abmux 0.0.7 → 0.0.9

package/README.md

@@ -1,14 +1,8 @@
 # abmux
 
-AI Board on tmux — A terminal UI for managing Claude Code sessions on tmux.
+AI Board on tmux — A TUI for managing multiple Claude Code sessions from a single terminal screen.
 
-## Features
-
-- Manage tmux sessions grouped by project
-- Detect Claude session status: waiting for input, thinking, running tools, idle
-- Launch new Claude Code sessions with prompts via your `$EDITOR`
-- Fuzzy search directories to add new sessions
-- CLI commands for scripting: `new`, `open`, `kill`, `list`
+Monitor, create, switch between, and delete Claude Code sessions running on tmux, all in one place.
 
 ## Requirements
 
@@ -19,34 +13,116 @@ AI Board on tmux — A terminal UI for managing Claude Code sessions on tmux.
 ## Install
 
 ```sh
-npm install -g abmux
-# or
-yarn global add abmux
-# or
 pnpm add -g abmux
 ```
 
-## Usage
+## Getting Started
 
 ```sh
-abmux                              # Start TUI
-abmux new <prompt> [--dir <path>]  # Create session and launch Claude
-abmux open [session]               # Attach to session
-abmux kill [session]               # Kill session
+abmux
+```
+
+Run without arguments to launch the TUI.
+
+CLI commands are also available for scripting:
+
+```sh
+abmux new <prompt> [--dir <path>]  # Create a session
+abmux open [session]               # Attach to a session
+abmux kill [session]               # Kill a session
 abmux list                         # List sessions
-abmux --help                       # Show help
 ```
 
+## Screen Layout
+
+The main screen is split into three panels:
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│ abmux - v0.0.x                                                  │
+├───────────────────────┬─────────────────────────────────────────┤
+│                       │                                         │
+│  Session List         │  Pane List                              │
+│  (Left Panel)         │  (Right Panel)                          │
+│                       │                                         │
+│  > my-project (cwd)   │    ⠋ [thinking] Refactoring...  %5     │
+│    other-project      │    ✳ [running]  Fixing tests    %8     │
+│                       │    ○ [idle]     Waiting         %12    │
+│                       │    ● vim                        %3     │
+│                       │                                         │
+├───────────────────────┴─────────────────────────────────────────┤
+│                                                                  │
+│  Session Overview (Bottom Panel)                                 │
+│  Summaries of what Claude is working on in each session          │
+│                                                                  │
+├──────────────────────────────────────────────────────────────────┤
+│ ↑/↓ move  Enter select  Tab next  n add  q quit    ● 2 thinking │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+Press `Tab` to cycle focus: Left → Right → Bottom. The focused panel is highlighted with a green border.
+
+## Panels
+
+### Left Panel: Session List
+
+Lists tmux sessions grouped by project directory. The session matching your current directory is marked with `(cwd)`.
+
+| Key           | Action                              |
+| ------------- | ----------------------------------- |
+| `↑` / `↓`     | Move cursor                         |
+| `Enter` / `→` | Select session, move to right panel |
+| `n`           | Add session via directory search    |
+| `d`           | Delete session                      |
+| `q`           | Quit                                |
+
+### Right Panel: Pane List
+
+Shows all panes in the selected session. Claude Code panes display their status; other panes (editors, shells) are also listed.
+
+| Key         | Action                          |
+| ----------- | ------------------------------- |
+| `↑` / `↓`   | Move cursor                     |
+| `Enter`     | Attach to pane (switch to tmux) |
+| `n`         | Create a new Claude session     |
+| `v`         | Open session in `$EDITOR`       |
+| `d`         | Kill pane                       |
+| `Esc` / `←` | Back to left panel              |
+
+### Bottom Panel: Session Overview
+
+Displays AI-generated summaries of what Claude is doing in each session. Auto-refreshes every 60 seconds.
+
+| Key         | Action             |
+| ----------- | ------------------ |
+| `↑` / `↓`   | Scroll             |
+| `Tab`       | Next panel         |
+| `Esc` / `←` | Back to left panel |
+
+## Status Icons
+
+The right panel and the status bar show Claude session states with these icons:
+
+| Icon          | Status   | Meaning                   |
+| ------------- | -------- | ------------------------- |
+| `⠋` (braille) | thinking | Claude is reasoning       |
+| `✳`           | running  | Executing a tool          |
+| `❓`          | confirm  | Waiting for user approval |
+| `❯`           | waiting  | Ready for input           |
+| `○`           | idle     | Idle                      |
+
+Non-Claude panes show `●` (busy) or `○` (available).
+
 ## Development
 
 ```sh
 pnpm install
-pnpm start        # Run in development mode (tsx)
-pnpm test         # Run tests with Vitest
-pnpm typecheck    # Type check without emitting
-pnpm lint:check   # Lint with oxlint
-pnpm format:check # Check formatting with oxfmt
-pnpm build        # Bundle with esbuild
+pnpm start        # Run in dev mode
+pnpm test         # Run tests
+pnpm typecheck    # Type check
+pnpm lint:check   # Lint
+pnpm format:check # Format check
+pnpm build        # Bundle
 ```
 
 ## License

package/dist/cli/index.js

@@ -532,7 +532,12 @@ var createManagerUsecase = (context) => {
   const { tmux, sessionDetection } = context.services;
   const windowTarget = (up) => `${up.pane.sessionName}:${String(up.pane.windowIndex)}`;
   return {
-    createSession: async ({ sessionName, cwd, prompt }) => {
+    createSession: async ({
+      sessionName,
+      cwd,
+      prompt,
+      worktree
+    }) => {
       const exists2 = await context.infra.tmuxCli.hasSession(sessionName);
       if (!exists2) {
         await context.infra.tmuxCli.newSession({ name: sessionName, cwd });
@@ -544,7 +549,8 @@ var createManagerUsecase = (context) => {
       const target = sessionPanes[0]?.paneId;
       if (!target) return;
       const escapedPrompt = escapeShellArg(prompt);
-      await tmux.sendCommand({ target, command: `claude -w -- ${escapedPrompt}` });
+      const worktreeFlag = worktree ? " -w" : "";
+      await tmux.sendCommand({ target, command: `claude${worktreeFlag} -- ${escapedPrompt}` });
     },
     list: async () => {
       const panes = await tmux.listPanes();
@@ -597,7 +603,7 @@ var createUsecases = (context) => ({
 // package.json
 var package_default = {
   name: "abmux",
-  version: "0.0.7",
+  version: "0.0.9",
   repository: {
     type: "git",
     url: "https://github.com/cut0/abmux.git"
@@ -667,8 +673,8 @@ import { createElement } from "react";
 
 // src/components/ManagerView.tsx
 import { basename as basename2 } from "node:path";
-import { Box as Box11 } from "ink";
-import { useCallback as useCallback4, useMemo as useMemo7, useRef as useRef3, useState as useState6 } from "react";
+import { Box as Box12, useInput as useInput8 } from "ink";
+import { useCallback as useCallback5, useMemo as useMemo7, useRef as useRef4, useState as useState8 } from "react";
 
 // src/components/shared/Header.tsx
 import { Box, Text } from "ink";
@@ -769,10 +775,11 @@ var SessionListPanel = ({
   onSelect,
   onCursorChange,
   onDeleteSession,
-  onAddSession
+  onAddSession,
+  cursorRef
 }) => {
   const { exit } = useApp();
-  const [cursor, setCursor] = useState(0);
+  const [cursor, setCursor] = useState(cursorRef?.current ?? 0);
   const sortedSessions = useMemo3(
     () => sortSessions(sessions, currentSession),
     [sessions, currentSession]
@@ -782,6 +789,7 @@ var SessionListPanel = ({
   if (clampedCursor !== cursor) {
     setCursor(clampedCursor);
   }
+  if (cursorRef) cursorRef.current = clampedCursor;
   const reservedLines = 1;
   const { scrollOffset, visibleCount } = useScroll(
     clampedCursor,
@@ -855,6 +863,7 @@ var SessionListPanel = ({
 
 // src/components/PaneListPanel.tsx
 import { Box as Box6, Text as Text6 } from "ink";
+import { useRef as useRef2 } from "react";
 
 // src/components/PaneListView.tsx
 import { Box as Box5, Text as Text5, useApp as useApp2, useInput as useInput2 } from "ink";
@@ -902,16 +911,19 @@ var PaneListView = ({
   onUnhighlight,
   onBack,
   onNewSession,
-  onKillPane
+  onOpenEditor,
+  onKillPane,
+  cursorRef
 }) => {
   const { exit } = useApp2();
-  const [cursor, setCursor] = useState2(0);
+  const [cursor, setCursor] = useState2(cursorRef?.current ?? 0);
   const highlightedRef = useRef(void 0);
   const panes = useMemo4(() => group.tabs.flatMap((t) => t.panes), [group]);
   const clampedCursor = cursor >= panes.length ? Math.max(0, panes.length - 1) : cursor;
   if (clampedCursor !== cursor) {
     setCursor(clampedCursor);
   }
+  if (cursorRef) cursorRef.current = clampedCursor;
   const reservedLines = 1;
   const { scrollOffset, visibleCount } = useScroll(
     clampedCursor,
@@ -980,6 +992,10 @@ var PaneListView = ({
         onNewSession(selectedSession);
         return;
       }
+      if (input === "v") {
+        onOpenEditor(selectedSession);
+        return;
+      }
       if (key.return) {
         const pane = panes[clampedCursor];
         if (pane) onNavigate(pane);
@@ -1000,7 +1016,7 @@ var PaneListView = ({
         ")"
       ] })
     ] }),
-    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: panes.length === 0 ? /* @__PURE__ */ jsx5(Box5, { paddingLeft: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "No panes. Press n to create." }) }) : visiblePanes.map((up, i) => /* @__PURE__ */ jsx5(
+    /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: panes.length === 0 ? /* @__PURE__ */ jsx5(Box5, { paddingLeft: 1, children: /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "No panes. Press n or v to create." }) }) : visiblePanes.map((up, i) => /* @__PURE__ */ jsx5(
       PaneItem,
       {
         unifiedPane: up,
@@ -1023,8 +1039,15 @@ var PaneListPanel = ({
   onUnhighlight,
   onBack,
   onNewSession,
-  onKillPane
+  onOpenEditor,
+  onKillPane,
+  cursorRef
 }) => {
+  const prevSessionRef = useRef2(selectedSession);
+  if (prevSessionRef.current !== selectedSession) {
+    prevSessionRef.current = selectedSession;
+    if (cursorRef) cursorRef.current = 0;
+  }
   if (!selectedSession) {
     return /* @__PURE__ */ jsx6(Box6, { paddingLeft: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No session selected" }) });
   }
@@ -1040,7 +1063,9 @@ var PaneListPanel = ({
       onUnhighlight,
       onBack,
       onNewSession,
-      onKillPane
+      onOpenEditor,
+      onKillPane,
+      cursorRef
     },
     selectedSession
   );
@@ -1058,10 +1083,11 @@ var SessionOverviewPanel = ({
   isLoading,
   isFocused,
   availableRows,
-  onBack
+  onBack,
+  cursorRef
 }) => {
   const { exit } = useApp3();
-  const [cursor, setCursor] = useState3(0);
+  const [cursor, setCursor] = useState3(cursorRef?.current ?? 0);
   const lines = useMemo5(() => {
     const summaryLines = overallSummary ? [
       { key: "summary", type: "summary", text: overallSummary },
@@ -1094,6 +1120,7 @@ var SessionOverviewPanel = ({
     return [...summaryLines, ...sessionLines];
   }, [overallSummary, items, groups]);
   const clampedCursor = cursor >= lines.length ? Math.max(0, lines.length - 1) : cursor;
+  if (cursorRef) cursorRef.current = clampedCursor;
   const reservedLines = 3;
   const { scrollOffset, visibleCount } = useScroll(
     clampedCursor,
@@ -1170,6 +1197,7 @@ var SessionOverviewPanel = ({
 
 // src/components/ConfirmView.tsx
 import { Box as Box8, Text as Text8, useInput as useInput4 } from "ink";
+import { useCallback as useCallback4, useState as useState5 } from "react";
 
 // src/hooks/use-terminal-size.ts
 import { useStdout } from "ink";
@@ -1199,20 +1227,35 @@ var useTerminalSize = () => {
 import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
 var ConfirmView = ({ selectedDir, prompt, onConfirm, onCancel }) => {
   const { rows } = useTerminalSize();
+  const [worktree, setWorktree] = useState5(true);
   const previewLines = prompt.split("\n");
-  const maxPreview = Math.min(previewLines.length, rows - 6);
+  const maxPreview = Math.min(previewLines.length, rows - 7);
+  const handleToggleWorktree = useCallback4(() => {
+    setWorktree((prev) => !prev);
+  }, []);
   useInput4((_input, key) => {
     if (key.return) {
-      onConfirm();
+      onConfirm({ worktree });
       return;
     }
     if (key.escape) {
       onCancel();
+      return;
+    }
+    if (key.tab) {
+      handleToggleWorktree();
     }
   });
   return /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", height: rows, children: [
     /* @__PURE__ */ jsx8(Header, { title: `${APP_TITLE} \u2014 ${selectedDir}` }),
-    /* @__PURE__ */ jsx8(Box8, { marginBottom: 1, children: /* @__PURE__ */ jsx8(Text8, { bold: true, children: "New Claude session:" }) }),
+    /* @__PURE__ */ jsxs6(Box8, { marginBottom: 1, gap: 2, children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, children: "New Claude session:" }),
+      /* @__PURE__ */ jsxs6(Text8, { color: worktree ? "green" : "gray", children: [
+        "worktree: [",
+        worktree ? "ON" : "OFF",
+        "]"
+      ] })
+    ] }),
     /* @__PURE__ */ jsxs6(Box8, { flexDirection: "column", flexGrow: 1, overflow: "hidden", paddingLeft: 2, children: [
       previewLines.slice(0, maxPreview).map((line, i) => /* @__PURE__ */ jsx8(Text8, { color: "white", children: line }, i)),
       previewLines.length > maxPreview && /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
@@ -1223,6 +1266,7 @@ var ConfirmView = ({ selectedDir, prompt, onConfirm, onCancel }) => {
     ] }),
     /* @__PURE__ */ jsxs6(Box8, { gap: 2, children: [
       /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Enter confirm" }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Tab worktree" }),
       /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Esc cancel" })
     ] })
   ] });
@@ -1266,7 +1310,7 @@ var DeleteSessionView = ({ sessionName, paneCount, onConfirm, onCancel }) => {
 
 // src/components/DirectorySearchView.tsx
 import { Box as Box10, Text as Text10, useInput as useInput6 } from "ink";
-import { useMemo as useMemo6, useState as useState5 } from "react";
+import { useMemo as useMemo6, useState as useState6 } from "react";
 import { basename } from "node:path";
 import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 var formatPath = (path) => {
@@ -1278,8 +1322,8 @@ var formatPath = (path) => {
 };
 var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
   const { rows } = useTerminalSize();
-  const [query, setQuery] = useState5("");
-  const [cursor, setCursor] = useState5(0);
+  const [query, setQuery] = useState6("");
+  const [cursor, setCursor] = useState6(0);
   const filtered = useMemo6(() => {
     if (!query) return directories;
     const lower = query.toLowerCase();
@@ -1354,10 +1398,53 @@ var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
   ] });
 };
 
+// src/components/PromptInputView.tsx
+import { Box as Box11, Text as Text11, useInput as useInput7 } from "ink";
+import { useState as useState7 } from "react";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
+var PromptInputView = ({ selectedDir, onSubmit, onCancel }) => {
+  const { rows } = useTerminalSize();
+  const [value, setValue] = useState7("");
+  useInput7((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      const trimmed = value.trim();
+      if (trimmed) onSubmit(trimmed);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setValue((prev) => prev.slice(0, -1));
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      setValue((prev) => prev + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} \u2014 ${selectedDir}` }),
+    /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { bold: true, children: "New prompt:" }) }),
+    /* @__PURE__ */ jsxs9(Box11, { paddingLeft: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsxs9(Text11, { color: "green", children: [
+        ">",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx11(Text11, { children: value }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: value ? "" : "type your prompt..." })
+    ] }),
+    /* @__PURE__ */ jsxs9(Box11, { gap: 2, children: [
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Enter submit" }),
+      /* @__PURE__ */ jsx11(Text11, { dimColor: true, children: "Esc cancel" })
+    ] })
+  ] });
+};
+
 // src/hooks/use-interval.ts
-import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useEffect as useEffect2, useRef as useRef3 } from "react";
 var useInterval = (fn, intervalMs, enabled = true) => {
-  const fnRef = useRef2(fn);
+  const fnRef = useRef3(fn);
   fnRef.current = fn;
   useEffect2(() => {
     if (!enabled) return;
@@ -1380,13 +1467,7 @@ var swallow = async (fn) => {
 };
 
 // src/components/ManagerView.tsx
-import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
-var MODE = {
-  split: "split",
-  confirm: "confirm",
-  deleteSession: "deleteSession",
-  addSession: "addSession"
-};
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 var FOCUS = {
   left: "left",
   right: "right",
@@ -1394,65 +1475,91 @@ var FOCUS = {
 };
 var POLL_INTERVAL = 3e3;
 var OVERVIEW_POLL_INTERVAL = 6e4;
+var FIXED_ROWS = 3;
+var TOP_HEIGHT_RATIO = 1 / 2;
+var LEFT_WIDTH_RATIO = 1 / 3;
+var initState = (remountState) => {
+  const snapshot = remountState?.snapshot;
+  return {
+    view: remountState?.prompt ? { mode: "confirm", prompt: remountState.prompt, cwd: remountState.cwd ?? "" } : { mode: "split" },
+    focus: snapshot?.focus ?? FOCUS.left,
+    selectedSession: remountState?.session ?? snapshot?.selectedSession,
+    sessions: [],
+    sessionsLoading: true,
+    overviewResult: snapshot?.overviewResult
+  };
+};
 var ManagerView = ({
   actions,
   currentSession,
   directories,
-  restoredPrompt,
-  restoredSession,
-  restoredCwd
+  remountState,
+  snapshotRef
 }) => {
   const { rows, columns } = useTerminalSize();
-  const [sessionsState, setSessionsState] = useState6({
-    sessions: [],
-    isLoading: true
+  const [state, setState] = useState8(() => initState(remountState));
+  const overviewInFlightRef = useRef4(false);
+  const snapshot = remountState?.snapshot;
+  const cursorsRef = useRef4({
+    session: { current: snapshot?.sessionListCursor ?? 0 },
+    pane: { current: snapshot?.paneListCursor ?? 0 },
+    overview: { current: snapshot?.overviewCursor ?? 0 }
   });
-  const [mode, setMode] = useState6(restoredPrompt ? MODE.confirm : MODE.split);
-  const [focus, setFocus] = useState6(FOCUS.left);
-  const [selectedSession, setSelectedSession] = useState6(restoredSession);
-  const [pendingPrompt, setPendingPrompt] = useState6(restoredPrompt ?? "");
-  const [pendingDeleteSession, setPendingDeleteSession] = useState6(void 0);
-  const [overviewResult, setOverviewResult] = useState6({
-    overallSummary: "",
-    sessions: []
-  });
-  const [overviewLoading, setOverviewLoading] = useState6(true);
-  const overviewInFlightRef = useRef3(false);
-  const refresh = useCallback4(async () => {
+  const patch = useCallback5((partial) => {
+    setState((prev) => ({ ...prev, ...partial }));
+  }, []);
+  const refresh = useCallback5(async () => {
     try {
       const fetched = await actions.fetchSessions();
-      setSessionsState((prev) => {
+      setState((prev) => {
         const fetchedNames = new Set(fetched.map((s) => s.name));
         const userOnly = prev.sessions.filter(
           (s) => !fetchedNames.has(s.name) && s.groups.length === 0
         );
-        return { sessions: [...userOnly, ...fetched], isLoading: false };
+        return { ...prev, sessions: [...userOnly, ...fetched], sessionsLoading: false };
       });
     } catch {
-      setSessionsState((prev) => ({ ...prev, isLoading: false }));
+      patch({ sessionsLoading: false });
     }
-  }, [actions]);
+  }, [actions, patch]);
   useInterval(() => void refresh(), POLL_INTERVAL);
   useInterval(
     () => {
       if (overviewInFlightRef.current) return;
       overviewInFlightRef.current = true;
-      setOverviewLoading(true);
-      void actions.fetchOverview(sessionsState.sessions).then((result) => {
-        setOverviewResult(result);
+      void actions.fetchOverview(state.sessions).then((result) => {
+        patch({ overviewResult: result });
       }).catch(() => {
       }).finally(() => {
-        setOverviewLoading(false);
         overviewInFlightRef.current = false;
       });
     },
     OVERVIEW_POLL_INTERVAL,
-    !sessionsState.isLoading
+    !state.sessionsLoading
   );
-  const resolvedSession = selectedSession ?? sessionsState.sessions[0]?.name;
+  useInput8(
+    (_input, key) => {
+      if (key.tab) {
+        setState((prev) => {
+          const next = prev.focus === FOCUS.left ? FOCUS.right : prev.focus === FOCUS.right ? FOCUS.bottom : FOCUS.left;
+          return { ...prev, focus: next };
+        });
+      }
+    },
+    { isActive: state.view.mode === "split" }
+  );
+  const resolvedSession = state.selectedSession ?? state.sessions[0]?.name;
+  snapshotRef.current = {
+    focus: state.focus,
+    selectedSession: resolvedSession,
+    sessionListCursor: cursorsRef.current.session.current,
+    paneListCursor: cursorsRef.current.pane.current,
+    overviewCursor: cursorsRef.current.overview.current,
+    overviewResult: state.overviewResult ?? { overallSummary: "", sessions: [] }
+  };
   const selectedManagedSession = useMemo7(
-    () => sessionsState.sessions.find((s) => s.name === resolvedSession),
-    [sessionsState.sessions, resolvedSession]
+    () => state.sessions.find((s) => s.name === resolvedSession),
+    [state.sessions, resolvedSession]
   );
   const selectedGroup = useMemo7(() => {
     if (!selectedManagedSession) return void 0;
@@ -1461,10 +1568,7 @@ var ManagerView = ({
       tabs: selectedManagedSession.groups.flatMap((g) => g.tabs)
     };
   }, [selectedManagedSession]);
-  const allGroups = useMemo7(
-    () => sessionsState.sessions.flatMap((s) => s.groups),
-    [sessionsState.sessions]
-  );
+  const allGroups = useMemo7(() => state.sessions.flatMap((s) => s.groups), [state.sessions]);
   const statusCounts = useMemo7(
     () => allGroups.flatMap((g) => g.tabs).flatMap((t) => t.panes).filter((p) => p.kind === "claude" && p.claudeStatus).reduce((acc, p) => {
       const s = p.claudeStatus;
@@ -1474,53 +1578,54 @@ var ManagerView = ({
     }, {}),
     [allGroups]
   );
-  const handleOpenAddSession = useCallback4(() => {
-    setMode(MODE.addSession);
-  }, []);
-  const handleAddSessionSelect = useCallback4((path) => {
+  const handleOpenAddSession = useCallback5(() => {
+    patch({ view: { mode: "addSession" } });
+  }, [patch]);
+  const handleAddSessionSelect = useCallback5((path) => {
     const name = basename2(path);
-    setSessionsState((prev) => {
+    setState((prev) => {
       const exists2 = prev.sessions.some((s) => s.name === name);
-      if (exists2) return prev;
       return {
         ...prev,
-        sessions: [{ name, path, groups: [] }, ...prev.sessions]
+        view: { mode: "split" },
+        selectedSession: name,
+        sessions: exists2 ? prev.sessions : [{ name, path, groups: [] }, ...prev.sessions]
       };
     });
-    setSelectedSession(name);
-    setMode(MODE.split);
-  }, []);
-  const handleCancelAddSession = useCallback4(() => {
-    setMode(MODE.split);
-  }, []);
-  const handleDeleteSession = useCallback4((name) => {
-    setPendingDeleteSession(name);
-    setMode(MODE.deleteSession);
   }, []);
-  const handleConfirmDelete = useCallback4(() => {
-    if (!pendingDeleteSession) return;
-    const session = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
-    setSessionsState((prev) => ({
+  const handleCancelAddSession = useCallback5(() => {
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleDeleteSession = useCallback5(
+    (name) => {
+      patch({ view: { mode: "deleteSession", sessionName: name } });
+    },
+    [patch]
+  );
+  const handleConfirmDelete = useCallback5(() => {
+    if (state.view.mode !== "deleteSession") return;
+    const { sessionName } = state.view;
+    const session = state.sessions.find((s) => s.name === sessionName);
+    setState((prev) => ({
       ...prev,
-      sessions: prev.sessions.filter((s) => s.name !== pendingDeleteSession)
+      view: { mode: "split" },
+      sessions: prev.sessions.filter((s) => s.name !== sessionName),
+      selectedSession: prev.selectedSession === sessionName ? void 0 : prev.selectedSession
     }));
-    if (resolvedSession === pendingDeleteSession) {
-      setSelectedSession(void 0);
-    }
     if (session) {
       const killAll = Promise.all(
         session.groups.map((g) => swallow(() => actions.killSession(g.sessionName)))
       );
       void killAll.then(() => void refresh());
     }
-    setPendingDeleteSession(void 0);
-    setMode(MODE.split);
-  }, [pendingDeleteSession, resolvedSession, sessionsState.sessions, actions, refresh]);
-  const handleCancelDelete = useCallback4(() => {
-    setPendingDeleteSession(void 0);
-    setMode(MODE.split);
-  }, []);
-  const handleNewSession = useCallback4(
+  }, [state.view, state.sessions, actions, refresh]);
+  const handleCancelDelete = useCallback5(() => {
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleNewSession = useCallback5(() => {
+    patch({ view: { mode: "promptInput" } });
+  }, [patch]);
+  const handleOpenEditor = useCallback5(
     (sessionName) => {
       const cwd = selectedManagedSession?.path;
       if (!cwd) return;
@@ -1528,61 +1633,77 @@ var ManagerView = ({
     },
     [actions, selectedManagedSession]
   );
-  const handleConfirmNew = useCallback4(() => {
-    if (!resolvedSession) return;
-    const cwd = restoredCwd ?? selectedManagedSession?.path;
-    if (!cwd) return;
-    void actions.createSession(resolvedSession, cwd, pendingPrompt).then(() => void refresh());
-    setPendingPrompt("");
-    setMode(MODE.split);
-  }, [resolvedSession, restoredCwd, selectedManagedSession, pendingPrompt, actions, refresh]);
-  const handleCancelConfirm = useCallback4(() => {
-    setPendingPrompt("");
-    setMode(MODE.split);
-  }, []);
-  const handleSessionSelect = useCallback4((name) => {
-    setSelectedSession(name);
-    setFocus(FOCUS.right);
-  }, []);
-  const handleSessionCursorChange = useCallback4((name) => {
-    setSelectedSession(name);
-  }, []);
-  const handleNavigate = useCallback4(
+  const handlePromptInputSubmit = useCallback5(
+    (prompt) => {
+      const cwd = selectedManagedSession?.path;
+      if (!cwd) return;
+      patch({ view: { mode: "confirm", prompt, cwd } });
+    },
+    [patch, selectedManagedSession]
+  );
+  const handlePromptInputCancel = useCallback5(() => {
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleConfirmNew = useCallback5(
+    ({ worktree }) => {
+      if (state.view.mode !== "confirm") return;
+      if (!resolvedSession) return;
+      void actions.createSession(resolvedSession, state.view.cwd, state.view.prompt, worktree).then(() => void refresh());
+      patch({ view: { mode: "split" } });
+    },
+    [state.view, resolvedSession, actions, refresh, patch]
+  );
+  const handleCancelConfirm = useCallback5(() => {
+    patch({ view: { mode: "split" } });
+  }, [patch]);
+  const handleSessionSelect = useCallback5(
+    (name) => {
+      patch({ selectedSession: name, focus: FOCUS.right });
+    },
+    [patch]
+  );
+  const handleSessionCursorChange = useCallback5(
+    (name) => {
+      patch({ selectedSession: name });
+    },
+    [patch]
+  );
+  const handleNavigate = useCallback5(
     (up) => {
       void actions.navigateToPane(up);
     },
     [actions]
   );
-  const handleBack = useCallback4(() => {
-    setFocus(FOCUS.left);
-  }, []);
-  const handleKillPane = useCallback4(
+  const handleBack = useCallback5(() => {
+    patch({ focus: FOCUS.left });
+  }, [patch]);
+  const handleKillPane = useCallback5(
     async (paneId) => {
       await swallow(() => actions.killPane(paneId));
       void refresh();
     },
     [actions, refresh]
   );
-  const handleHighlight = useCallback4(
+  const handleHighlight = useCallback5(
     async (up) => {
       await swallow(() => actions.highlightWindow(up));
     },
     [actions]
   );
-  const handleUnhighlight = useCallback4(
+  const handleUnhighlight = useCallback5(
     async (up) => {
       await swallow(() => actions.unhighlightWindow(up));
     },
     [actions]
   );
-  if (sessionsState.isLoading) {
-    return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
-      /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
-      /* @__PURE__ */ jsx11(StatusBar, { message: "Loading...", type: "info" })
+  if (state.sessionsLoading) {
+    return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsx12(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
+      /* @__PURE__ */ jsx12(StatusBar, { message: "Loading...", type: "info" })
     ] });
   }
-  if (mode === MODE.addSession) {
-    return /* @__PURE__ */ jsx11(
+  if (state.view.mode === "addSession") {
+    return /* @__PURE__ */ jsx12(
       DirectorySearchView,
       {
         directories,
@@ -1591,105 +1712,119 @@ var ManagerView = ({
       }
     );
   }
-  if (mode === MODE.deleteSession && pendingDeleteSession) {
-    const deleteSession = sessionsState.sessions.find((s) => s.name === pendingDeleteSession);
+  if (state.view.mode === "deleteSession") {
+    const { sessionName } = state.view;
+    const deleteSession = state.sessions.find((s) => s.name === sessionName);
     const paneCount = deleteSession?.groups.reduce(
       (sum, g) => sum + g.tabs.reduce((s, t) => s + t.panes.length, 0),
       0
     ) ?? 0;
-    return /* @__PURE__ */ jsx11(
+    return /* @__PURE__ */ jsx12(
       DeleteSessionView,
       {
-        sessionName: pendingDeleteSession,
+        sessionName,
         paneCount,
         onConfirm: handleConfirmDelete,
         onCancel: handleCancelDelete
       }
     );
   }
-  if (mode === MODE.confirm && pendingPrompt) {
-    return /* @__PURE__ */ jsx11(
+  if (state.view.mode === "promptInput") {
+    return /* @__PURE__ */ jsx12(
+      PromptInputView,
+      {
+        selectedDir: resolvedSession ?? "",
+        onSubmit: handlePromptInputSubmit,
+        onCancel: handlePromptInputCancel
+      }
+    );
+  }
+  if (state.view.mode === "confirm") {
+    return /* @__PURE__ */ jsx12(
       ConfirmView,
       {
         selectedDir: resolvedSession ?? "",
-        prompt: pendingPrompt,
+        prompt: state.view.prompt,
         onConfirm: handleConfirmNew,
         onCancel: handleCancelConfirm
       }
     );
   }
-  const fixedRows = 3;
-  const contentHeight = rows - fixedRows;
-  const topHeight = Math.floor(contentHeight / 2);
+  const contentHeight = rows - FIXED_ROWS;
+  const topHeight = Math.floor(contentHeight * TOP_HEIGHT_RATIO);
   const bottomHeight = contentHeight - topHeight;
-  const leftWidth = Math.floor(columns / 3);
+  const leftWidth = Math.floor(columns * LEFT_WIDTH_RATIO);
   const rightWidth = columns - leftWidth;
-  return /* @__PURE__ */ jsxs9(Box11, { flexDirection: "column", height: rows, children: [
-    /* @__PURE__ */ jsx11(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
-    /* @__PURE__ */ jsxs9(Box11, { flexDirection: "row", height: topHeight, children: [
-      /* @__PURE__ */ jsx11(
-        Box11,
+  return /* @__PURE__ */ jsxs10(Box12, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx12(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
+    /* @__PURE__ */ jsxs10(Box12, { flexDirection: "row", height: topHeight, children: [
+      /* @__PURE__ */ jsx12(
+        Box12,
         {
           flexDirection: "column",
           width: leftWidth,
           borderStyle: "round",
-          borderColor: focus === FOCUS.left ? "green" : "gray",
-          children: /* @__PURE__ */ jsx11(
+          borderColor: state.focus === FOCUS.left ? "green" : "gray",
+          children: /* @__PURE__ */ jsx12(
             SessionListPanel,
             {
-              sessions: sessionsState.sessions,
+              sessions: state.sessions,
               currentSession,
-              isFocused: focus === FOCUS.left,
+              isFocused: state.focus === FOCUS.left,
               availableRows: topHeight - 2,
               onSelect: handleSessionSelect,
               onCursorChange: handleSessionCursorChange,
               onDeleteSession: handleDeleteSession,
-              onAddSession: handleOpenAddSession
+              onAddSession: handleOpenAddSession,
+              cursorRef: cursorsRef.current.session
             }
           )
         }
       ),
-      /* @__PURE__ */ jsx11(
-        Box11,
+      /* @__PURE__ */ jsx12(
+        Box12,
         {
           flexDirection: "column",
           width: rightWidth,
           borderStyle: "round",
-          borderColor: focus === FOCUS.right ? "green" : "gray",
-          children: /* @__PURE__ */ jsx11(
+          borderColor: state.focus === FOCUS.right ? "green" : "gray",
+          children: /* @__PURE__ */ jsx12(
             PaneListPanel,
             {
               selectedSession: resolvedSession,
               group: selectedGroup,
-              isFocused: focus === FOCUS.right,
+              isFocused: state.focus === FOCUS.right,
               availableRows: topHeight - 2,
               onNavigate: handleNavigate,
               onHighlight: handleHighlight,
               onUnhighlight: handleUnhighlight,
               onBack: handleBack,
               onNewSession: handleNewSession,
-              onKillPane: handleKillPane
+              onOpenEditor: handleOpenEditor,
+              onKillPane: handleKillPane,
+              cursorRef: cursorsRef.current.pane
             }
           )
         }
       )
     ] }),
-    /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(
       SessionOverviewPanel,
       {
-        overallSummary: overviewResult.overallSummary,
-        items: overviewResult.sessions,
+        overallSummary: state.overviewResult?.overallSummary ?? "",
+        items: state.overviewResult?.sessions ?? [],
         groups: allGroups,
-        isLoading: overviewLoading,
-        isFocused: focus === FOCUS.bottom,
+        isLoading: !state.overviewResult,
+        isFocused: state.focus === FOCUS.bottom,
         availableRows: bottomHeight,
-        onBack: handleBack
+        onBack: handleBack,
+        cursorRef: cursorsRef.current.overview
       }
     ),
-    /* @__PURE__ */ jsx11(
+    /* @__PURE__ */ jsx12(
       StatusBar,
       {
-        message: focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  n add  d delete  q quit" : focus === FOCUS.right ? "\u2191/\u2193 move  Enter focus  n new  d kill  Esc/\u2190 back  q quit" : "\u2191/\u2193 scroll  Esc/\u2190 back  q quit",
+        message: state.focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  Tab next  n add  d delete  q quit" : state.focus === FOCUS.right ? "\u2191/\u2193 move  Enter focus  Tab next  n new  v vim  d kill  Esc/\u2190 back  q quit" : "\u2191/\u2193 scroll  Tab next  Esc/\u2190 back  q quit",
         statusCounts
       }
     )
@@ -1700,9 +1835,8 @@ var ManagerView = ({
 var createTuiCommand = ({ usecases, services, infra }) => async () => {
   const directories = await services.directoryScan.scan();
   let instance;
-  let pendingPrompt;
-  let pendingSession;
-  let pendingCwd;
+  const snapshotRef = { current: void 0 };
+  let remountState;
   const actions = {
     fetchSessions: async () => {
       const result = await usecases.manager.list();
@@ -1736,8 +1870,8 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
       const groups = sessions.flatMap((s) => s.groups);
       return await usecases.manager.fetchOverview(groups);
     },
-    createSession: async (sessionName, cwd, prompt) => {
-      await usecases.manager.createSession({ sessionName, cwd, prompt });
+    createSession: async (sessionName, cwd, prompt, worktree) => {
+      await usecases.manager.createSession({ sessionName, cwd, prompt, worktree });
     },
     killSession: async (sessionName) => {
       await usecases.manager.killSession(sessionName);
@@ -1752,11 +1886,10 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
       await usecases.manager.unhighlightWindow(up);
     },
     openEditor: (sessionName, cwd) => {
+      const snapshot = snapshotRef.current;
       instance.unmount();
       const prompt = infra.editor.open();
-      pendingPrompt = prompt;
-      pendingSession = sessionName;
-      pendingCwd = cwd;
+      remountState = { prompt, session: sessionName, cwd, snapshot };
       instance = renderApp();
       return prompt;
     },
@@ -1764,18 +1897,17 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
       const target = `${up.pane.sessionName}:${String(up.pane.windowIndex)}`;
       await infra.tmuxCli.selectWindow(target);
       await infra.tmuxCli.selectPane(up.pane.paneId);
+      const snapshot = snapshotRef.current;
       instance.unmount();
       await infra.tmuxCli.attachSession(up.pane.sessionName);
+      remountState = { snapshot };
       instance = renderApp();
     }
   };
   const renderApp = () => {
-    const prompt = pendingPrompt;
-    const session = pendingSession;
-    const cwd = pendingCwd;
-    pendingPrompt = void 0;
-    pendingSession = void 0;
-    pendingCwd = void 0;
+    const state = remountState;
+    remountState = void 0;
+    snapshotRef.current = void 0;
     const rawCwd = process.cwd();
     const currentSession = basename3(findMatchingDirectory(rawCwd, directories) ?? rawCwd);
     return render(
@@ -1783,9 +1915,8 @@ var createTuiCommand = ({ usecases, services, infra }) => async () => {
         actions,
         currentSession,
         directories,
-        restoredPrompt: prompt,
-        restoredSession: session,
-        restoredCwd: cwd
+        remountState: state,
+        snapshotRef
       }),
       { concurrent: true }
     );
@@ -1801,18 +1932,20 @@ var createNewCommand = ({ usecases }) => async (args) => {
   const { values, positionals } = parseArgs({
     args,
     options: {
-      dir: { type: "string" }
+      dir: { type: "string" },
+      worktree: { type: "boolean", default: true }
     },
     allowPositionals: true
   });
   const prompt = positionals[0];
   if (!prompt) {
-    console.error("Usage: abmux new <prompt> [--dir <path>]");
+    console.error("Usage: abmux new <prompt> [--dir <path>] [--no-worktree]");
     process.exit(1);
   }
   const dir = values.dir ?? process.cwd();
   const sessionName = basename4(dir);
-  await usecases.manager.createSession({ sessionName, cwd: dir, prompt });
+  const worktree = values.worktree ?? true;
+  await usecases.manager.createSession({ sessionName, cwd: dir, prompt, worktree });
   console.log(`Session "${sessionName}" created.`);
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abmux",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "repository": {
     "type": "git",
     "url": "https://github.com/cut0/abmux.git"