abmux 0.0.1

package/dist/cli/index.js

@@ -0,0 +1,1514 @@
+#!/usr/bin/env node
+
+// src/infra/tmux-cli.ts
+import { execFile, execFileSync, spawnSync } from "node:child_process";
+var resolveTmuxPath = () => {
+  try {
+    return execFileSync("which", ["tmux"], { encoding: "utf-8" }).trim();
+  } catch {
+    return "tmux";
+  }
+};
+var tmuxPath = resolveTmuxPath();
+var DELIMITER = "	";
+var PANE_FORMAT = [
+  "#{session_name}",
+  "#{window_index}",
+  "#{pane_index}",
+  "#{pane_id}",
+  "#{pane_current_path}",
+  "#{pane_title}",
+  "#{window_name}",
+  "#{pane_active}",
+  "#{pane_width}",
+  "#{pane_height}"
+].join(DELIMITER);
+var execTmux = (args) => new Promise((resolve, reject) => {
+  execFile(tmuxPath, args, (error, stdout, stderr) => {
+    if (error) {
+      reject(new Error(`tmux ${args[0]} failed: ${stderr || error.message}`));
+      return;
+    }
+    resolve(stdout.trim());
+  });
+});
+var parsePaneLine = (line) => {
+  const parts = line.split(DELIMITER);
+  if (parts.length < 10) return void 0;
+  return {
+    sessionName: parts[0] ?? "",
+    windowIndex: parseInt(parts[1] ?? "0", 10),
+    paneIndex: parseInt(parts[2] ?? "0", 10),
+    paneId: parts[3] ?? "",
+    cwd: parts[4] ?? "",
+    title: parts[5] ?? "",
+    windowName: parts[6] ?? "",
+    isActive: parts[7] === "1",
+    paneWidth: parseInt(parts[8] ?? "0", 10),
+    paneHeight: parseInt(parts[9] ?? "0", 10)
+  };
+};
+var createTmuxCli = () => ({
+  listPanes: async () => {
+    try {
+      const output = await execTmux(["list-panes", "-a", "-F", PANE_FORMAT]);
+      if (!output) return [];
+      return output.split("\n").map(parsePaneLine).filter((p) => p !== void 0);
+    } catch {
+      return [];
+    }
+  },
+  newSession: async (input) => {
+    const args = ["new-session", "-d", "-s", input.name, "-P", "-F", "#{session_name}"];
+    if (input.cwd) {
+      args.push("-c", input.cwd);
+    }
+    return await execTmux(args);
+  },
+  newWindow: async (input) => {
+    const args = ["new-window", "-t", input.target];
+    if (input.cwd) {
+      args.push("-c", input.cwd);
+    }
+    if (input.command) {
+      args.push(...input.command);
+    }
+    await execTmux(args);
+  },
+  splitWindow: async (input) => {
+    const flag = input.direction === "h" ? "-h" : "-v";
+    const args = ["split-window", flag, "-t", input.target];
+    if (input.cwd) {
+      args.push("-c", input.cwd);
+    }
+    await execTmux(args);
+  },
+  sendKeys: async (input) => {
+    await execTmux(["send-keys", "-t", input.target, input.keys, "Enter"]);
+  },
+  capturePane: async (target) => {
+    return await execTmux(["capture-pane", "-t", target, "-p"]);
+  },
+  selectPane: async (target) => {
+    await execTmux(["select-pane", "-t", target]);
+  },
+  selectWindow: async (target) => {
+    await execTmux(["select-window", "-t", target]);
+  },
+  renameWindow: async (input) => {
+    await execTmux(["rename-window", "-t", input.target, input.name]);
+  },
+  attachSession: async (sessionName) => {
+    spawnSync(tmuxPath, ["attach-session", "-t", sessionName], {
+      stdio: "inherit"
+    });
+  },
+  killPane: async (target) => {
+    await execTmux(["kill-pane", "-t", target]);
+  },
+  killSession: async (sessionName) => {
+    await execTmux(["kill-session", "-t", sessionName]);
+  },
+  hasSession: async (name) => {
+    try {
+      await execTmux(["has-session", "-t", name]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+});
+
+// src/infra/editor.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { writeFileSync, readFileSync, unlinkSync, mkdtempSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+var createEditor = () => ({
+  open: () => {
+    const dir = mkdtempSync(join(tmpdir(), "abmux-"));
+    const filePath = join(dir, "PROMPT.md");
+    writeFileSync(filePath, "", "utf-8");
+    const editor = process.env["EDITOR"] ?? "vim";
+    const result = spawnSync2(editor, [filePath], {
+      stdio: "inherit"
+    });
+    if (result.status !== 0) return void 0;
+    try {
+      const content = readFileSync(filePath, "utf-8").trim();
+      unlinkSync(filePath);
+      return content || void 0;
+    } catch {
+      return void 0;
+    }
+  }
+});
+
+// src/infra/index.ts
+var createInfra = () => ({
+  tmuxCli: createTmuxCli(),
+  editor: createEditor()
+});
+
+// src/models/session.ts
+var SESSION_STATUS = {
+  waitingInput: "waiting-input",
+  waitingConfirm: "waiting-confirm",
+  thinking: "thinking",
+  toolRunning: "tool-running",
+  idle: "idle"
+};
+var SESSION_STATUS_LABEL = {
+  [SESSION_STATUS.waitingInput]: "waiting",
+  [SESSION_STATUS.waitingConfirm]: "confirm",
+  [SESSION_STATUS.thinking]: "thinking",
+  [SESSION_STATUS.toolRunning]: "running",
+  [SESSION_STATUS.idle]: "idle"
+};
+var SESSION_STATUS_COLOR = {
+  [SESSION_STATUS.waitingInput]: "green",
+  [SESSION_STATUS.waitingConfirm]: "yellow",
+  [SESSION_STATUS.thinking]: "blue",
+  [SESSION_STATUS.toolRunning]: "magenta",
+  [SESSION_STATUS.idle]: "gray"
+};
+var PANE_KIND = {
+  claude: "claude",
+  available: "available",
+  busy: "busy"
+};
+
+// src/services/session-detection-service.ts
+var BUSY_TITLES = /* @__PURE__ */ new Set([
+  "nvim",
+  "vim",
+  "vi",
+  "node",
+  "python",
+  "python3",
+  "ruby",
+  "cargo",
+  "go"
+]);
+var isClaudePrefix = (char) => {
+  if (char === "\u2733") return true;
+  const code = char.charCodeAt(0);
+  return code >= 10240 && code <= 10495;
+};
+var classifyPane = (pane) => {
+  const firstChar = pane.title.charAt(0);
+  if (isClaudePrefix(firstChar)) return PANE_KIND.claude;
+  if (BUSY_TITLES.has(pane.title)) return PANE_KIND.busy;
+  return PANE_KIND.available;
+};
+var detectStatusFromTitle = (title) => {
+  const firstChar = title.charAt(0);
+  if (firstChar === "\u2733") return SESSION_STATUS.toolRunning;
+  const code = firstChar.charCodeAt(0);
+  if (code >= 10240 && code <= 10495) return SESSION_STATUS.thinking;
+  return SESSION_STATUS.idle;
+};
+var detectStatusFromText = (paneText) => {
+  const lines = paneText.split("\n");
+  const lastLines = lines.slice(-20);
+  const joined = lastLines.join("\n");
+  if (/Do you want to proceed\?|Esc to cancel/.test(joined)) {
+    return SESSION_STATUS.waitingConfirm;
+  }
+  if (/Running…/.test(joined)) {
+    return SESSION_STATUS.toolRunning;
+  }
+  if (/ろーでぃんぐ…|Thinking|⏳/.test(joined)) {
+    return SESSION_STATUS.thinking;
+  }
+  const trimmedLines = lastLines.map((l) => l.trim()).filter((l) => l.length > 0);
+  const lastNonEmpty = trimmedLines[trimmedLines.length - 1] ?? "";
+  if (/^❯\s*$/.test(lastNonEmpty) || /-- INSERT --/.test(joined)) {
+    return SESSION_STATUS.waitingInput;
+  }
+  return SESSION_STATUS.idle;
+};
+var formatCwd = (cwd) => {
+  const home = process.env["HOME"] ?? "";
+  if (home && cwd.startsWith(home)) {
+    return `~${cwd.slice(home.length)}`;
+  }
+  return cwd;
+};
+var toUnifiedPane = (pane) => {
+  const kind = classifyPane(pane);
+  if (kind === PANE_KIND.claude) {
+    return {
+      pane,
+      kind,
+      claudeStatus: detectStatusFromTitle(pane.title),
+      claudeTitle: pane.title.slice(2)
+    };
+  }
+  return { pane, kind };
+};
+var createSessionDetectionService = () => ({
+  groupBySession: ({ panes }) => {
+    const windowKey = (pane) => `${pane.sessionName}:${String(pane.windowIndex)}`;
+    const windowMap = /* @__PURE__ */ new Map();
+    for (const pane of panes) {
+      const key = windowKey(pane);
+      const unified = toUnifiedPane(pane);
+      const existing = windowMap.get(key);
+      if (existing) {
+        existing.panes = [...existing.panes, unified];
+        if (pane.isActive) {
+          existing.activePaneTitle = pane.title;
+        }
+      } else {
+        windowMap.set(key, {
+          sessionName: pane.sessionName,
+          windowIndex: pane.windowIndex,
+          cwd: formatCwd(pane.cwd),
+          windowName: pane.windowName,
+          activePaneTitle: pane.isActive ? pane.title : "",
+          panes: [unified]
+        });
+      }
+    }
+    const windowGroups = [...windowMap.entries()].toSorted(([a], [b]) => a.localeCompare(b)).map(([, group]) => ({
+      windowIndex: group.windowIndex,
+      windowName: group.windowName || group.activePaneTitle || `Window ${String(group.windowIndex)}`,
+      sessionName: group.sessionName,
+      panes: group.panes.toSorted((a, b) => {
+        const kindOrder = { claude: 0, available: 1, busy: 2 };
+        const kindDiff = kindOrder[a.kind] - kindOrder[b.kind];
+        if (kindDiff !== 0) return kindDiff;
+        if (a.kind === "claude" && b.kind === "claude") {
+          const statusOrder = {
+            "waiting-confirm": 0,
+            "waiting-input": 1,
+            thinking: 2,
+            "tool-running": 3,
+            idle: 4
+          };
+          const sa = statusOrder[a.claudeStatus ?? "idle"] ?? 4;
+          const sb = statusOrder[b.claudeStatus ?? "idle"] ?? 4;
+          if (sa !== sb) return sa - sb;
+        }
+        return a.pane.paneIndex - b.pane.paneIndex;
+      })
+    }));
+    const sessionMap = /* @__PURE__ */ new Map();
+    for (const win of windowGroups) {
+      const existing = sessionMap.get(win.sessionName);
+      if (existing) {
+        existing.push({
+          windowIndex: win.windowIndex,
+          windowName: win.windowName,
+          panes: win.panes
+        });
+      } else {
+        sessionMap.set(win.sessionName, [
+          { windowIndex: win.windowIndex, windowName: win.windowName, panes: win.panes }
+        ]);
+      }
+    }
+    return [...sessionMap.entries()].map(([sessionName, tabs]) => ({ sessionName, tabs }));
+  },
+  detectStatusFromText
+});
+
+// src/services/tmux-service.ts
+var createTmuxService = (context) => {
+  const { tmuxCli } = context.infra;
+  return {
+    listPanes: async () => {
+      return await tmuxCli.listPanes();
+    },
+    createNewWindow: async (input) => {
+      await tmuxCli.newWindow({ target: input.target, cwd: input.cwd });
+    },
+    splitWindow: async (input) => {
+      await tmuxCli.splitWindow({
+        target: input.target,
+        direction: input.direction,
+        cwd: input.cwd
+      });
+    },
+    sendCommand: async (input) => {
+      await tmuxCli.sendKeys({
+        target: input.target,
+        keys: input.command
+      });
+    },
+    sendKeys: async (input) => {
+      await tmuxCli.sendKeys({
+        target: input.target,
+        keys: input.keys
+      });
+    },
+    attachSession: async (sessionName) => {
+      await tmuxCli.attachSession(sessionName);
+    },
+    killPane: async (target) => {
+      await tmuxCli.killPane(target);
+    },
+    killSession: async (sessionName) => {
+      await tmuxCli.killSession(sessionName);
+    },
+    renameWindow: async (input) => {
+      await tmuxCli.renameWindow({ target: input.target, name: input.name });
+    },
+    getText: async (target) => {
+      return await tmuxCli.capturePane(target);
+    }
+  };
+};
+
+// src/services/directory-scan-service.ts
+import { readdir, access } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  ".cache",
+  ".pnpm-store",
+  ".Trash",
+  "Library",
+  "Applications",
+  ".claude"
+]);
+var MAX_DEPTH = 5;
+var exists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var findProjects = async (dir, depth) => {
+  if (depth > MAX_DEPTH) return [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && !SKIP_DIRS.has(e.name));
+    const results = [];
+    const childScans = [];
+    for (const entry of dirs) {
+      const fullPath = join2(dir, entry.name);
+      childScans.push(
+        exists(join2(fullPath, ".git")).then(async (isProject) => {
+          if (isProject) return [fullPath];
+          return await findProjects(fullPath, depth + 1);
+        })
+      );
+    }
+    const nested = await Promise.all(childScans);
+    for (const paths of nested) {
+      for (const p of paths) {
+        results.push(p);
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+};
+var createDirectoryScanService = () => ({
+  scan: async () => {
+    const home = process.env["HOME"] ?? "";
+    if (!home) return [];
+    const results = await findProjects(home, 0);
+    return results.toSorted((a, b) => a.localeCompare(b));
+  }
+});
+
+// src/services/index.ts
+var createServices = (context) => ({
+  tmux: createTmuxService(context),
+  sessionDetection: createSessionDetectionService(),
+  directoryScan: createDirectoryScanService()
+});
+
+// src/utils/ShellUtils.ts
+var escapeShellArg = (arg) => {
+  if (arg === "") return "''";
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+};
+
+// src/usecases/manager-usecase.ts
+var createManagerUsecase = (context) => {
+  const { tmux, sessionDetection } = context.services;
+  const windowTarget = (up) => `${up.pane.sessionName}:${String(up.pane.windowIndex)}`;
+  return {
+    createSession: async ({ sessionName, cwd, prompt }) => {
+      const exists2 = await context.infra.tmuxCli.hasSession(sessionName);
+      if (!exists2) {
+        await context.infra.tmuxCli.newSession({ name: sessionName, cwd });
+      } else {
+        await context.infra.tmuxCli.newWindow({ target: sessionName, cwd });
+      }
+      const panes = await context.infra.tmuxCli.listPanes();
+      const sessionPanes = panes.filter((p) => p.sessionName === sessionName).toSorted((a, b) => b.windowIndex - a.windowIndex || b.paneIndex - a.paneIndex);
+      const target = sessionPanes[0]?.paneId;
+      if (!target) return;
+      const escapedPrompt = escapeShellArg(prompt);
+      await tmux.sendCommand({ target, command: `claude -w -- ${escapedPrompt}` });
+    },
+    list: async () => {
+      const panes = await tmux.listPanes();
+      const sessionGroups = sessionDetection.groupBySession({ panes });
+      return { sessionGroups };
+    },
+    enrichStatus: async (up) => {
+      if (up.kind !== "claude") return up;
+      try {
+        const paneText = await tmux.getText(up.pane.paneId);
+        const status = sessionDetection.detectStatusFromText(paneText);
+        return { ...up, claudeStatus: status };
+      } catch {
+        return up;
+      }
+    },
+    navigateTo: async (up) => {
+      await tmux.attachSession(up.pane.sessionName);
+    },
+    highlightWindow: async (up) => {
+      const title = up.claudeTitle ?? up.pane.title;
+      await tmux.renameWindow({
+        target: windowTarget(up),
+        name: `\u25B6 ${title}`
+      });
+    },
+    unhighlightWindow: async (up) => {
+      await tmux.renameWindow({
+        target: windowTarget(up),
+        name: ""
+      });
+    },
+    killPane: async (paneId) => {
+      await tmux.killPane(paneId);
+    },
+    killSession: async (sessionName) => {
+      await tmux.killSession(sessionName);
+    }
+  };
+};
+
+// src/usecases/index.ts
+var createUsecases = (context) => ({
+  manager: createManagerUsecase(context)
+});
+
+// package.json
+var package_default = {
+  name: "abmux",
+  version: "0.0.1",
+  repository: {
+    type: "git",
+    url: "https://github.com/cut0/abmux.git"
+  },
+  bin: {
+    abmux: "./dist/cli/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    start: "tsx src/cli/index.ts",
+    test: "vitest run",
+    typecheck: "tsc --noEmit",
+    "lint:check": "oxlint src/",
+    "lint:fix": "oxlint --fix src/",
+    "format:check": "oxfmt --check .",
+    "format:fix": "oxfmt .",
+    build: "tsx build.ts",
+    release: "pnpm build && changeset publish"
+  },
+  dependencies: {
+    "@inkjs/ui": "2.0.0",
+    ink: "6.8.0",
+    react: "19.2.4"
+  },
+  devDependencies: {
+    "@changesets/changelog-github": "0.5.1",
+    "@changesets/cli": "2.29.4",
+    "@types/node": "25.5.2",
+    "@types/react": "19.2.14",
+    esbuild: "0.25.2",
+    oxfmt: "0.44.0",
+    oxlint: "1.59.0",
+    tsx: "4.21.0",
+    typescript: "6.0.2",
+    vitest: "4.1.2"
+  },
+  packageManager: "pnpm@10.30.1"
+};
+
+// src/constants.ts
+var APP_TITLE = "abmux - AI Board on tmux";
+var APP_VERSION = package_default.version;
+
+// src/cli/help.ts
+var printHelp = () => {
+  console.log(`${APP_TITLE} v${APP_VERSION}
+
+Usage:
+  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 list                         List sessions
+  abmux --help                       Show this help`);
+};
+
+// src/cli/tui-command.ts
+import { basename as basename3 } from "node:path";
+import { render } from "ink";
+import { createElement } from "react";
+
+// src/components/ManagerView.tsx
+import { basename as basename2 } from "node:path";
+import { Box as Box10, Text as Text10 } from "ink";
+import { useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo5, useRef as useRef2, useState as useState5 } from "react";
+
+// src/components/shared/Header.tsx
+import { Box, Text } from "ink";
+import { jsx } from "react/jsx-runtime";
+var Header = ({ title }) => {
+  return /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: title }) });
+};
+
+// src/components/shared/StatusBar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var COLOR_MAP = {
+  success: "green",
+  error: "red",
+  info: "gray"
+};
+var StatusBar = ({ message, type = "info" }) => {
+  return /* @__PURE__ */ jsx2(Box2, { marginTop: 1, children: /* @__PURE__ */ jsx2(Text2, { color: COLOR_MAP[type], children: message }) });
+};
+
+// src/components/shared/DirectorySelect.tsx
+import { Box as Box3, Text as Text3, useApp, useInput } from "ink";
+import { useCallback, useMemo as useMemo2, useState } from "react";
+
+// src/hooks/use-scroll.ts
+import { useMemo } from "react";
+var useScroll = (cursor, totalItems, availableRows) => {
+  return useMemo(() => {
+    const visibleCount = Math.max(1, availableRows);
+    if (totalItems <= visibleCount) {
+      return { scrollOffset: 0, visibleCount };
+    }
+    let offset = cursor - Math.floor(visibleCount / 2);
+    if (offset < 0) offset = 0;
+    if (offset + visibleCount > totalItems) offset = totalItems - visibleCount;
+    return { scrollOffset: offset, visibleCount };
+  }, [cursor, totalItems, availableRows]);
+};
+
+// src/components/shared/DirectorySelect.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+var sortSessionGroups = (groups, currentSession) => {
+  const current = groups.filter((g) => g.sessionName === currentSession);
+  const rest = groups.filter((g) => g.sessionName !== currentSession);
+  return [...current, ...rest];
+};
+var SessionListPanel = ({
+  sessionGroups,
+  currentSession,
+  isFocused,
+  availableRows,
+  onSelect,
+  onCursorChange,
+  onDeleteSession,
+  onAddSession
+}) => {
+  const { exit } = useApp();
+  const [cursor, setCursor] = useState(0);
+  const sortedGroups = useMemo2(
+    () => sortSessionGroups(sessionGroups, currentSession),
+    [sessionGroups, currentSession]
+  );
+  const sessions = useMemo2(() => sortedGroups.map((g) => g.sessionName), [sortedGroups]);
+  const clampedCursor = cursor >= sessions.length ? Math.max(0, sessions.length - 1) : cursor;
+  if (clampedCursor !== cursor) {
+    setCursor(clampedCursor);
+  }
+  const reservedLines = 1;
+  const { scrollOffset, visibleCount } = useScroll(
+    clampedCursor,
+    sessions.length,
+    availableRows - reservedLines
+  );
+  const visibleSessions = sessions.slice(scrollOffset, scrollOffset + visibleCount);
+  const moveCursor = useCallback(
+    (next) => {
+      const clamped = Math.max(0, Math.min(sessions.length - 1, next));
+      setCursor(clamped);
+      const name = sessions[clamped];
+      if (name) onCursorChange(name);
+    },
+    [sessions, onCursorChange]
+  );
+  useInput(
+    (input, key) => {
+      if (input === "q") {
+        exit();
+        return;
+      }
+      if (key.upArrow) {
+        moveCursor(clampedCursor - 1);
+        return;
+      }
+      if (key.downArrow) {
+        moveCursor(clampedCursor + 1);
+        return;
+      }
+      if (key.return || key.rightArrow) {
+        const name = sessions[clampedCursor];
+        if (name) onSelect(name);
+        return;
+      }
+      if (input === "d" && onDeleteSession) {
+        const name = sessions[clampedCursor];
+        if (name) onDeleteSession(name);
+        return;
+      }
+      if (input === "n" && onAddSession) {
+        onAddSession();
+      }
+    },
+    { isActive: isFocused }
+  );
+  return /* @__PURE__ */ jsxs(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Box3, { paddingLeft: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: isFocused ? "green" : "gray", children: "Sessions" }),
+      /* @__PURE__ */ jsxs(Text3, { dimColor: true, children: [
+        " ",
+        "(",
+        clampedCursor + 1,
+        "/",
+        sessions.length,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleSessions.map((name, i) => {
+      const globalIndex = scrollOffset + i;
+      const isHighlighted = globalIndex === clampedCursor;
+      const isCurrent = name === currentSession;
+      return /* @__PURE__ */ jsxs(Box3, { paddingLeft: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
+        /* @__PURE__ */ jsx3(Text3, { color: isHighlighted ? "green" : "cyan", bold: isHighlighted, wrap: "truncate", children: name }),
+        isCurrent && /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: "(cwd)" })
+      ] }, name);
+    }) })
+  ] });
+};
+
+// src/components/PaneListPanel.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+
+// src/components/PaneListView.tsx
+import { Box as Box5, Text as Text5, useApp as useApp2, useInput as useInput2 } from "ink";
+import { useCallback as useCallback2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
+
+// src/components/sessions/PaneItem.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var PaneItem = ({ unifiedPane, isHighlighted }) => {
+  const { pane, kind, claudeStatus, claudeTitle } = unifiedPane;
+  if (kind === "claude") {
+    const icon = pane.title.charAt(0);
+    const statusLabel = claudeStatus ? SESSION_STATUS_LABEL[claudeStatus] : "";
+    const statusColor = claudeStatus ? SESSION_STATUS_COLOR[claudeStatus] : "gray";
+    return /* @__PURE__ */ jsxs2(Box4, { paddingLeft: 3, gap: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
+      /* @__PURE__ */ jsx4(Text4, { color: "#FF8C00", children: icon }),
+      /* @__PURE__ */ jsxs2(Text4, { color: statusColor, children: [
+        "[",
+        statusLabel,
+        "]"
+      ] }),
+      /* @__PURE__ */ jsx4(Text4, { color: isHighlighted ? "green" : void 0, bold: isHighlighted, children: claudeTitle }),
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: pane.paneId })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box4, { paddingLeft: 3, gap: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
+    kind === "available" && /* @__PURE__ */ jsx4(Text4, { color: "#4AA8D8", children: "\u25CB" }),
+    kind === "busy" && /* @__PURE__ */ jsx4(Text4, { color: "#E05252", children: "\u25CF" }),
+    /* @__PURE__ */ jsx4(Text4, { color: isHighlighted ? "green" : void 0, bold: isHighlighted, children: pane.title || "(empty)" }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: pane.paneId })
+  ] });
+};
+
+// src/components/PaneListView.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var PaneListView = ({
+  selectedSession,
+  group,
+  isFocused,
+  availableRows,
+  onNavigate,
+  onHighlight,
+  onUnhighlight,
+  onBack,
+  onNewSession,
+  onKillPane
+}) => {
+  const { exit } = useApp2();
+  const [cursor, setCursor] = useState2(0);
+  const highlightedRef = useRef(void 0);
+  const panes = useMemo3(() => group.tabs.flatMap((t) => t.panes), [group]);
+  const clampedCursor = cursor >= panes.length ? Math.max(0, panes.length - 1) : cursor;
+  if (clampedCursor !== cursor) {
+    setCursor(clampedCursor);
+  }
+  const reservedLines = 1;
+  const { scrollOffset, visibleCount } = useScroll(
+    clampedCursor,
+    panes.length,
+    availableRows - reservedLines
+  );
+  const visiblePanes = useMemo3(
+    () => panes.slice(scrollOffset, scrollOffset + visibleCount),
+    [panes, scrollOffset, visibleCount]
+  );
+  const highlight = useCallback2(
+    (up) => {
+      const prev = highlightedRef.current;
+      if (prev && prev !== up) onUnhighlight(prev);
+      if (up) onHighlight(up);
+      highlightedRef.current = up;
+    },
+    [onHighlight, onUnhighlight]
+  );
+  const clearHighlight = useCallback2(() => {
+    const prev = highlightedRef.current;
+    if (prev) onUnhighlight(prev);
+    highlightedRef.current = void 0;
+  }, [onUnhighlight]);
+  const moveCursor = useCallback2(
+    (next) => {
+      const clamped = Math.max(0, Math.min(panes.length - 1, next));
+      setCursor(clamped);
+      highlight(panes[clamped]);
+    },
+    [panes, highlight]
+  );
+  const didInitRef = useRef(false);
+  if (!didInitRef.current && panes.length > 0) {
+    didInitRef.current = true;
+    highlight(panes[clampedCursor]);
+  }
+  useInput2(
+    (input, key) => {
+      if (input === "q") {
+        clearHighlight();
+        exit();
+        return;
+      }
+      if (key.escape || key.leftArrow) {
+        clearHighlight();
+        onBack();
+        return;
+      }
+      if (key.upArrow) {
+        moveCursor(clampedCursor - 1);
+        return;
+      }
+      if (key.downArrow) {
+        moveCursor(clampedCursor + 1);
+        return;
+      }
+      if (input === "d") {
+        const pane = panes[clampedCursor];
+        if (pane) {
+          void onKillPane(pane.pane.paneId);
+        }
+        return;
+      }
+      if (input === "n") {
+        onNewSession(selectedSession);
+        return;
+      }
+      if (key.return) {
+        const pane = panes[clampedCursor];
+        if (pane) onNavigate(pane);
+      }
+    },
+    { isActive: isFocused }
+  );
+  return /* @__PURE__ */ jsxs3(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box5, { paddingLeft: 1, children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: isFocused ? "green" : "gray", children: "Panes" }),
+      /* @__PURE__ */ jsxs3(Text5, { dimColor: true, children: [
+        " ",
+        selectedSession,
+        " (",
+        panes.length > 0 ? clampedCursor + 1 : 0,
+        "/",
+        panes.length,
+        ")"
+      ] })
+    ] }),
+    /* @__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(
+      PaneItem,
+      {
+        unifiedPane: up,
+        isHighlighted: scrollOffset + i === clampedCursor
+      },
+      up.pane.paneId
+    )) })
+  ] });
+};
+
+// src/components/PaneListPanel.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var PaneListPanel = ({
+  selectedSession,
+  group,
+  isFocused,
+  availableRows,
+  onNavigate,
+  onHighlight,
+  onUnhighlight,
+  onBack,
+  onNewSession,
+  onKillPane
+}) => {
+  if (!selectedSession) {
+    return /* @__PURE__ */ jsx6(Box6, { paddingLeft: 1, children: /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: "No session selected" }) });
+  }
+  return /* @__PURE__ */ jsx6(
+    PaneListView,
+    {
+      selectedSession,
+      group: group ?? { sessionName: selectedSession, tabs: [] },
+      isFocused,
+      availableRows,
+      onNavigate,
+      onHighlight,
+      onUnhighlight,
+      onBack,
+      onNewSession,
+      onKillPane
+    },
+    selectedSession
+  );
+};
+
+// src/components/ConfirmView.tsx
+import { Box as Box7, Text as Text7, useInput as useInput3 } from "ink";
+
+// src/hooks/use-terminal-size.ts
+import { useStdout } from "ink";
+import { useEffect, useState as useState3 } from "react";
+var useTerminalSize = () => {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState3({
+    rows: stdout.rows ?? 24,
+    columns: stdout.columns ?? 80
+  });
+  useEffect(() => {
+    const handleResize = () => {
+      setSize({
+        rows: stdout.rows ?? 24,
+        columns: stdout.columns ?? 80
+      });
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+};
+
+// src/components/ConfirmView.tsx
+import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
+var ConfirmView = ({ selectedDir, prompt, onConfirm, onCancel }) => {
+  const { rows } = useTerminalSize();
+  const previewLines = prompt.split("\n");
+  const maxPreview = Math.min(previewLines.length, rows - 6);
+  useInput3((_input, key) => {
+    if (key.return) {
+      onConfirm();
+      return;
+    }
+    if (key.escape) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs4(Box7, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx7(Header, { title: `${APP_TITLE} \u2014 ${selectedDir}` }),
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(Text7, { bold: true, children: "New Claude session:" }) }),
+    /* @__PURE__ */ jsxs4(Box7, { flexDirection: "column", flexGrow: 1, overflow: "hidden", paddingLeft: 2, children: [
+      previewLines.slice(0, maxPreview).map((line, i) => /* @__PURE__ */ jsx7(Text7, { color: "white", children: line }, i)),
+      previewLines.length > maxPreview && /* @__PURE__ */ jsxs4(Text7, { dimColor: true, children: [
+        "... (",
+        previewLines.length - maxPreview,
+        " more lines)"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box7, { gap: 2, children: [
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Enter confirm" }),
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Esc cancel" })
+    ] })
+  ] });
+};
+
+// src/components/DeleteSessionView.tsx
+import { Box as Box8, Text as Text8, useInput as useInput4 } from "ink";
+import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
+var DeleteSessionView = ({
+  sessionName,
+  paneCount,
+  onConfirm,
+  onCancel
+}) => {
+  const { rows } = useTerminalSize();
+  useInput4((_input, key) => {
+    if (key.return) {
+      onConfirm();
+      return;
+    }
+    if (key.escape) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ jsxs5(Box8, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx8(Header, { title: APP_TITLE }),
+    /* @__PURE__ */ jsxs5(Box8, { flexDirection: "column", gap: 1, paddingLeft: 2, children: [
+      /* @__PURE__ */ jsx8(Text8, { bold: true, color: "red", children: "Delete session?" }),
+      /* @__PURE__ */ jsxs5(Text8, { children: [
+        "Session: ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: sessionName })
+      ] }),
+      /* @__PURE__ */ jsxs5(Text8, { children: [
+        "Panes: ",
+        /* @__PURE__ */ jsx8(Text8, { bold: true, children: paneCount })
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "All processes in this session will be terminated." })
+    ] }),
+    /* @__PURE__ */ jsx8(Box8, { flexGrow: 1 }),
+    /* @__PURE__ */ jsxs5(Box8, { gap: 2, children: [
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Enter confirm" }),
+      /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "Esc cancel" })
+    ] })
+  ] });
+};
+
+// src/components/DirectorySearchView.tsx
+import { Box as Box9, Text as Text9, useInput as useInput5 } from "ink";
+import { useMemo as useMemo4, useState as useState4 } from "react";
+import { basename } from "node:path";
+import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
+var formatPath = (path) => {
+  const home = process.env["HOME"] ?? "";
+  if (home && path.startsWith(home)) {
+    return `~${path.slice(home.length)}`;
+  }
+  return path;
+};
+var DirectorySearchView = ({ directories, onSelect, onCancel }) => {
+  const { rows } = useTerminalSize();
+  const [query, setQuery] = useState4("");
+  const [cursor, setCursor] = useState4(0);
+  const filtered = useMemo4(() => {
+    if (!query) return directories;
+    const lower = query.toLowerCase();
+    return directories.filter((d) => {
+      const name = basename(d).toLowerCase();
+      const formatted = formatPath(d).toLowerCase();
+      return name.includes(lower) || formatted.includes(lower);
+    });
+  }, [directories, query]);
+  const clampedCursor = cursor >= filtered.length ? Math.max(0, filtered.length - 1) : cursor;
+  if (clampedCursor !== cursor) {
+    setCursor(clampedCursor);
+  }
+  const listHeight = rows - 6;
+  const { scrollOffset, visibleCount } = useScroll(clampedCursor, filtered.length, listHeight);
+  const visibleItems = useMemo4(
+    () => filtered.slice(scrollOffset, scrollOffset + visibleCount),
+    [filtered, scrollOffset, visibleCount]
+  );
+  useInput5((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      const selected = filtered[clampedCursor];
+      if (selected) onSelect(selected);
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setCursor((c) => Math.min(filtered.length - 1, c + 1));
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setQuery((q) => q.slice(0, -1));
+      setCursor(0);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta && !key.upArrow && !key.downArrow) {
+      setQuery((q) => q + input);
+      setCursor(0);
+    }
+  });
+  return /* @__PURE__ */ jsxs6(Box9, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx9(Header, { title: `${APP_TITLE} \u2014 Add Session` }),
+    /* @__PURE__ */ jsxs6(Box9, { paddingLeft: 1, gap: 1, children: [
+      /* @__PURE__ */ jsx9(Text9, { bold: true, children: ">" }),
+      /* @__PURE__ */ jsx9(Text9, { children: query }),
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: query ? "" : "type to filter..." })
+    ] }),
+    /* @__PURE__ */ jsx9(Box9, { paddingLeft: 1, children: /* @__PURE__ */ jsxs6(Text9, { dimColor: true, children: [
+      filtered.length,
+      "/",
+      directories.length
+    ] }) }),
+    /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleItems.map((dir, i) => {
+      const globalIndex = scrollOffset + i;
+      const isHighlighted = globalIndex === clampedCursor;
+      return /* @__PURE__ */ jsxs6(Box9, { paddingLeft: 1, gap: 1, children: [
+        /* @__PURE__ */ jsx9(Text9, { color: isHighlighted ? "green" : void 0, children: isHighlighted ? "\u25B6" : " " }),
+        /* @__PURE__ */ jsx9(Text9, { color: isHighlighted ? "green" : void 0, bold: isHighlighted, children: formatPath(dir) })
+      ] }, dir);
+    }) }),
+    /* @__PURE__ */ jsxs6(Box9, { gap: 2, children: [
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Enter select" }),
+      /* @__PURE__ */ jsx9(Text9, { dimColor: true, children: "Esc cancel" })
+    ] })
+  ] });
+};
+
+// src/utils/PromiseUtils.ts
+var swallow = async (fn) => {
+  try {
+    await fn();
+  } catch {
+  }
+};
+
+// src/components/ManagerView.tsx
+import { jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+var MODE = {
+  split: "split",
+  confirm: "confirm",
+  deleteSession: "deleteSession",
+  addSession: "addSession"
+};
+var FOCUS = {
+  left: "left",
+  right: "right"
+};
+var POLL_INTERVAL = 3e3;
+var ManagerView = ({
+  actions,
+  currentSession,
+  currentCwd,
+  directories,
+  restoredPrompt,
+  restoredSession
+}) => {
+  const { rows, columns } = useTerminalSize();
+  const [fetchState, setFetchState] = useState5({ data: [], isLoading: true });
+  const [mode, setMode] = useState5(restoredPrompt ? MODE.confirm : MODE.split);
+  const [focus, setFocus] = useState5(FOCUS.left);
+  const [selectedSession, setSelectedSession] = useState5(restoredSession);
+  const [pendingPrompt, setPendingPrompt] = useState5(restoredPrompt ?? "");
+  const [pendingDeleteSession, setPendingDeleteSession] = useState5(void 0);
+  const sessionCwdMap = useRef2(/* @__PURE__ */ new Map());
+  const refresh = useCallback3(async () => {
+    try {
+      const groups = await actions.fetchSessions();
+      const knownNames = new Set(groups.map((g) => g.sessionName));
+      const missing = [];
+      for (const name of sessionCwdMap.current.keys()) {
+        if (!knownNames.has(name)) {
+          missing.push({ sessionName: name, tabs: [] });
+        }
+      }
+      setFetchState({ data: [...missing, ...groups], isLoading: false });
+    } catch {
+      setFetchState((prev) => ({ ...prev, isLoading: false }));
+    }
+  }, [actions]);
+  useEffect2(() => {
+    void refresh();
+    const timer = setInterval(() => {
+      void refresh();
+    }, POLL_INTERVAL);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [refresh]);
+  const resolvedSession = selectedSession ?? fetchState.data[0]?.sessionName;
+  const selectedGroup = useMemo5(
+    () => fetchState.data.find((g) => g.sessionName === resolvedSession),
+    [fetchState.data, resolvedSession]
+  );
+  const handleOpenAddSession = useCallback3(() => {
+    setMode(MODE.addSession);
+  }, []);
+  const handleAddSessionSelect = useCallback3(
+    (path) => {
+      const name = basename2(path);
+      sessionCwdMap.current.set(name, path);
+      const exists2 = fetchState.data.some((g) => g.sessionName === name);
+      if (!exists2) {
+        setFetchState((prev) => ({
+          ...prev,
+          data: [{ sessionName: name, tabs: [] }, ...prev.data]
+        }));
+      }
+      setSelectedSession(name);
+      setMode(MODE.split);
+    },
+    [fetchState.data]
+  );
+  const handleCancelAddSession = useCallback3(() => {
+    setMode(MODE.split);
+  }, []);
+  const handleDeleteSession = useCallback3((name) => {
+    setPendingDeleteSession(name);
+    setMode(MODE.deleteSession);
+  }, []);
+  const handleConfirmDelete = useCallback3(() => {
+    if (!pendingDeleteSession) return;
+    sessionCwdMap.current.delete(pendingDeleteSession);
+    if (resolvedSession === pendingDeleteSession) {
+      setSelectedSession(void 0);
+    }
+    void swallow(() => actions.killSession(pendingDeleteSession)).then(() => void refresh());
+    setPendingDeleteSession(void 0);
+    setMode(MODE.split);
+  }, [pendingDeleteSession, resolvedSession, actions, refresh]);
+  const handleCancelDelete = useCallback3(() => {
+    setPendingDeleteSession(void 0);
+    setMode(MODE.split);
+  }, []);
+  const handleNewSession = useCallback3(
+    (sessionName) => {
+      actions.openEditor(sessionName);
+    },
+    [actions]
+  );
+  const handleConfirmNew = useCallback3(() => {
+    if (!resolvedSession) return;
+    const cwd = sessionCwdMap.current.get(resolvedSession) ?? currentCwd;
+    void actions.createSession(resolvedSession, cwd, pendingPrompt).then(() => void refresh());
+    setPendingPrompt("");
+    setMode(MODE.split);
+  }, [resolvedSession, currentCwd, pendingPrompt, actions, refresh]);
+  const handleCancelConfirm = useCallback3(() => {
+    setPendingPrompt("");
+    setMode(MODE.split);
+  }, []);
+  const handleSessionSelect = useCallback3((name) => {
+    setSelectedSession(name);
+    setFocus(FOCUS.right);
+  }, []);
+  const handleSessionCursorChange = useCallback3((name) => {
+    setSelectedSession(name);
+  }, []);
+  const handleNavigate = useCallback3(
+    (up) => {
+      actions.attachSession(up.pane.sessionName);
+    },
+    [actions]
+  );
+  const handleBack = useCallback3(() => {
+    setFocus(FOCUS.left);
+  }, []);
+  const handleKillPane = useCallback3(
+    async (paneId) => {
+      await swallow(() => actions.killPane(paneId));
+      void refresh();
+    },
+    [actions, refresh]
+  );
+  const handleHighlight = useCallback3(
+    async (up) => {
+      await swallow(() => actions.highlightWindow(up));
+    },
+    [actions]
+  );
+  const handleUnhighlight = useCallback3(
+    async (up) => {
+      await swallow(() => actions.unhighlightWindow(up));
+    },
+    [actions]
+  );
+  if (fetchState.isLoading) {
+    return /* @__PURE__ */ jsxs7(Box10, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsx10(Header, { title: `${APP_TITLE} v${APP_VERSION}` }),
+      /* @__PURE__ */ jsx10(StatusBar, { message: "Loading...", type: "info" })
+    ] });
+  }
+  if (mode === MODE.addSession) {
+    return /* @__PURE__ */ jsx10(
+      DirectorySearchView,
+      {
+        directories,
+        onSelect: handleAddSessionSelect,
+        onCancel: handleCancelAddSession
+      }
+    );
+  }
+  if (mode === MODE.deleteSession && pendingDeleteSession) {
+    const deleteGroup = fetchState.data.find((g) => g.sessionName === pendingDeleteSession);
+    const paneCount = deleteGroup?.tabs.reduce((sum, t) => sum + t.panes.length, 0) ?? 0;
+    return /* @__PURE__ */ jsx10(
+      DeleteSessionView,
+      {
+        sessionName: pendingDeleteSession,
+        paneCount,
+        onConfirm: handleConfirmDelete,
+        onCancel: handleCancelDelete
+      }
+    );
+  }
+  if (mode === MODE.confirm && pendingPrompt) {
+    return /* @__PURE__ */ jsx10(
+      ConfirmView,
+      {
+        selectedDir: resolvedSession ?? "",
+        prompt: pendingPrompt,
+        onConfirm: handleConfirmNew,
+        onCancel: handleCancelConfirm
+      }
+    );
+  }
+  const panelHeight = rows - 5;
+  const leftWidth = Math.floor(columns / 3);
+  const rightWidth = columns - leftWidth;
+  return /* @__PURE__ */ jsxs7(Box10, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsx10(Header, { title: `${APP_TITLE} - v${APP_VERSION}` }),
+    /* @__PURE__ */ jsxs7(Box10, { flexDirection: "row", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx10(
+        Box10,
+        {
+          flexDirection: "column",
+          width: leftWidth,
+          borderStyle: "round",
+          borderColor: focus === FOCUS.left ? "green" : "gray",
+          children: /* @__PURE__ */ jsx10(
+            SessionListPanel,
+            {
+              sessionGroups: fetchState.data,
+              currentSession,
+              isFocused: focus === FOCUS.left,
+              availableRows: panelHeight,
+              onSelect: handleSessionSelect,
+              onCursorChange: handleSessionCursorChange,
+              onDeleteSession: handleDeleteSession,
+              onAddSession: handleOpenAddSession
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx10(
+        Box10,
+        {
+          flexDirection: "column",
+          width: rightWidth,
+          borderStyle: "round",
+          borderColor: focus === FOCUS.right ? "green" : "gray",
+          children: /* @__PURE__ */ jsx10(
+            PaneListPanel,
+            {
+              selectedSession: resolvedSession,
+              group: selectedGroup,
+              isFocused: focus === FOCUS.right,
+              availableRows: panelHeight,
+              onNavigate: handleNavigate,
+              onHighlight: handleHighlight,
+              onUnhighlight: handleUnhighlight,
+              onBack: handleBack,
+              onNewSession: handleNewSession,
+              onKillPane: handleKillPane
+            }
+          )
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx10(Text10, { dimColor: true, children: focus === FOCUS.left ? "\u2191/\u2193 move  Enter/\u2192 select  n add  d delete  q quit" : "\u2191/\u2193 move  Enter focus  n new  d kill  Esc/\u2190 back  q quit" })
+  ] });
+};
+
+// src/cli/tui-command.ts
+var createTuiCommand = ({ usecases, services, infra }) => async () => {
+  const directories = await services.directoryScan.scan();
+  let instance;
+  let pendingPrompt;
+  let pendingSession;
+  const actions = {
+    fetchSessions: async () => {
+      const result = await usecases.manager.list();
+      return await Promise.all(
+        result.sessionGroups.map(async (group) => ({
+          sessionName: group.sessionName,
+          tabs: await Promise.all(
+            group.tabs.map(async (tab) => ({
+              windowIndex: tab.windowIndex,
+              windowName: tab.windowName,
+              panes: await Promise.all(
+                tab.panes.map((up) => usecases.manager.enrichStatus(up))
+              )
+            }))
+          )
+        }))
+      );
+    },
+    createSession: async (sessionName, cwd, prompt) => {
+      await usecases.manager.createSession({ sessionName, cwd, prompt });
+    },
+    killSession: async (sessionName) => {
+      await usecases.manager.killSession(sessionName);
+    },
+    killPane: async (paneId) => {
+      await usecases.manager.killPane(paneId);
+    },
+    highlightWindow: async (up) => {
+      await usecases.manager.highlightWindow(up);
+    },
+    unhighlightWindow: async (up) => {
+      await usecases.manager.unhighlightWindow(up);
+    },
+    openEditor: (sessionName) => {
+      instance.unmount();
+      const prompt = infra.editor.open();
+      pendingPrompt = prompt;
+      pendingSession = sessionName;
+      instance = renderApp();
+      return prompt;
+    },
+    attachSession: (sessionName) => {
+      instance.unmount();
+      void infra.tmuxCli.attachSession(sessionName);
+      instance = renderApp();
+    }
+  };
+  const renderApp = () => {
+    const prompt = pendingPrompt;
+    const session = pendingSession;
+    pendingPrompt = void 0;
+    pendingSession = void 0;
+    return render(
+      createElement(ManagerView, {
+        actions,
+        currentSession: basename3(process.cwd()),
+        currentCwd: process.cwd(),
+        directories,
+        restoredPrompt: prompt,
+        restoredSession: session
+      })
+    );
+  };
+  instance = renderApp();
+  await instance.waitUntilExit();
+};
+
+// src/cli/new-command.ts
+import { basename as basename4 } from "node:path";
+import { parseArgs } from "node:util";
+var createNewCommand = ({ usecases }) => async (args) => {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      dir: { type: "string" }
+    },
+    allowPositionals: true
+  });
+  const prompt = positionals[0];
+  if (!prompt) {
+    console.error("Usage: abmux new <prompt> [--dir <path>]");
+    process.exit(1);
+  }
+  const dir = values.dir ?? process.cwd();
+  const sessionName = basename4(dir);
+  await usecases.manager.createSession({ sessionName, cwd: dir, prompt });
+  console.log(`Session "${sessionName}" created.`);
+};
+
+// src/cli/open-command.ts
+import { basename as basename5 } from "node:path";
+var createOpenCommand = ({ infra }) => async (args) => {
+  const session = args[0] ?? basename5(process.cwd());
+  const exists2 = await infra.tmuxCli.hasSession(session);
+  if (!exists2) {
+    console.error(`Session "${session}" not found.`);
+    process.exit(1);
+  }
+  await infra.tmuxCli.attachSession(session);
+};
+
+// src/cli/kill-command.ts
+import { basename as basename6 } from "node:path";
+var createKillCommand = ({ usecases }) => async (args) => {
+  const session = args[0] ?? basename6(process.cwd());
+  await usecases.manager.killSession(session);
+  console.log(`Session "${session}" killed.`);
+};
+
+// src/cli/list-command.ts
+var createListCommand = ({ usecases }) => async () => {
+  const result = await usecases.manager.list();
+  if (result.sessionGroups.length === 0) {
+    console.log("No sessions found.");
+    return;
+  }
+  for (const group of result.sessionGroups) {
+    const paneCount = group.tabs.reduce((sum, t) => sum + t.panes.length, 0);
+    console.log(`${group.sessionName} (${String(paneCount)} panes)`);
+  }
+};
+
+// src/cli/index.ts
+var main = async () => {
+  const infra = createInfra();
+  const services = createServices({ infra });
+  const usecases = createUsecases({ services, infra });
+  const [command, ...args] = process.argv.slice(2);
+  if (command === "--help" || command === "-h") {
+    printHelp();
+    return;
+  }
+  const commands = {
+    new: createNewCommand({ usecases }),
+    open: createOpenCommand({ infra }),
+    kill: createKillCommand({ usecases }),
+    list: createListCommand({ usecases })
+  };
+  const handler = commands[command ?? ""];
+  if (command && !handler) {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+  }
+  if (handler) {
+    await handler(args);
+    return;
+  }
+  await createTuiCommand({ usecases, services, infra })();
+};
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});