code-squad-cli 1.3.0 → 2.1.0

package/dist/index.js

@@ -1,428 +1,385 @@
 #!/usr/bin/env node
-
-// dist/index.js
-import * as path15 from "path";
-import * as fs13 from "fs";
-import * as os7 from "os";
-import * as crypto from "crypto";
-import chalk3 from "chalk";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // dist/adapters/GitAdapter.js
 import { exec as execCallback } from "child_process";
 import { promisify } from "util";
 import * as fs from "fs";
-var exec = promisify(execCallback);
-var execOptions = { maxBuffer: 1024 * 1024 };
-var GitAdapter = class {
-  async isGitRepository(workspaceRoot) {
-    try {
-      await exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, execOptions);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async getCurrentBranch(workspaceRoot) {
-    try {
-      const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
-      return stdout.trim();
-    } catch {
-      try {
-        const { stdout } = await exec(`cd "${workspaceRoot}" && git symbolic-ref --short HEAD`, execOptions);
-        return stdout.trim();
-      } catch {
-        return "";
+var exec, execOptions, GitAdapter;
+var init_GitAdapter = __esm({
+  "dist/adapters/GitAdapter.js"() {
+    "use strict";
+    exec = promisify(execCallback);
+    execOptions = { maxBuffer: 1024 * 1024 };
+    GitAdapter = class {
+      async isGitRepository(workspaceRoot) {
+        try {
+          await exec(`cd "${workspaceRoot}" && git rev-parse --git-dir`, execOptions);
+          return true;
+        } catch {
+          return false;
+        }
       }
-    }
-  }
-  async listWorktrees(workspaceRoot) {
-    try {
-      const { stdout } = await exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, execOptions);
-      const worktrees = [];
-      const lines = stdout.split("\n").filter((line) => line.trim());
-      let i = 0;
-      while (i < lines.length) {
-        const worktreeLine = lines[i];
-        const headLine = lines[i + 1];
-        const branchLine = lines[i + 2];
-        if (!worktreeLine || !headLine) {
-          i++;
-          continue;
+      async getCurrentBranch(workspaceRoot) {
+        try {
+          const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+          return stdout.trim();
+        } catch {
+          try {
+            const { stdout } = await exec(`cd "${workspaceRoot}" && git symbolic-ref --short HEAD`, execOptions);
+            return stdout.trim();
+          } catch {
+            return "";
+          }
         }
-        const pathMatch = worktreeLine.match(/^worktree (.+)$/);
-        const headMatch = headLine.match(/^HEAD (.+)$/);
-        const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
-        if (pathMatch && headMatch) {
-          const path16 = pathMatch[1];
-          const head = headMatch[1];
-          const branch = branchMatch ? branchMatch[1] : "HEAD";
-          if (path16 !== workspaceRoot) {
-            worktrees.push({ path: path16, branch, head });
+      }
+      async listWorktrees(workspaceRoot) {
+        try {
+          const { stdout } = await exec(`cd "${workspaceRoot}" && git worktree list --porcelain`, execOptions);
+          const worktrees = [];
+          const lines = stdout.split("\n").filter((line) => line.trim());
+          let i = 0;
+          while (i < lines.length) {
+            const worktreeLine = lines[i];
+            const headLine = lines[i + 1];
+            const branchLine = lines[i + 2];
+            if (!worktreeLine || !headLine) {
+              i++;
+              continue;
+            }
+            const pathMatch = worktreeLine.match(/^worktree (.+)$/);
+            const headMatch = headLine.match(/^HEAD (.+)$/);
+            const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
+            if (pathMatch && headMatch) {
+              const path13 = pathMatch[1];
+              const head = headMatch[1];
+              const branch = branchMatch ? branchMatch[1] : "HEAD";
+              if (path13 !== workspaceRoot) {
+                worktrees.push({ path: path13, branch, head });
+              }
+            }
+            i += 3;
           }
+          return worktrees;
+        } catch {
+          return [];
         }
-        i += 3;
       }
-      return worktrees;
-    } catch {
-      return [];
-    }
-  }
-  async createWorktree(worktreePath, branch, workspaceRoot) {
-    await exec(`cd "${workspaceRoot}" && git worktree prune`, execOptions).catch(() => {
-    });
-    const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf("/"));
-    const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : "";
-    await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add -f "${worktreePath}" -b "${branch}"`, execOptions);
-  }
-  async removeWorktree(worktreePath, workspaceRoot, force = false) {
-    const forceFlag = force ? " --force" : "";
-    try {
-      await exec(`cd "${workspaceRoot}" && git worktree remove "${worktreePath}"${forceFlag}`, execOptions);
-    } catch (error) {
-      throw new Error(`Failed to remove worktree: ${error.message}`);
-    }
+      async createWorktree(worktreePath, branch, workspaceRoot) {
+        await exec(`cd "${workspaceRoot}" && git worktree prune`, execOptions).catch(() => {
+        });
+        const parentDir = worktreePath.substring(0, worktreePath.lastIndexOf("/"));
+        const mkdirCmd = parentDir ? `mkdir -p "${parentDir}" && ` : "";
+        await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add -f "${worktreePath}" -b "${branch}"`, execOptions);
+      }
+      async removeWorktree(worktreePath, workspaceRoot, force = false) {
+        const forceFlag = force ? " --force" : "";
+        try {
+          await exec(`cd "${workspaceRoot}" && git worktree remove "${worktreePath}"${forceFlag}`, execOptions);
+        } catch (error) {
+          throw new Error(`Failed to remove worktree: ${error.message}`);
+        }
+      }
+      async deleteBranch(branchName, workspaceRoot, force = false) {
+        const deleteFlag = force ? "-D" : "-d";
+        try {
+          await exec(`cd "${workspaceRoot}" && git branch ${deleteFlag} "${branchName}"`, execOptions);
+        } catch (error) {
+          throw new Error(`Failed to delete branch: ${error.message}`);
+        }
+      }
+      async isValidWorktree(path13, workspaceRoot) {
+        try {
+          await fs.promises.access(path13, fs.constants.R_OK);
+        } catch {
+          return false;
+        }
+        try {
+          await exec(`cd "${path13}" && git rev-parse --git-dir`, execOptions);
+        } catch {
+          return false;
+        }
+        const worktrees = await this.listWorktrees(workspaceRoot);
+        return worktrees.some((wt) => wt.path === path13);
+      }
+      async getWorktreeBranch(worktreePath) {
+        try {
+          const { stdout } = await exec(`cd "${worktreePath}" && git rev-parse --abbrev-ref HEAD`, execOptions);
+          return stdout.trim();
+        } catch (error) {
+          throw new Error(`Failed to get branch name: ${error.message}`);
+        }
+      }
+      /**
+       * 현재 디렉토리가 워크트리인지 확인하고 컨텍스트 반환
+       */
+      async getWorktreeContext(cwd) {
+        let commonDir = null;
+        try {
+          const { stdout } = await exec(`cd "${cwd}" && git rev-parse --git-common-dir`, execOptions);
+          commonDir = stdout.trim();
+        } catch {
+          return { isWorktree: false, mainRoot: null, currentPath: cwd, branch: null };
+        }
+        const isWorktree = commonDir !== ".git";
+        if (!isWorktree) {
+          return { isWorktree: false, mainRoot: cwd, currentPath: cwd, branch: null };
+        }
+        let mainRoot = null;
+        try {
+          const { stdout } = await exec(`cd "${cwd}" && git worktree list --porcelain`, execOptions);
+          const match = stdout.match(/^worktree (.+)$/m);
+          mainRoot = match ? match[1] : null;
+        } catch {
+        }
+        const branch = await this.getWorktreeBranch(cwd).catch(() => null);
+        return { isWorktree, mainRoot, currentPath: cwd, branch };
+      }
+      /**
+       * staged 또는 unstaged 변경사항이 있는지 확인 (untracked 제외)
+       */
+      async hasDirtyState(workspacePath) {
+        try {
+          const { stdout } = await exec(`cd "${workspacePath}" && git status --porcelain`, execOptions);
+          const lines = stdout.split("\n").filter((line) => line.trim());
+          const dirtyLines = lines.filter((line) => !line.startsWith("??"));
+          return dirtyLines.length > 0;
+        } catch {
+          return true;
+        }
+      }
+    };
   }
-  async deleteBranch(branchName, workspaceRoot, force = false) {
-    const deleteFlag = force ? "-D" : "-d";
-    try {
-      await exec(`cd "${workspaceRoot}" && git branch ${deleteFlag} "${branchName}"`, execOptions);
-    } catch (error) {
-      throw new Error(`Failed to delete branch: ${error.message}`);
+});
+
+// dist/config.js
+import * as fs9 from "fs";
+import * as os4 from "os";
+import * as path9 from "path";
+async function loadGlobalConfig() {
+  try {
+    const content = await fs9.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
     }
+    console.warn(`[Code Squad] Warning: Could not load global config at ${GLOBAL_CONFIG_PATH}.`, error);
+    return {};
   }
-  async isValidWorktree(path16, workspaceRoot) {
-    try {
-      await fs.promises.access(path16, fs.constants.R_OK);
-    } catch {
-      return false;
-    }
-    try {
-      await exec(`cd "${path16}" && git rev-parse --git-dir`, execOptions);
-    } catch {
-      return false;
-    }
-    const worktrees = await this.listWorktrees(workspaceRoot);
-    return worktrees.some((wt) => wt.path === path16);
+}
+async function loadConfig(workspaceRoot) {
+  const globalConfig = await loadGlobalConfig();
+  const normalizedPath = path9.resolve(workspaceRoot);
+  const projectConfig = globalConfig.projects?.[normalizedPath] ?? {};
+  const defaults = globalConfig.defaults ?? {};
+  return {
+    ...defaults,
+    ...projectConfig,
+    worktreeCopyPatterns: [
+      .../* @__PURE__ */ new Set([
+        ...defaults.worktreeCopyPatterns ?? [],
+        ...projectConfig.worktreeCopyPatterns ?? []
+      ])
+    ]
+  };
+}
+function getWorktreeCopyPatterns(config) {
+  return config.worktreeCopyPatterns ?? [];
+}
+var GLOBAL_CONFIG_PATH;
+var init_config = __esm({
+  "dist/config.js"() {
+    "use strict";
+    GLOBAL_CONFIG_PATH = path9.join(os4.homedir(), ".code-squad", "config.json");
   }
-  async getWorktreeBranch(worktreePath) {
-    try {
-      const { stdout } = await exec(`cd "${worktreePath}" && git rev-parse --abbrev-ref HEAD`, execOptions);
-      return stdout.trim();
-    } catch (error) {
-      throw new Error(`Failed to get branch name: ${error.message}`);
-    }
+});
+
+// dist/fileUtils.js
+import * as fs10 from "fs";
+import * as path10 from "path";
+import fg from "fast-glob";
+async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
+  const copied = [];
+  const failed = [];
+  if (patterns.length === 0) {
+    return { copied, failed };
   }
-  /**
-   * 현재 디렉토리가 워크트리인지 확인하고 컨텍스트 반환
-   */
-  async getWorktreeContext(cwd) {
-    let commonDir = null;
-    try {
-      const { stdout } = await exec(`cd "${cwd}" && git rev-parse --git-common-dir`, execOptions);
-      commonDir = stdout.trim();
-    } catch {
-      return { isWorktree: false, mainRoot: null, currentPath: cwd, branch: null };
-    }
-    const isWorktree = commonDir !== ".git";
-    if (!isWorktree) {
-      return { isWorktree: false, mainRoot: cwd, currentPath: cwd, branch: null };
-    }
-    let mainRoot = null;
+  for (const pattern of patterns) {
     try {
-      const { stdout } = await exec(`cd "${cwd}" && git worktree list --porcelain`, execOptions);
-      const match = stdout.match(/^worktree (.+)$/m);
-      mainRoot = match ? match[1] : null;
+      const files = await fg(pattern, {
+        cwd: sourceRoot,
+        absolute: true,
+        onlyFiles: true,
+        dot: true
+        // .env 같은 dotfile도 매칭
+      });
+      for (const absolutePath of files) {
+        try {
+          await copySingleFile(absolutePath, sourceRoot, destRoot);
+          const relativePath = path10.relative(sourceRoot, absolutePath);
+          copied.push(relativePath);
+        } catch {
+          const relativePath = path10.relative(sourceRoot, absolutePath);
+          failed.push(relativePath);
+        }
+      }
     } catch {
     }
-    const branch = await this.getWorktreeBranch(cwd).catch(() => null);
-    return { isWorktree, mainRoot, currentPath: cwd, branch };
   }
-  /**
-   * staged 또는 unstaged 변경사항이 있는지 확인 (untracked 제외)
-   */
-  async hasDirtyState(workspacePath) {
-    try {
-      const { stdout } = await exec(`cd "${workspacePath}" && git status --porcelain`, execOptions);
-      const lines = stdout.split("\n").filter((line) => line.trim());
-      const dirtyLines = lines.filter((line) => !line.startsWith("??"));
-      return dirtyLines.length > 0;
-    } catch {
-      return true;
-    }
+  return { copied, failed };
+}
+async function copySingleFile(absolutePath, sourceRoot, destRoot) {
+  const relativePath = path10.relative(sourceRoot, absolutePath);
+  const destPath = path10.join(destRoot, relativePath);
+  const destDir = path10.dirname(destPath);
+  await fs10.promises.mkdir(destDir, { recursive: true });
+  await fs10.promises.copyFile(absolutePath, destPath);
+}
+var init_fileUtils = __esm({
+  "dist/fileUtils.js"() {
+    "use strict";
   }
-};
+});
 
-// dist/ui/prompts.js
-import { createPrompt, useState, useKeypress, usePrefix, isEnterKey, isBackspaceKey } from "@inquirer/core";
-import { confirm } from "@inquirer/prompts";
-import chalk from "chalk";
-import * as path from "path";
-var cancelableInput = createPrompt((config, done) => {
-  const [value, setValue] = useState(config.default || "");
-  const [error, setError] = useState(null);
-  const prefix = usePrefix({ status: "idle" });
-  useKeypress((key, rl) => {
-    if (key.name === "escape") {
-      done(null);
-    } else if (isEnterKey(key)) {
-      if (config.validate) {
-        const result = config.validate(value);
-        if (result !== true) {
-          setError(typeof result === "string" ? result : "Invalid input");
-          return;
-        }
-      }
-      done(value);
-    } else if (isBackspaceKey(key)) {
-      setValue(value.slice(0, -1));
-      setError(null);
-    } else if (key.ctrl || key.name === "tab" || key.name === "up" || key.name === "down") {
-    } else {
-      const seq = key.sequence;
-      if (seq && seq.length === 1 && seq >= " ") {
-        setValue(value + seq);
-        setError(null);
+// dist/tui/App.js
+var App_exports = {};
+__export(App_exports, {
+  runTui: () => runTui
+});
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback } from "react";
+import { render, Box, Text, useInput, useApp } from "ink";
+import * as path11 from "path";
+import * as os5 from "os";
+function shorten(p) {
+  const home = os5.homedir();
+  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}
+function App({ initialWorktrees, root }) {
+  const { exit } = useApp();
+  const [view, setView] = useState("list");
+  const [worktrees, setWorktrees] = useState(initialWorktrees);
+  const [cursor, setCursor] = useState(0);
+  const [input, setInput] = useState("");
+  const [msg, setMsg] = useState(null);
+  const [busy, setBusy] = useState(false);
+  useEffect(() => {
+    if (!msg)
+      return;
+    const t = setTimeout(() => setMsg(null), 2e3);
+    return () => clearTimeout(t);
+  }, [msg]);
+  const refresh = useCallback(async () => {
+    const wts = await git.listWorktrees(root);
+    setWorktrees(wts);
+    setCursor((c) => Math.min(c, Math.max(0, wts.length - 1)));
+  }, [root]);
+  useInput((ch, key) => {
+    if (busy)
+      return;
+    if (view === "list") {
+      if (key.upArrow) {
+        setCursor((c) => Math.max(0, c - 1));
+      } else if (key.downArrow) {
+        setCursor((c) => Math.min(worktrees.length - 1, c + 1));
+      } else if (key.return && worktrees.length > 0) {
+        process.stdout.write(worktrees[cursor].path + "\n");
+        exit();
+      } else if (ch === "n") {
+        setView("create");
+        setInput("");
+      } else if (ch === "d" && worktrees.length > 0) {
+        setView("delete");
+      } else if (ch === "q" || key.escape) {
+        exit();
       }
+      return;
     }
-  });
-  const errorMsg = error ? chalk.red(`
-${error}`) : "";
-  return `${prefix} ${config.message} ${chalk.cyan(value)}${errorMsg}
-${chalk.dim("ESC:cancel Enter:confirm")}`;
-});
-function truncatePath(fullPath, maxLen) {
-  if (fullPath.length <= maxLen)
-    return fullPath;
-  const home = process.env.HOME || "";
-  let display = fullPath.startsWith(home) ? "~" + fullPath.slice(home.length) : fullPath;
-  if (display.length <= maxLen)
-    return display;
-  const parts = display.split(path.sep);
-  if (parts.length > 2) {
-    return "\u2026/" + parts.slice(-2).join("/");
-  }
-  return "\u2026" + display.slice(-maxLen + 1);
-}
-var vimSelect = createPrompt((config, done) => {
-  const { choices, pageSize = 15, shortcuts = [] } = config;
-  const enabledChoices = choices.filter((c) => !c.disabled);
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const prefix = usePrefix({ status: "idle" });
-  useKeypress((key) => {
-    if (key.name === "j" || key.name === "down") {
-      const nextIndex = (selectedIndex + 1) % enabledChoices.length;
-      setSelectedIndex(nextIndex);
-    } else if (key.name === "k" || key.name === "up") {
-      const prevIndex = (selectedIndex - 1 + enabledChoices.length) % enabledChoices.length;
-      setSelectedIndex(prevIndex);
-    } else if (isEnterKey(key)) {
-      done(enabledChoices[selectedIndex].value);
-    } else if (key.name === "escape" || key.name === "b") {
-      const backShortcut = shortcuts.find((s) => s.key === "back");
-      if (backShortcut) {
-        done(backShortcut.value);
+    if (view === "create") {
+      if (key.escape) {
+        setView("list");
+        return;
       }
-    } else {
-      const shortcut = shortcuts.find((s) => s.key === key.name);
-      if (shortcut) {
-        done(shortcut.value);
+      if (key.return && input.trim()) {
+        const name = input.trim();
+        setBusy(true);
+        const base = path11.join(path11.dirname(root), `${path11.basename(root)}.worktree`);
+        const wtPath = path11.join(base, name);
+        git.createWorktree(wtPath, name, root).then(async () => {
+          const config = await loadConfig(root);
+          const patterns = getWorktreeCopyPatterns(config);
+          if (patterns.length > 0) {
+            await copyFilesWithPatterns(root, wtPath, patterns);
+          }
+          process.stdout.write(wtPath + "\n");
+          exit();
+        }).catch((e) => {
+          setMsg({ text: e.message, color: "red" });
+          setView("list");
+          setBusy(false);
+        });
+        return;
       }
-    }
-  });
-  const totalItems = enabledChoices.length;
-  const halfPage = Math.floor(pageSize / 2);
-  let startIndex = 0;
-  if (totalItems > pageSize) {
-    if (selectedIndex <= halfPage) {
-      startIndex = 0;
-    } else if (selectedIndex >= totalItems - halfPage) {
-      startIndex = totalItems - pageSize;
-    } else {
-      startIndex = selectedIndex - halfPage;
-    }
-  }
-  const visibleChoices = enabledChoices.slice(startIndex, startIndex + pageSize);
-  const lines = visibleChoices.map((choice, i) => {
-    const actualIndex = startIndex + i;
-    const isSelected = actualIndex === selectedIndex;
-    const cursor = isSelected ? chalk.cyan("\u276F") : " ";
-    const name = isSelected ? chalk.cyan(choice.name) : choice.name;
-    return `${cursor} ${name}`;
-  });
-  if (startIndex > 0) {
-    lines.unshift(chalk.dim("  \u2191 more"));
-  }
-  if (startIndex + pageSize < totalItems) {
-    lines.push(chalk.dim("  \u2193 more"));
-  }
-  const shortcutHints = shortcuts.filter((s) => s.description).map((s) => chalk.dim(`${s.key}:${s.description}`)).join(" ");
-  const hint = chalk.dim("j/k:navigate enter:select") + (shortcutHints ? " " + shortcutHints : "");
-  return `${prefix} ${chalk.bold(config.message)}
-${lines.join("\n")}
-${hint}`;
-});
-async function selectThread(threads, repoName) {
-  const cols = process.stdout.columns || 80;
-  const nameWidth = 18;
-  const prefixWidth = 6;
-  const pathMaxLen = Math.max(20, cols - nameWidth - prefixWidth - 5);
-  const threadChoices = threads.map((t) => {
-    const typeIcon = t.type === "worktree" ? chalk.cyan("[W]") : chalk.yellow("[L]");
-    const displayPath = truncatePath(t.path, pathMaxLen);
-    return {
-      name: `${typeIcon} ${t.name.padEnd(nameWidth)} ${chalk.dim(displayPath)}`,
-      value: { type: "existing", thread: t },
-      thread: t
-    };
-  });
-  const newChoice = {
-    name: chalk.green("+ \uC0C8 \uC791\uC5C5"),
-    value: { type: "new" },
-    thread: null
-  };
-  const allChoices = [...threadChoices, newChoice];
-  const threadSelect = createPrompt((config, done) => {
-    const [selectedIndex, setSelectedIndex] = useState(0);
-    const prefix = usePrefix({ status: "idle" });
-    const pageSize = 15;
-    useKeypress((key) => {
-      if (key.name === "j" || key.name === "down") {
-        setSelectedIndex((selectedIndex + 1) % allChoices.length);
-      } else if (key.name === "k" || key.name === "up") {
-        setSelectedIndex((selectedIndex - 1 + allChoices.length) % allChoices.length);
-      } else if (isEnterKey(key)) {
-        done(allChoices[selectedIndex].value);
-      } else if (key.name === "n") {
-        done({ type: "new" });
-      } else if (key.name === "q") {
-        done({ type: "exit" });
-      } else if (key.name === "d") {
-        const current = allChoices[selectedIndex];
-        if (current.thread) {
-          done({ type: "delete-selected", thread: current.thread });
-        }
+      if (key.backspace || key.delete) {
+        setInput((v) => v.slice(0, -1));
+        return;
       }
-    });
-    const totalItems = allChoices.length;
-    const halfPage = Math.floor(pageSize / 2);
-    let startIndex = 0;
-    if (totalItems > pageSize) {
-      if (selectedIndex <= halfPage) {
-        startIndex = 0;
-      } else if (selectedIndex >= totalItems - halfPage) {
-        startIndex = totalItems - pageSize;
-      } else {
-        startIndex = selectedIndex - halfPage;
+      if (ch && !key.ctrl && !key.meta) {
+        setInput((v) => v + ch);
       }
+      return;
     }
-    const visibleChoices = allChoices.slice(startIndex, startIndex + pageSize);
-    const lines = visibleChoices.map((choice, i) => {
-      const actualIndex = startIndex + i;
-      const isSelected = actualIndex === selectedIndex;
-      const cursor = isSelected ? chalk.cyan("\u276F") : " ";
-      const name = isSelected ? chalk.cyan(choice.name) : choice.name;
-      return `${cursor} ${name}`;
-    });
-    if (startIndex > 0) {
-      lines.unshift(chalk.dim("  \u2191 more"));
-    }
-    if (startIndex + pageSize < totalItems) {
-      lines.push(chalk.dim("  \u2193 more"));
-    }
-    const hint = chalk.dim("j/k:nav n:new d:delete q:quit");
-    return `${prefix} ${config.message}
-${lines.join("\n")}
-${hint}`;
-  });
-  return threadSelect({ message: chalk.bold(repoName) });
-}
-async function selectThreadAction(threadName) {
-  const choices = [
-    { name: "\uD130\uBBF8\uB110 \uC5F4\uAE30", value: "open" },
-    { name: chalk.red("\uC0AD\uC81C\uD558\uAE30"), value: "delete" },
-    { name: chalk.dim("\u2190 \uB4A4\uB85C"), value: "back" }
-  ];
-  return vimSelect({
-    message: `'${threadName}'`,
-    choices,
-    shortcuts: [{ key: "back", value: "back" }]
-  });
-}
-async function selectNewThreadType() {
-  const choices = [
-    {
-      name: chalk.cyan("\uC6CC\uD06C\uD2B8\uB9AC") + chalk.dim(" - \uC0C8 \uBE0C\uB79C\uCE58\uC640 \uB514\uB809\uD1A0\uB9AC \uC0DD\uC131"),
-      value: "worktree"
-    },
-    {
-      name: chalk.yellow("\uB85C\uCEEC") + chalk.dim(" - \uD604\uC7AC \uB514\uB809\uD1A0\uB9AC\uC5D0\uC11C \uC791\uC5C5"),
-      value: "local"
-    },
-    { name: chalk.dim("\u2190 \uB4A4\uB85C"), value: "back" }
-  ];
-  return vimSelect({
-    message: "\uC0C8 \uC791\uC5C5 \uD0C0\uC785",
-    choices,
-    shortcuts: [{ key: "back", value: "back" }]
-  });
-}
-async function newWorktreeForm(defaultBasePath) {
-  const name = await cancelableInput({
-    message: "\uC6CC\uD06C\uD2B8\uB9AC \uC774\uB984:",
-    validate: (value) => {
-      if (!value.trim())
-        return "\uC774\uB984\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
-      if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
-        return "\uC601\uBB38, \uC22B\uC790, -, _ \uB9CC \uC0AC\uC6A9 \uAC00\uB2A5";
+    if (view === "delete") {
+      if (ch === "y" || key.return) {
+        const target = worktrees[cursor];
+        setBusy(true);
+        git.removeWorktree(target.path, root, true).then(() => git.deleteBranch(target.branch, root, true)).then(async () => {
+          setMsg({ text: `Deleted ${target.branch}`, color: "green" });
+          await refresh();
+          setBusy(false);
+          setView("list");
+        }).catch((e) => {
+          setMsg({ text: e.message, color: "red" });
+          setBusy(false);
+          setView("list");
+        });
+      } else if (ch === "n" || key.escape) {
+        setView("list");
       }
-      return true;
-    }
-  });
-  if (!name)
-    return null;
-  const defaultPath = `${defaultBasePath}/${name}`;
-  const pathInput = await cancelableInput({
-    message: "\uACBD\uB85C:",
-    default: defaultPath
-  });
-  if (!pathInput)
-    return null;
-  return { name, path: pathInput };
-}
-async function newLocalForm() {
-  const name = await cancelableInput({
-    message: "\uB85C\uCEEC \uC2A4\uB808\uB4DC \uC774\uB984:",
-    validate: (value) => {
-      if (!value.trim())
-        return "\uC774\uB984\uC744 \uC785\uB825\uD574\uC8FC\uC138\uC694";
-      return true;
     }
   });
-  return name || null;
-}
-async function confirmDeleteWorktree(threadName) {
-  const confirmed = await confirm({
-    message: `'${threadName}' \uC6CC\uD06C\uD2B8\uB9AC\uB97C \uC0AD\uC81C\uD560\uAE4C\uC694?`,
-    default: true
-  });
-  if (!confirmed) {
-    return { confirmed: false, removeGitWorktree: false };
+  return _jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Code Squad" }), busy && _jsx(Text, { color: "yellow", children: " ..." })] }), view === "list" && (worktrees.length === 0 ? _jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "No worktrees yet. Press " }), _jsx(Text, { color: "yellow", children: "n" }), _jsx(Text, { dimColor: true, children: " to create one." })] }) : _jsx(Box, { flexDirection: "column", marginBottom: 1, children: worktrees.map((wt, i) => _jsxs(Box, { children: [_jsx(Text, { color: i === cursor ? "cyan" : void 0, children: i === cursor ? "\u276F " : "  " }), _jsx(Text, { bold: i === cursor, children: wt.branch.padEnd(20) }), _jsxs(Text, { dimColor: true, children: [" ", shorten(wt.path)] })] }, wt.path)) })), view === "create" && _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { bold: true, children: "New Worktree" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "> " }), _jsx(Text, { color: "cyan", children: input }), _jsx(Text, { dimColor: true, children: "\u2588" })] })] }), view === "delete" && worktrees[cursor] && _jsx(Box, { flexDirection: "column", marginBottom: 1, children: _jsxs(Text, { children: ["Delete ", _jsx(Text, { bold: true, color: "yellow", children: worktrees[cursor].branch }), "?"] }) }), msg && _jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: msg.color, children: msg.text }) }), _jsxs(Box, { gap: 2, children: [view === "list" && _jsxs(_Fragment, { children: [worktrees.length > 0 && _jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "\u2191\u2193" }), " ", _jsx(Text, { dimColor: true, children: "navigate" })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "\u21B5" }), " ", _jsx(Text, { dimColor: true, children: "switch" })] })] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "n" }), " ", _jsx(Text, { dimColor: true, children: "new" })] }), worktrees.length > 0 && _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "d" }), " ", _jsx(Text, { dimColor: true, children: "delete" })] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "q" }), " ", _jsx(Text, { dimColor: true, children: "quit" })] })] }), view === "create" && _jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "\u21B5" }), " ", _jsx(Text, { dimColor: true, children: "create" })] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "esc" }), " ", _jsx(Text, { dimColor: true, children: "cancel" })] })] }), view === "delete" && _jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "y" }), " ", _jsx(Text, { dimColor: true, children: "confirm" })] }), _jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "n" }), " ", _jsx(Text, { dimColor: true, children: "cancel" })] })] })] })] });
+}
+async function runTui(workspaceRoot) {
+  const worktrees = await git.listWorktrees(workspaceRoot);
+  const { waitUntilExit } = render(_jsx(App, { initialWorktrees: worktrees, root: workspaceRoot }), { stdout: process.stderr });
+  await waitUntilExit();
+}
+var git;
+var init_App = __esm({
+  "dist/tui/App.js"() {
+    "use strict";
+    init_GitAdapter();
+    init_config();
+    init_fileUtils();
+    git = new GitAdapter();
   }
-  const removeGitWorktree = await confirm({
-    message: "Git worktree\uC640 \uBE0C\uB79C\uCE58\uB3C4 \uD568\uAED8 \uC0AD\uC81C\uD560\uAE4C\uC694?",
-    default: true
-  });
-  return { confirmed, removeGitWorktree };
-}
-async function confirmDeleteLocal(threadName) {
-  return await confirm({
-    message: `'${threadName}' \uB85C\uCEEC \uC2A4\uB808\uB4DC\uB97C \uC0AD\uC81C\uD560\uAE4C\uC694?`,
-    default: true
-  });
-}
+});
 
 // dist/index.js
-import { confirm as confirm3 } from "@inquirer/prompts";
+init_GitAdapter();
+import * as path12 from "path";
+import chalk from "chalk";
+import { confirm } from "@inquirer/prompts";
 
 // dist/flip/server/Server.js
 import express2 from "express";
@@ -433,7 +390,7 @@ import net from "net";
 // dist/flip/routes/files.js
 import { Router } from "express";
 import fs2 from "fs";
-import path2 from "path";
+import path from "path";
 
 // dist/flip/constants/filters.js
 var FILTERED_PATTERNS = /* @__PURE__ */ new Set([
@@ -500,8 +457,8 @@ function buildFileTree(rootPath, currentPath, maxDepth, depth = 0) {
     return a.name.localeCompare(b.name);
   });
   for (const entry of entries) {
-    const fullPath = path2.join(currentPath, entry.name);
-    const relativePath = path2.relative(rootPath, fullPath);
+    const fullPath = path.join(currentPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath);
     const filtered = isFiltered(entry.name);
     const node = {
       path: relativePath,
@@ -521,8 +478,8 @@ function collectFlatFiles(rootPath, currentPath, maxDepth, depth = 0, result = {
     return result;
   const entries = fs2.readdirSync(currentPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path2.join(currentPath, entry.name);
-    const relativePath = path2.relative(rootPath, fullPath);
+    const fullPath = path.join(currentPath, entry.name);
+    const relativePath = path.relative(rootPath, fullPath);
     if (isFiltered(entry.name)) {
       if (entry.isDirectory()) {
         result.filteredDirs.push(relativePath);
@@ -592,7 +549,7 @@ router.get("/flat", (req, res) => {
 // dist/flip/routes/file.js
 import { Router as Router2 } from "express";
 import fs3 from "fs";
-import path3 from "path";
+import path2 from "path";
 var router2 = Router2();
 var extensionMap = {
   // JavaScript/TypeScript
@@ -705,11 +662,11 @@ var filenameMap = {
   "CODEOWNERS": "gitignore"
 };
 function detectLanguage(filePath) {
-  const basename5 = path3.basename(filePath);
-  if (filenameMap[basename5]) {
-    return filenameMap[basename5];
+  const basename3 = path2.basename(filePath);
+  if (filenameMap[basename3]) {
+    return filenameMap[basename3];
   }
-  const ext = path3.extname(filePath).slice(1).toLowerCase();
+  const ext = path2.extname(filePath).slice(1).toLowerCase();
   if (extensionMap[ext]) {
     return extensionMap[ext];
   }
@@ -738,9 +695,9 @@ router2.get("/", (req, res) => {
     res.status(400).json({ error: "Missing path parameter" });
     return;
   }
-  const filePath = path3.join(cwd, relativePath);
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedCwd = path3.resolve(cwd);
+  const filePath = path2.join(cwd, relativePath);
+  const resolvedPath = path2.resolve(filePath);
+  const resolvedCwd = path2.resolve(cwd);
   if (!resolvedPath.startsWith(resolvedCwd)) {
     res.status(403).json({ error: "Access denied" });
     return;
@@ -767,7 +724,7 @@ router2.get("/", (req, res) => {
 import { Router as Router3 } from "express";
 import { execSync } from "child_process";
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path3 from "path";
 var router3 = Router3();
 function parseGitStatus(output) {
   const files = [];
@@ -927,7 +884,7 @@ router3.get("/diff", (req, res) => {
     res.status(400).json({ error: "Missing path parameter" });
     return;
   }
-  const fullPath = path4.join(cwd, relativePath);
+  const fullPath = path3.join(cwd, relativePath);
   let fileStatus = "modified";
   try {
     const statusOutput = execSync(`git status --porcelain -- "${relativePath}"`, {
@@ -1003,10 +960,10 @@ function formatComments(comments) {
 // dist/flip/output/clipboard.js
 import { spawn } from "child_process";
 import fs5 from "fs";
-import path5 from "path";
+import path4 from "path";
 import os from "os";
 async function copyToClipboard(text) {
-  const tmpFile = path5.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
+  const tmpFile = path4.join(os.tmpdir(), `flip-clipboard-${Date.now()}.txt`);
   const cleanupTmpFile = () => {
     try {
       fs5.unlinkSync(tmpFile);
@@ -1052,7 +1009,7 @@ async function copyToClipboard(text) {
 // dist/flip/output/autopaste.js
 import { spawn as spawn2 } from "child_process";
 import fs6 from "fs";
-import path6 from "path";
+import path5 from "path";
 import os2 from "os";
 async function schedulePaste(sessionId) {
   if (process.platform !== "darwin") {
@@ -1062,7 +1019,7 @@ async function schedulePaste(sessionId) {
   await pasteToOriginalSession(sessionId);
 }
 async function pasteToOriginalSession(sessionId) {
-  const sessionFile = path6.join(os2.tmpdir(), `flip-view-session-${sessionId}`);
+  const sessionFile = path5.join(os2.tmpdir(), `flip-view-session-${sessionId}`);
   let itermSessionId;
   try {
     itermSessionId = fs6.readFileSync(sessionFile, "utf-8").trim();
@@ -1109,7 +1066,7 @@ async function pasteToOriginalSession(sessionId) {
         `;
   }
   try {
-    const tmpScript = path6.join(os2.tmpdir(), `flip-paste-${Date.now()}.scpt`);
+    const tmpScript = path5.join(os2.tmpdir(), `flip-paste-${Date.now()}.scpt`);
     fs6.writeFileSync(tmpScript, script);
     const cleanupScript = () => {
       try {
@@ -1188,21 +1145,21 @@ router5.post("/", async (req, res) => {
 // dist/flip/routes/static.js
 import { Router as Router6 } from "express";
 import express from "express";
-import path7 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
 import fs7 from "fs";
 function createStaticRouter() {
   const router6 = Router6();
   const __filename = fileURLToPath(import.meta.url);
-  const __dirname = path7.dirname(__filename);
-  let distPath = path7.resolve(__dirname, "flip-ui/dist");
+  const __dirname = path6.dirname(__filename);
+  let distPath = path6.resolve(__dirname, "flip-ui/dist");
   if (!fs7.existsSync(distPath)) {
-    distPath = path7.resolve(__dirname, "../../../flip-ui/dist");
+    distPath = path6.resolve(__dirname, "../../../flip-ui/dist");
   }
   if (fs7.existsSync(distPath)) {
     router6.use(express.static(distPath));
     router6.get("*", (req, res) => {
-      const indexPath = path7.join(distPath, "index.html");
+      const indexPath = path6.join(distPath, "index.html");
       if (fs7.existsSync(indexPath)) {
         res.sendFile(indexPath);
       } else {
@@ -1310,7 +1267,7 @@ function createChangesRouter(sessionManager) {
 
 // dist/flip/watcher/FileWatcher.js
 import chokidar from "chokidar";
-import * as path8 from "path";
+import * as path7 from "path";
 var FileWatcher = class {
   watcher = null;
   cwd;
@@ -1327,8 +1284,8 @@ var FileWatcher = class {
   }
   start() {
     const shouldIgnore = (filePath) => {
-      const relativePath = path8.relative(this.cwd, filePath);
-      const segments = relativePath.split(path8.sep);
+      const relativePath = path7.relative(this.cwd, filePath);
+      const segments = relativePath.split(path7.sep);
       return segments.some((segment) => segment !== ".git" && FILTERED_PATTERNS.has(segment));
     };
     this.watcher = chokidar.watch(this.cwd, {
@@ -1376,7 +1333,7 @@ var FileWatcher = class {
     this.gitChangedCallbacks.push(callback);
   }
   handleFileEvent(filePath, event) {
-    const relativePath = path8.relative(this.cwd, filePath);
+    const relativePath = path7.relative(this.cwd, filePath);
     if (relativePath.startsWith(".git")) {
       this.emitGitChanged();
       return;
@@ -1390,7 +1347,7 @@ var FileWatcher = class {
     this.emitGitChanged();
   }
   handleDirEvent(dirPath, event) {
-    const relativePath = path8.relative(this.cwd, dirPath);
+    const relativePath = path7.relative(this.cwd, dirPath);
     if (relativePath.startsWith(".git")) {
       return;
     }
@@ -1750,7 +1707,7 @@ async function findExistingServer(startPort, endPort) {
 
 // dist/flip/index.js
 import open from "open";
-import path9 from "path";
+import path8 from "path";
 import fs8 from "fs";
 import os3 from "os";
 import http2 from "http";
@@ -1849,7 +1806,7 @@ async function runFlip(args) {
   } else {
     command = "oneshot";
   }
-  const cwd = pathArg ? path9.resolve(pathArg) : process.cwd();
+  const cwd = pathArg ? path8.resolve(pathArg) : process.cwd();
   const finalSessionId = sessionId || getSessionId();
   switch (command) {
     case "setup": {
@@ -1963,7 +1920,7 @@ async function setupHotkey() {
   } catch {
     csqPath = new URL(import.meta.url).pathname;
   }
-  const nodeDir = path9.dirname(nodePath);
+  const nodeDir = path8.dirname(nodePath);
   const wrapperScript = `#!/bin/bash
 # Add node to PATH (coprocess doesn't inherit shell PATH)
 export PATH="${nodeDir}:$PATH"
@@ -1989,8 +1946,8 @@ else
     exec ${csqPath} flip
 fi
 `;
-  const scriptDir = path9.join(os3.homedir(), ".config", "csq");
-  const scriptPath = path9.join(scriptDir, "flip-hotkey.sh");
+  const scriptDir = path8.join(os3.homedir(), ".config", "csq");
+  const scriptPath = path8.join(scriptDir, "flip-hotkey.sh");
   if (!fs8.existsSync(scriptDir)) {
     fs8.mkdirSync(scriptDir, { recursive: true });
   }
@@ -2016,1479 +1973,54 @@ fi
   console.log("");
 }
 
-// dist/dash/index.js
-import chalk2 from "chalk";
-import * as path14 from "path";
-import { confirm as confirm2 } from "@inquirer/prompts";
-
-// dist/dash/TmuxAdapter.js
-import { exec as execCallback2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var exec2 = promisify2(execCallback2);
-var execOptions2 = { maxBuffer: 1024 * 1024 };
-var TmuxAdapter = class {
-  /**
-   * tmux 설치 여부 확인
-   */
-  async isTmuxAvailable() {
-    try {
-      await exec2("which tmux", execOptions2);
-      return true;
-    } catch {
-      return false;
-    }
+// dist/index.js
+init_config();
+init_fileUtils();
+process.on("SIGINT", () => {
+  process.exit(130);
+});
+var gitAdapter = new GitAdapter();
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (command === "--init" || command === "init") {
+    printShellInit();
+    return;
   }
-  /**
-   * 현재 tmux 세션 내부인지 확인
-   */
-  isInsideTmux() {
-    return !!process.env.TMUX;
-  }
-  /**
-   * 세션 존재 여부 확인
-   */
-  async hasSession(name) {
-    try {
-      await exec2(`tmux has-session -t "${name}"`, execOptions2);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * 새 tmux 세션 생성
-   */
-  async createSession(name, cwd) {
-    await exec2(`tmux new-session -d -s "${name}" -c "${cwd}"`, execOptions2);
-  }
-  /**
-   * 세션 생성 또는 기존 세션 반환
-   * @returns true if new session created, false if existing session
-   */
-  async ensureSession(name, cwd) {
-    if (await this.hasSession(name)) {
-      return false;
-    }
-    await this.createSession(name, cwd);
-    return true;
-  }
-  /**
-   * 세션에 attach (spawn 사용)
-   */
-  async attachSession(name) {
-    const { spawn: spawn3 } = await import("child_process");
-    return new Promise((resolve2, reject) => {
-      const tmux = spawn3("tmux", ["attach-session", "-t", name], { stdio: "inherit" });
-      tmux.on("close", (code) => {
-        if (code === 0)
-          resolve2();
-        else
-          reject(new Error(`tmux attach failed with code ${code}`));
-      });
-      tmux.on("error", reject);
-    });
-  }
-  /**
-   * 현재 pane 분할 (수직/수평)
-   * @param direction 'v' = 수직 (좌우), 'h' = 수평 (상하)
-   * @param cwd 새 pane의 작업 디렉토리
-   * @param percent 새 pane의 크기 비율 (옵션)
-   */
-  async splitWindow(direction, cwd, percent) {
-    const flag = direction === "v" ? "-h" : "-v";
-    const cwdFlag = cwd ? `-c "${cwd}"` : "";
-    const percentFlag = percent ? `-p ${percent}` : "";
-    await exec2(`tmux split-window ${flag} ${cwdFlag} ${percentFlag}`, execOptions2);
-    const { stdout } = await exec2('tmux display-message -p "#{pane_id}"', execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * 특정 pane 선택 (포커스)
-   */
-  async selectPane(paneId) {
-    await exec2(`tmux select-pane -t "${paneId}"`, execOptions2);
-  }
-  /**
-   * pane 목록 조회
-   */
-  async listPanes() {
-    try {
-      const { stdout } = await exec2('tmux list-panes -F "#{pane_id}|#{pane_index}|#{pane_active}|#{pane_current_path}"', execOptions2);
-      return stdout.trim().split("\n").filter(Boolean).map((line) => {
-        const [id, index, active, cwd] = line.split("|");
-        return {
-          id,
-          index: parseInt(index, 10),
-          active: active === "1",
-          cwd
-        };
-      });
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * pane 종료
-   */
-  async killPane(paneId) {
-    await exec2(`tmux kill-pane -t "${paneId}"`, execOptions2);
-  }
-  /**
-   * pane에 키 전송
-   */
-  async sendKeys(paneId, keys) {
-    const escaped = keys.replace(/"/g, '\\"');
-    await exec2(`tmux send-keys -t "${paneId}" "${escaped}"`, execOptions2);
-  }
-  /**
-   * pane에 특수 키 전송 (C-l, C-c, Enter 등 tmux 키 이름)
-   */
-  async sendSpecialKey(paneId, keyName) {
-    await exec2(`tmux send-keys -t "${paneId}" ${keyName}`, execOptions2);
-  }
-  /**
-   * pane에 Enter 키 전송
-   */
-  async sendEnter(paneId) {
-    await exec2(`tmux send-keys -t "${paneId}" Enter`, execOptions2);
-  }
-  /**
-   * 현재 window의 레이아웃 설정
-   * @param layout 'even-horizontal' | 'even-vertical' | 'main-horizontal' | 'main-vertical' | 'tiled'
-   */
-  async setLayout(layout) {
-    await exec2(`tmux select-layout ${layout}`, execOptions2);
-  }
-  /**
-   * pane 크기 조정
-   */
-  async resizePane(paneId, direction, amount) {
-    await exec2(`tmux resize-pane -t "${paneId}" -${direction} ${amount}`, execOptions2);
-  }
-  /**
-   * pane 너비를 절대값으로 설정
-   */
-  async setPaneWidth(paneId, width) {
-    await exec2(`tmux resize-pane -t "${paneId}" -x ${width}`, execOptions2);
-  }
-  /**
-   * pane을 별도 window로 분리 (백그라운드 실행 유지)
-   * @returns 새로 생성된 window ID
-   */
-  async breakPaneToWindow(paneId) {
-    const { stdout } = await exec2(`tmux break-pane -d -s "${paneId}" -P -F "#{window_id}"`, execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * 특정 session:index에 window 생성
-   * @returns 새로 생성된 window ID
-   */
-  async createWindowAtIndex(sessionName, index, cwd) {
-    const { stdout } = await exec2(`tmux new-window -d -t "${sessionName}:${index}" -c "${cwd}" -P -F "#{window_id}"`, execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * 숨겨진 window 생성 (단일 pane)
-   */
-  async createHiddenWindow(cwd) {
-    const cwdFlag = cwd ? `-c "${cwd}"` : "";
-    const { stdout } = await exec2(`tmux new-window -d ${cwdFlag} -P -F "#{window_id}"`, execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * window의 pane을 특정 pane과 swap
-   */
-  async swapPaneWithWindow(windowId, targetPaneId) {
-    await exec2(`tmux swap-pane -d -s "${windowId}.0" -t "${targetPaneId}"`, execOptions2);
-  }
-  /**
-   * window 내 단일 pane 너비 설정
-   */
-  async setWindowPaneWidth(windowId, width) {
-    await exec2(`tmux resize-pane -t "${windowId}.0" -x ${width}`, execOptions2);
-  }
-  /**
-   * pane index로 pane ID 조회 (현재 window)
-   */
-  async getPaneIdByIndex(index) {
-    try {
-      const { stdout } = await exec2('tmux list-panes -F "#{pane_index}|#{pane_id}"', execOptions2);
-      const match = stdout.trim().split("\n").map((line) => line.split("|")).find(([idx]) => parseInt(idx, 10) === index);
-      return match?.[1] ?? null;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * 숨겨진 window에서 pane을 현재 window로 가져옴
-   * @param windowId 숨겨진 window ID
-   * @param targetPaneId 옆에 배치할 target pane
-   * @returns 가져온 pane의 새 ID
-   */
-  async joinPaneFromWindow(windowId, targetPaneId) {
-    await exec2(`tmux join-pane -h -s "${windowId}.0" -t "${targetPaneId}"`, execOptions2);
-    const { stdout } = await exec2('tmux display-message -p "#{pane_id}"', execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * pane 숨기기 (width=0) - deprecated, use breakPaneToWindow
-   */
-  async hidePane(paneId) {
-    await exec2(`tmux resize-pane -t "${paneId}" -x 0`, execOptions2);
-  }
-  /**
-   * pane 표시 (지정 너비로 복원) - deprecated, use joinPaneFromWindow
-   */
-  async showPane(paneId, width) {
-    await exec2(`tmux resize-pane -t "${paneId}" -x ${width}`, execOptions2);
-  }
-  /**
-   * 현재 window 너비 조회
-   */
-  async getWindowWidth() {
-    const { stdout } = await exec2('tmux display-message -p "#{window_width}"', execOptions2);
-    return parseInt(stdout.trim(), 10);
-  }
-  /**
-   * pane 너비 조회
-   */
-  async getPaneWidth(paneId) {
-    const { stdout } = await exec2(`tmux display-message -t "${paneId}" -p "#{pane_width}"`, execOptions2);
-    return parseInt(stdout.trim(), 10);
-  }
-  /**
-   * pane 높이 조회
-   */
-  async getPaneHeight(paneId) {
-    const { stdout } = await exec2(`tmux display-message -t "${paneId}" -p "#{pane_height}"`, execOptions2);
-    return parseInt(stdout.trim(), 10);
-  }
-  /**
-   * 현재 세션 이름 조회
-   */
-  async getSessionName() {
-    try {
-      const { stdout } = await exec2('tmux display-message -p "#{session_name}"', execOptions2);
-      return stdout.trim();
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * 현재 pane ID 조회
-   */
-  async getCurrentPaneId() {
-    try {
-      const { stdout } = await exec2('tmux display-message -p "#{pane_id}"', execOptions2);
-      return stdout.trim();
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * UX 개선 설정 적용
-   * - 마우스 모드 활성화 (클릭 선택, 드래그 리사이징)
-   * - 활성 pane 테두리 강조
-   * - pane swap 단축키 (Ctrl+b m)
-   */
-  async applyUXSettings() {
-    const settings = [
-      "set -g mouse on",
-      // extended-keys 활성화 (Shift+Tab 등 modifier key 조합 인식에 필요)
-      "set -g extended-keys on",
-      "set -g pane-active-border-style 'fg=cyan,bold'",
-      "set -g pane-border-style 'fg=#444444'",
-      "set -g pane-border-lines single",
-      "set -g pane-border-status top",
-      "set -g pane-border-format ' #{pane_current_path} '",
-      // pane 번호 표시 시간 늘리기
-      "set -g display-panes-time 5000",
-      // pane 번호 색상
-      "set -g display-panes-colour '#444444'",
-      "set -g display-panes-active-colour cyan"
-    ];
-    for (const setting of settings) {
-      try {
-        await exec2(`tmux ${setting}`, execOptions2);
-      } catch {
-      }
-    }
-    try {
-      await exec2(`tmux bind-key m if-shell -F "#{!=:#{pane_index},0}" "display-menu -T 'Move Pane' -x P -y P 'Move Left' l 'if-shell -F \\"#{>:#{pane_index},1}\\" \\"swap-pane -U\\"' 'Move Right' r 'swap-pane -D' '' 'Swap #1' 1 'swap-pane -t 1' 'Swap #2' 2 'swap-pane -t 2' 'Swap #3' 3 'swap-pane -t 3' 'Swap #4' 4 'swap-pane -t 4' '' 'Cancel' q ''"`, execOptions2);
-    } catch {
-    }
-    try {
-      await exec2(`tmux bind-key -n BTab if-shell -F "#{==:#{pane_index},0}" "select-pane -t 1" "select-pane -t 0"`, execOptions2);
-    } catch {
-    }
-  }
-  /**
-   * 대시보드 pane 리사이즈 훅 설정
-   */
-  async setDashboardResizeHook(paneId, width) {
-    try {
-      await exec2(`tmux set -g @csq_dash_pane "${paneId}"`, execOptions2);
-      await exec2(`tmux set -g @csq_dash_width "${width}"`, execOptions2);
-      await exec2(`tmux set-hook after-resize-pane 'resize-pane -t "#{@csq_dash_pane}" -x #{@csq_dash_width}'`, execOptions2);
-    } catch {
-    }
-  }
-  /**
-   * main-vertical 레이아웃 적용 (왼쪽 고정, 오른쪽 분할)
-   * @param mainWidth 왼쪽 메인 pane 너비 (columns)
-   */
-  async applyMainVerticalLayout(mainWidth = 30) {
-    try {
-      await exec2(`tmux set-window-option main-pane-width ${mainWidth}`, execOptions2);
-      await exec2("tmux select-layout main-vertical", execOptions2);
-    } catch {
-    }
-  }
-  /**
-   * 특정 pane 기준으로 분할
-   * @param targetPaneId 분할할 대상 pane
-   * @param direction 'v' = 수직 (좌우), 'h' = 수평 (상하)
-   * @param cwd 새 pane의 작업 디렉토리
-   */
-  async splitPane(targetPaneId, direction, cwd) {
-    const flag = direction === "v" ? "-h" : "-v";
-    const cwdFlag = cwd ? `-c "${cwd}"` : "";
-    await exec2(`tmux split-window ${flag} -t "${targetPaneId}" ${cwdFlag}`, execOptions2);
-    const { stdout } = await exec2('tmux display-message -p "#{pane_id}"', execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * 현재 세션 종료
-   */
-  async killCurrentSession() {
-    await exec2("tmux kill-session", execOptions2);
-  }
-  /**
-   * 현재 클라이언트 detach (세션은 유지)
-   */
-  async detachClient() {
-    await exec2("tmux detach-client", execOptions2);
-  }
-  /**
-   * Detach client and kill a window in one atomic tmux command.
-   * Prevents flash of another window between kill and detach.
-   */
-  async detachAndKillWindow(sessionName, windowIndex) {
-    await exec2(`tmux detach-client \\; kill-window -t "${sessionName}:${windowIndex}"`, execOptions2);
-  }
-  /**
-   * 특정 window 종료
-   */
-  async killWindow(windowId) {
-    await exec2(`tmux kill-window -t "${windowId}"`, execOptions2);
-  }
-  /**
-   * pane 화면 클리어 (scrollback 포함)
-   */
-  async clearPane(paneId) {
-    await exec2(`tmux send-keys -t "${paneId}" -R`, execOptions2);
-    await exec2(`tmux clear-history -t "${paneId}"`, execOptions2);
-  }
-  /**
-   * 클라이언트 강제 리프레시
-   */
-  async refreshClient() {
-    await exec2("tmux refresh-client -S", execOptions2);
-  }
-  /**
-   * pane 위치 swap
-   * @param paneId 이동할 pane
-   * @param direction 'left' | 'right' | 'up' | 'down'
-   */
-  async swapPane(paneId, direction) {
-    const dirMap = {
-      left: "-U",
-      // swap with pane above/left
-      right: "-D",
-      // swap with pane below/right
-      up: "-U",
-      down: "-D"
-    };
-    await exec2(`tmux swap-pane -t "${paneId}" ${dirMap[direction]}`, execOptions2);
-  }
-  /**
-   * 대시보드 제외하고 오른쪽 pane들 균등 분할
-   * @param dashPaneId 대시보드 pane ID
-   * @param dashWidth 대시보드 너비 (columns)
-   */
-  async distributeRightPanes(dashPaneId, dashWidth = 35) {
-    try {
-      const { stdout: widthStr } = await exec2('tmux display-message -p "#{window_width}"', execOptions2);
-      const totalWidth = parseInt(widthStr.trim(), 10);
-      const panes = await this.listPanes();
-      const rightPanes = panes.filter((p) => p.id !== dashPaneId);
-      if (rightPanes.length === 0)
-        return;
-      const rightAreaWidth = totalWidth - dashWidth - 1;
-      const paneWidth = Math.floor(rightAreaWidth / rightPanes.length);
-      for (const pane of rightPanes) {
-        await exec2(`tmux resize-pane -t "${pane.id}" -x ${paneWidth}`, execOptions2);
-      }
-      await exec2(`tmux resize-pane -t "${dashPaneId}" -x ${dashWidth}`, execOptions2);
-    } catch {
-    }
-  }
-  // ============================================================
-  // Window 관련 메서드 (Task 1, 8)
-  // ============================================================
-  /**
-   * 현재 세션의 모든 window 목록 조회
-   */
-  async listWindows() {
-    try {
-      const { stdout } = await exec2('tmux list-windows -F "#{window_id}|#{window_index}|#{window_name}|#{pane_current_path}|#{window_active}"', execOptions2);
-      return stdout.trim().split("\n").filter(Boolean).map((line) => {
-        const [id, index, name, cwd, active] = line.split("|");
-        return {
-          id,
-          index: parseInt(index, 10),
-          name,
-          cwd,
-          active: active === "1"
-        };
-      });
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * 특정 window로 포커스 전환
-   */
-  async selectWindow(windowId) {
-    await exec2(`tmux select-window -t "${windowId}"`, execOptions2);
-  }
-  /**
-   * 새 window 생성
-   * @param cwd 작업 디렉토리 (옵션)
-   * @param name window 이름 (옵션)
-   * @returns 생성된 window ID
-   */
-  async createNewWindow(cwd, name) {
-    const cwdFlag = cwd ? `-c "${cwd}"` : "";
-    const nameFlag = name ? `-n "${name}"` : "";
-    const { stdout } = await exec2(`tmux new-window -d ${cwdFlag} ${nameFlag} -P -F "#{window_id}"`, execOptions2);
-    return stdout.trim();
-  }
-  /**
-   * 현재 window ID 조회
-   */
-  async getCurrentWindowId() {
-    try {
-      const { stdout } = await exec2('tmux display-message -p "#{window_id}"', execOptions2);
-      return stdout.trim();
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * 현재 window index 조회
-   */
-  async getCurrentWindowIndex() {
-    try {
-      const { stdout } = await exec2('tmux display-message -p "#{window_index}"', execOptions2);
-      return parseInt(stdout.trim(), 10);
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * window 이름 변경
-   */
-  async renameWindow(windowId, name) {
-    await exec2(`tmux rename-window -t "${windowId}" "${name}"`, execOptions2);
-  }
-};
-
-// dist/dash/InkDashboard.js
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useState as useState4, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef3 } from "react";
-import { render, Box, Text, useInput, useStdin } from "ink";
-import TextInput from "ink-text-input";
-
-// dist/dash/windowHelpers.js
-var gitAdapter = new GitAdapter();
-async function loadAllWindows(tmuxAdapter2, dashWindowIndex) {
-  const rawWindows = await tmuxAdapter2.listWindows();
-  const filteredWindows = rawWindows.filter((w) => w.index !== dashWindowIndex);
-  const windowsWithGitInfo = await Promise.all(filteredWindows.map(async (w) => {
-    const isGitRepo = await gitAdapter.isGitRepository(w.cwd);
-    let worktreeBranch;
-    let projectRoot;
-    if (isGitRepo) {
-      try {
-        const context = await gitAdapter.getWorktreeContext(w.cwd);
-        worktreeBranch = context.branch ?? void 0;
-        projectRoot = context.mainRoot ?? void 0;
-      } catch {
-      }
-    }
-    return {
-      windowId: w.id,
-      windowIndex: w.index,
-      name: w.name,
-      cwd: w.cwd,
-      isActive: w.active,
-      isGitRepo,
-      worktreeBranch,
-      projectRoot
-    };
-  }));
-  return windowsWithGitInfo;
-}
-async function deleteWindowById(tmuxAdapter2, windowId) {
-  await tmuxAdapter2.killWindow(windowId);
-}
-
-// dist/dash/threadHelpers.js
-import * as path12 from "path";
-
-// dist/config.js
-import * as fs9 from "fs";
-import * as os4 from "os";
-import * as path10 from "path";
-var GLOBAL_CONFIG_PATH = path10.join(os4.homedir(), ".code-squad", "config.json");
-async function loadGlobalConfig() {
-  try {
-    const content = await fs9.promises.readFile(GLOBAL_CONFIG_PATH, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return {};
-    }
-    console.warn(`[Code Squad] Warning: Could not load global config at ${GLOBAL_CONFIG_PATH}.`, error);
-    return {};
-  }
-}
-async function loadConfig(workspaceRoot) {
-  const globalConfig = await loadGlobalConfig();
-  const normalizedPath = path10.resolve(workspaceRoot);
-  const projectConfig = globalConfig.projects?.[normalizedPath] ?? {};
-  const defaults = globalConfig.defaults ?? {};
-  return {
-    ...defaults,
-    ...projectConfig,
-    worktreeCopyPatterns: [
-      .../* @__PURE__ */ new Set([
-        ...defaults.worktreeCopyPatterns ?? [],
-        ...projectConfig.worktreeCopyPatterns ?? []
-      ])
-    ]
-  };
-}
-function getWorktreeCopyPatterns(config) {
-  return config.worktreeCopyPatterns ?? [];
-}
-
-// dist/fileUtils.js
-import * as fs10 from "fs";
-import * as path11 from "path";
-import fg from "fast-glob";
-async function copyFilesWithPatterns(sourceRoot, destRoot, patterns) {
-  const copied = [];
-  const failed = [];
-  if (patterns.length === 0) {
-    return { copied, failed };
-  }
-  for (const pattern of patterns) {
-    try {
-      const files = await fg(pattern, {
-        cwd: sourceRoot,
-        absolute: true,
-        onlyFiles: true,
-        dot: true
-        // .env 같은 dotfile도 매칭
-      });
-      for (const absolutePath of files) {
-        try {
-          await copySingleFile(absolutePath, sourceRoot, destRoot);
-          const relativePath = path11.relative(sourceRoot, absolutePath);
-          copied.push(relativePath);
-        } catch {
-          const relativePath = path11.relative(sourceRoot, absolutePath);
-          failed.push(relativePath);
-        }
-      }
-    } catch {
-    }
-  }
-  return { copied, failed };
-}
-async function copySingleFile(absolutePath, sourceRoot, destRoot) {
-  const relativePath = path11.relative(sourceRoot, absolutePath);
-  const destPath = path11.join(destRoot, relativePath);
-  const destDir = path11.dirname(destPath);
-  await fs10.promises.mkdir(destDir, { recursive: true });
-  await fs10.promises.copyFile(absolutePath, destPath);
-}
-
-// dist/dash/threadHelpers.js
-var gitAdapter2 = new GitAdapter();
-async function createThread(workspaceRoot, name, rootOverride) {
-  const baseRoot = rootOverride || workspaceRoot;
-  const repoName = path12.basename(baseRoot);
-  const defaultBasePath = path12.join(path12.dirname(baseRoot), `${repoName}.worktree`);
-  const worktreePath = path12.join(defaultBasePath, name);
-  await gitAdapter2.createWorktree(worktreePath, name, baseRoot);
-  const configData = await loadConfig(baseRoot);
-  const patterns = getWorktreeCopyPatterns(configData);
-  if (patterns.length > 0) {
-    await copyFilesWithPatterns(baseRoot, worktreePath, patterns);
-  }
-  return {
-    id: worktreePath,
-    name,
-    path: worktreePath,
-    branch: name
-  };
-}
-async function deleteThread(workspaceRoot, thread) {
-  await gitAdapter2.removeWorktree(thread.path, workspaceRoot, true);
-  if (thread.branch) {
-    await gitAdapter2.deleteBranch(thread.branch, workspaceRoot, true);
-  }
-}
-
-// dist/dash/pathUtils.js
-import * as os5 from "os";
-import * as path13 from "path";
-import * as fs11 from "fs";
-var gitAdapter3 = new GitAdapter();
-function expandTilde(p) {
-  if (p === "~")
-    return os5.homedir();
-  if (p.startsWith("~/"))
-    return path13.join(os5.homedir(), p.slice(2));
-  return p;
-}
-function splitPathForCompletion(p) {
-  const expanded = expandTilde(p);
-  if (expanded.endsWith("/")) {
-    return { parentDir: expanded, leafPrefix: "" };
-  }
-  return {
-    parentDir: path13.dirname(expanded),
-    leafPrefix: path13.basename(expanded)
-  };
-}
-async function validatePath(p) {
-  const expanded = expandTilde(p);
-  if (!expanded || !path13.isAbsolute(expanded)) {
-    return { status: "invalid", isGitRepo: false };
-  }
-  try {
-    const stat = await fs11.promises.stat(expanded);
-    if (stat.isDirectory()) {
-      const isGitRepo = await gitAdapter3.isGitRepository(expanded);
-      return { status: "valid", isGitRepo };
-    }
-    return { status: "invalid", isGitRepo: false };
-  } catch {
-    const parent = path13.dirname(expanded);
-    try {
-      const parentStat = await fs11.promises.stat(parent);
-      if (parentStat.isDirectory()) {
-        return { status: "creatable", isGitRepo: false };
-      }
-    } catch {
-    }
-    return { status: "invalid", isGitRepo: false };
-  }
-}
-
-// dist/dash/useDirectorySuggestions.js
-import { useState as useState2, useRef, useCallback, useMemo } from "react";
-import * as fs12 from "fs";
-import * as os6 from "os";
-var MAX_VISIBLE = 5;
-function useDirectorySuggestions() {
-  const [suggestions, setSuggestions] = useState2([]);
-  const [selectedIndex, setSelectedIndex] = useState2(0);
-  const [isOpen, setIsOpen] = useState2(false);
-  const requestIdRef = useRef(0);
-  const clearSuggestions = useCallback(() => {
-    setSuggestions([]);
-    setSelectedIndex(0);
-    setIsOpen(false);
-  }, []);
-  const triggerComplete = useCallback(async (inputPath) => {
-    const reqId = ++requestIdRef.current;
-    const { parentDir, leafPrefix } = splitPathForCompletion(inputPath);
-    let entries;
-    try {
-      const dirEntries = await fs12.promises.readdir(parentDir, { withFileTypes: true });
-      entries = dirEntries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).filter((e) => e.name.toLowerCase().startsWith(leafPrefix.toLowerCase())).map((e) => e.name).sort();
-    } catch {
-      return null;
-    }
-    if (reqId !== requestIdRef.current)
-      return null;
-    if (entries.length === 0) {
-      clearSuggestions();
-      return null;
-    }
-    if (entries.length === 1) {
-      clearSuggestions();
-      const completed = parentDir.endsWith("/") ? parentDir + entries[0] + "/" : parentDir + "/" + entries[0] + "/";
-      return collapseHome(completed);
-    }
-    const commonPrefix = findCommonPrefix(entries);
-    setSuggestions(entries);
-    setSelectedIndex(0);
-    setIsOpen(true);
-    if (commonPrefix.length > leafPrefix.length) {
-      const completed = parentDir.endsWith("/") ? parentDir + commonPrefix : parentDir + "/" + commonPrefix;
-      return collapseHome(completed);
-    }
-    return null;
-  }, [clearSuggestions]);
-  const selectNext = useCallback(() => {
-    setSelectedIndex((prev) => (prev + 1) % Math.max(suggestions.length, 1));
-  }, [suggestions.length]);
-  const selectPrev = useCallback(() => {
-    setSelectedIndex((prev) => (prev - 1 + Math.max(suggestions.length, 1)) % Math.max(suggestions.length, 1));
-  }, [suggestions.length]);
-  const acceptSelected = useCallback((inputPath) => {
-    if (!isOpen || suggestions.length === 0)
-      return null;
-    const selected = suggestions[selectedIndex];
-    if (!selected)
-      return null;
-    const { parentDir } = splitPathForCompletion(inputPath);
-    const completed = parentDir.endsWith("/") ? parentDir + selected + "/" : parentDir + "/" + selected + "/";
-    clearSuggestions();
-    return collapseHome(completed);
-  }, [isOpen, suggestions, selectedIndex, clearSuggestions]);
-  const visibleSuggestions = useMemo(() => {
-    if (suggestions.length === 0)
-      return [];
-    let start;
-    if (suggestions.length <= MAX_VISIBLE) {
-      start = 0;
-    } else {
-      start = Math.min(Math.max(0, selectedIndex - Math.floor(MAX_VISIBLE / 2)), suggestions.length - MAX_VISIBLE);
-    }
-    const end = Math.min(start + MAX_VISIBLE, suggestions.length);
-    return suggestions.slice(start, end).map((name) => ({
-      name,
-      isSelected: name === suggestions[selectedIndex]
-    }));
-  }, [suggestions, selectedIndex]);
-  const hasMore = suggestions.length > MAX_VISIBLE;
-  return {
-    visibleSuggestions,
-    hasMore,
-    isOpen,
-    triggerComplete,
-    selectNext,
-    selectPrev,
-    acceptSelected,
-    clearSuggestions
-  };
-}
-function findCommonPrefix(strs) {
-  if (strs.length === 0)
-    return "";
-  let prefix = strs[0];
-  for (let i = 1; i < strs.length; i++) {
-    while (!strs[i].toLowerCase().startsWith(prefix.toLowerCase())) {
-      prefix = prefix.slice(0, -1);
-      if (prefix === "")
-        return "";
-    }
-  }
-  return prefix;
-}
-function collapseHome(p) {
-  const home = os6.homedir();
-  if (p === home)
-    return "~";
-  if (p.startsWith(home + "/"))
-    return "~" + p.slice(home.length);
-  return p;
-}
-
-// dist/dash/usePathValidation.js
-import { useState as useState3, useEffect, useRef as useRef2 } from "react";
-function usePathValidation(inputPath) {
-  const [validation, setValidation] = useState3(null);
-  const [isGitRepo, setIsGitRepo] = useState3(false);
-  const timerRef = useRef2(null);
-  const requestIdRef = useRef2(0);
-  useEffect(() => {
-    if (timerRef.current)
-      clearTimeout(timerRef.current);
-    const expanded = expandTilde(inputPath);
-    if (!expanded || expanded.length < 2) {
-      setValidation(null);
-      setIsGitRepo(false);
-      return;
-    }
-    timerRef.current = setTimeout(async () => {
-      const reqId = ++requestIdRef.current;
-      const result = await validatePath(inputPath);
-      if (reqId !== requestIdRef.current)
-        return;
-      setValidation(result);
-      setIsGitRepo(result.isGitRepo);
-    }, 300);
-    return () => {
-      if (timerRef.current)
-        clearTimeout(timerRef.current);
-    };
-  }, [inputPath]);
-  return { validation, isGitRepo };
-}
-
-// dist/dash/InkDashboard.js
-function parseMouseEvent(data) {
-  const match = data.match(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/);
-  if (!match)
-    return null;
-  return {
-    button: parseInt(match[1], 10),
-    col: parseInt(match[2], 10),
-    row: parseInt(match[3], 10),
-    release: match[4] === "m"
-  };
-}
-function useMouse(onMouseClick, enabled = true) {
-  const { stdin } = useStdin();
-  useEffect2(() => {
-    if (!enabled) {
-      process.stdout.write("\x1B[?1006l");
-      process.stdout.write("\x1B[?1000l");
-      return;
-    }
-    process.stdout.write("\x1B[?1000h");
-    process.stdout.write("\x1B[?1006h");
-    const handleData = (data) => {
-      const str = data.toString();
-      if (str.includes("\x1B[<")) {
-        const mouseEvent = parseMouseEvent(str);
-        if (mouseEvent && mouseEvent.button === 0 && !mouseEvent.release) {
-          onMouseClick(mouseEvent.row, mouseEvent.col);
-        }
-      }
-    };
-    stdin?.on("data", handleData);
-    return () => {
-      process.stdout.write("\x1B[?1006l");
-      process.stdout.write("\x1B[?1000l");
-      stdin?.off("data", handleData);
-    };
-  }, [stdin, onMouseClick, enabled]);
-}
-function WindowCard({ window, isSelected }) {
-  const borderColor = isSelected ? "cyan" : "gray";
-  const nameColor = isSelected ? "cyan" : "white";
-  const statusIcon = window.isActive ? "\u25CF" : "\u25CB";
-  const statusColor = window.isActive ? "green" : "gray";
-  const projectName = window.projectRoot ? window.projectRoot.split("/").slice(-1)[0] : window.cwd.split("/").slice(-1)[0];
-  const threadName = window.worktreeBranch ?? window.name;
-  return _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor, paddingX: 1, marginBottom: 0, children: [_jsxs(Box, { children: [_jsxs(Text, { color: statusColor, children: [statusIcon, " "] }), _jsx(Text, { color: nameColor, bold: isSelected, children: window.name }), isSelected && _jsx(Text, { color: "red", children: " \u2715" })] }), _jsxs(Box, { children: [_jsx(Text, { color: "gray", children: projectName }), _jsx(Text, { color: "gray", children: " \u2192 " }), _jsx(Text, { color: "cyan", children: threadName })] })] });
-}
-function NewWindowForm({ windowName, onWindowNameChange, rootPath, onRootPathChange, validation, onSubmit, onCancel }) {
-  const [focusedField, setFocusedField] = useState4("name");
-  const dirSuggestions = useDirectorySuggestions();
-  useInput(async (input, key) => {
-    if (key.escape) {
-      if (dirSuggestions.isOpen) {
-        dirSuggestions.clearSuggestions();
-      } else {
-        onCancel();
-      }
-      return;
-    }
-    if (key.return) {
-      if (dirSuggestions.isOpen) {
-        const accepted = dirSuggestions.acceptSelected(rootPath);
-        if (accepted)
-          onRootPathChange(accepted);
-      } else {
-        onSubmit();
-      }
-      return;
-    }
-    if (key.tab) {
-      if (dirSuggestions.isOpen) {
-        dirSuggestions.clearSuggestions();
-      }
-      setFocusedField((prev) => prev === "name" ? "root" : "name");
-      return;
-    }
-    if (key.upArrow) {
-      if (dirSuggestions.isOpen) {
-        dirSuggestions.selectPrev();
-      } else {
-        setFocusedField("name");
-      }
-      return;
-    }
-    if (key.downArrow) {
-      if (dirSuggestions.isOpen) {
-        dirSuggestions.selectNext();
-      } else {
-        setFocusedField("root");
-      }
-      return;
-    }
-  });
-  const handleRootPathChange = useCallback2(async (value) => {
-    onRootPathChange(value);
-    if (value.endsWith("/")) {
-      const completed = await dirSuggestions.triggerComplete(value);
-      if (completed)
-        onRootPathChange(completed);
-    } else if (value.length > 1 && value.includes("/")) {
-      await dirSuggestions.triggerComplete(value);
-    } else {
-      dirSuggestions.clearSuggestions();
-    }
-  }, [dirSuggestions, onRootPathChange]);
-  let validationIcon = "";
-  let validationColor;
-  let validationText = "";
-  if (validation) {
-    if (validation.status === "valid") {
-      if (validation.isGitRepo) {
-        validationIcon = "\u2713";
-        validationColor = "green";
-        validationText = "git repo";
-      } else {
-        validationIcon = "\u2717";
-        validationColor = "red";
-        validationText = "not a git repo";
-      }
-    } else if (validation.status === "creatable") {
-      validationIcon = "\u2717";
-      validationColor = "red";
-      validationText = "not a git repo";
-    } else {
-      validationIcon = "\u2717";
-      validationColor = "red";
-      validationText = "invalid path";
-    }
-  }
-  return _jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", bold: true, children: "+ New Window" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: focusedField === "name" ? "cyan" : void 0, children: "Name: " }), _jsx(TextInput, { value: windowName, onChange: focusedField === "name" ? onWindowNameChange : () => {
-  }, placeholder: "window-name", focus: focusedField === "name" })] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: focusedField === "root" ? "cyan" : "gray", children: "Root: " }), focusedField === "root" ? _jsx(TextInput, { value: rootPath, onChange: handleRootPathChange, placeholder: "/path/to/dir", focus: true }) : _jsx(Text, { color: "gray", children: rootPath })] }), validation && _jsxs(Box, { children: [_jsx(Text, { children: "  " }), _jsxs(Text, { color: validationColor, children: [validationIcon, " ", validationText] })] }), dirSuggestions.isOpen && dirSuggestions.visibleSuggestions.length > 0 && _jsxs(Box, { flexDirection: "column", children: [dirSuggestions.visibleSuggestions.map((s) => _jsx(Box, { children: _jsxs(Text, { color: s.isSelected ? "cyan" : "gray", children: [s.isSelected ? " > " : "   ", s.name, "/"] }) }, s.name)), dirSuggestions.hasMore && _jsx(Text, { color: "gray", children: "   \u2191\u2193 for more" })] }), dirSuggestions.isOpen ? _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "\u2191\u2193:select Enter:pick Esc:close" }) }) : _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "Tab:field Enter:ok Esc:cancel" }) })] });
-}
-function DeleteConfirm({ windowName, onConfirm, onCancel }) {
-  useInput((input, key) => {
-    if (input === "y" || input === "Y") {
-      onConfirm();
-    } else if (input === "n" || input === "N" || key.escape) {
-      onCancel();
-    }
-  });
-  return _jsxs(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, children: [_jsxs(Text, { color: "red", children: ['Delete "', windowName, '"? '] }), _jsx(Text, { color: "gray", children: "(y/n)" })] });
-}
-function HintBar({ mode }) {
-  if (mode === "new-window") {
-    return null;
-  }
-  return _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "gray", children: "\u2191\u2193/jk: nav  Enter: switch  r: refresh  q: detach" }) });
-}
-function Dashboard({ workspaceRoot, repoName, currentBranch, initialWindows, tmuxAdapter: tmuxAdapter2, dashWindowIndex, paneHeight }) {
-  const [windows, setWindows] = useState4(initialWindows);
-  const [selectedIndex, setSelectedIndex] = useState4(0);
-  const [inputMode, setInputMode] = useState4("normal");
-  const [newWindowName, setNewWindowName] = useState4("");
-  const [rootPath, setRootPath] = useState4(workspaceRoot);
-  const { validation, isGitRepo: formIsGitRepo } = usePathValidation(rootPath);
-  const handleWindowNameChange = useCallback2((value) => {
-    const sanitized = value.replace(/\s/g, "");
-    setNewWindowName(sanitized);
-  }, []);
-  const [status, setStatus] = useState4("");
-  const [isProcessing, setIsProcessing] = useState4(false);
-  const activeWindowIdRef = useRef3(null);
-  const statusTimerRef = useRef3(null);
-  const showStatus = useCallback2((msg) => {
-    if (statusTimerRef.current)
-      clearTimeout(statusTimerRef.current);
-    setStatus(msg);
-    statusTimerRef.current = setTimeout(() => setStatus(""), 2e3);
-  }, []);
-  const refreshWindows = useCallback2(async () => {
-    const updatedWindows = await loadAllWindows(tmuxAdapter2, dashWindowIndex);
-    setWindows(updatedWindows);
-    return { windows: updatedWindows };
-  }, [tmuxAdapter2, dashWindowIndex]);
-  useEffect2(() => {
-    if (initialWindows.length === 0)
-      return;
-    const first = initialWindows[0];
-    if (first) {
-      void handleSelectWindow(first);
-    }
-  }, []);
-  const HEADER_ROWS = 3;
-  const NEW_WINDOW_ROWS = 3;
-  const WINDOW_START_ROW = HEADER_ROWS + NEW_WINDOW_ROWS + 2;
-  const WINDOW_HEIGHT = 4;
-  const handleMouseClick = useCallback2((row, col) => {
-    if (isProcessing || inputMode !== "normal")
-      return;
-    if (row >= HEADER_ROWS + 1 && row <= HEADER_ROWS + NEW_WINDOW_ROWS + 1) {
-      setInputMode("new-window");
-      setNewWindowName("");
-      setRootPath(workspaceRoot);
-      return;
-    }
-    if (row >= WINDOW_START_ROW && windows.length > 0) {
-      const windowIndex = Math.floor((row - WINDOW_START_ROW) / WINDOW_HEIGHT);
-      if (windowIndex >= 0 && windowIndex < windows.length) {
-        setSelectedIndex(windowIndex);
-        void handleSelectWindow(windows[windowIndex]);
-      }
-    }
-  }, [isProcessing, inputMode, windows, workspaceRoot]);
-  useMouse(handleMouseClick, inputMode === "normal");
-  const findRightPane = async () => {
-    const panes = await tmuxAdapter2.listPanes();
-    return panes.find((p) => p.index !== 0);
-  };
-  const handleSelectWindow = async (win) => {
-    try {
-      if (win.windowId === activeWindowIdRef.current) {
-        const rightPane2 = await findRightPane();
-        if (rightPane2)
-          await tmuxAdapter2.selectPane(rightPane2.id);
-        return;
-      }
-      if (activeWindowIdRef.current) {
-        const rightPane2 = await findRightPane();
-        if (rightPane2) {
-          try {
-            await tmuxAdapter2.swapPaneWithWindow(activeWindowIdRef.current, rightPane2.id);
-          } catch {
-          }
-        }
-      }
-      const rightPane = await findRightPane();
-      if (rightPane) {
-        await tmuxAdapter2.swapPaneWithWindow(win.windowId, rightPane.id);
-        activeWindowIdRef.current = win.windowId;
-        await tmuxAdapter2.selectPane((await findRightPane()).id);
-      }
-      showStatus(`Switched: ${win.name}`);
-    } catch (error) {
-      showStatus(`Error: ${error.message}`);
-    }
-  };
-  useInput(async (input, key) => {
-    if (isProcessing) {
-      if (key.escape) {
-        setIsProcessing(false);
-        setInputMode("normal");
-        showStatus("Cancelled");
-      }
-      return;
-    }
-    if (inputMode !== "normal")
-      return;
-    if (input === "j" || key.downArrow) {
-      setSelectedIndex((prev) => (prev + 1) % Math.max(windows.length, 1));
-    } else if (input === "k" || key.upArrow) {
-      setSelectedIndex((prev) => (prev - 1 + Math.max(windows.length, 1)) % Math.max(windows.length, 1));
-    } else if (input === "q") {
-      try {
-        if (activeWindowIdRef.current) {
-          const rightPane = await findRightPane();
-          if (rightPane) {
-            try {
-              await tmuxAdapter2.swapPaneWithWindow(activeWindowIdRef.current, rightPane.id);
-            } catch {
-            }
-          }
-        }
-        const sessionName = `csq-${repoName}`;
-        await tmuxAdapter2.detachAndKillWindow(sessionName, dashWindowIndex);
-      } catch {
-      }
-    } else if (key.return) {
-      const selected = windows[selectedIndex];
-      if (selected) {
-        await handleSelectWindow(selected);
-      }
-    } else if (input === "n" || input === "+") {
-      setInputMode("new-window");
-      setNewWindowName("");
-      setRootPath(workspaceRoot);
-    } else if (input === "d") {
-      if (windows[selectedIndex]) {
-        setInputMode("confirm-delete");
-      }
-    } else if (input === "r") {
-      process.stdout.write("\x1B[2J\x1B[H");
-      process.stdout.emit("resize");
-      await refreshWindows();
-      showStatus("Refreshed");
-    }
-  });
-  const handleCreateWindow = async () => {
-    if (!newWindowName.trim()) {
-      showStatus("Window name required");
-      return;
-    }
-    if (!validation || !formIsGitRepo) {
-      showStatus("Root must be a git repo");
-      return;
-    }
-    setIsProcessing(true);
-    setStatus(`Creating ${newWindowName}...`);
-    try {
-      const expandedRoot = expandTilde(rootPath);
-      const newThread = await createThread(workspaceRoot, newWindowName.trim(), expandedRoot);
-      const newWindowId = await tmuxAdapter2.createNewWindow(newThread.path, newWindowName.trim());
-      const { windows: updatedWindows } = await refreshWindows();
-      setInputMode("normal");
-      setNewWindowName("");
-      showStatus(`Created: ${newWindowName}`);
-      const newWin = updatedWindows.find((w) => w.windowId === newWindowId);
-      if (newWin) {
-        await handleSelectWindow(newWin);
-      }
-    } catch (error) {
-      showStatus(`Error: ${error.message}`);
-    }
-    setIsProcessing(false);
-  };
-  const handleDeleteWindow = async () => {
-    const selected = windows[selectedIndex];
-    if (!selected)
-      return;
-    setIsProcessing(true);
-    setStatus(`Deleting ${selected.name}...`);
-    try {
-      if (selected.windowId === activeWindowIdRef.current) {
-        const rightPane = await findRightPane();
-        if (rightPane) {
-          try {
-            await tmuxAdapter2.swapPaneWithWindow(selected.windowId, rightPane.id);
-          } catch {
-          }
-        }
-        activeWindowIdRef.current = null;
-      }
-      await deleteWindowById(tmuxAdapter2, selected.windowId);
-      if (selected.worktreeBranch) {
-        try {
-          await deleteThread(workspaceRoot, {
-            id: selected.cwd,
-            name: selected.worktreeBranch,
-            path: selected.cwd,
-            branch: selected.worktreeBranch
-          });
-        } catch {
-        }
-      }
-      const { windows: updatedWindows } = await refreshWindows();
-      const newIndex = Math.min(selectedIndex, Math.max(0, updatedWindows.length - 1));
-      setSelectedIndex(newIndex);
-      const fallbackWin = updatedWindows[newIndex];
-      if (fallbackWin) {
-        await handleSelectWindow(fallbackWin);
-      }
-      setInputMode("normal");
-      showStatus(`Deleted: ${selected.name}`);
-    } catch (error) {
-      showStatus(`Error: ${error.message}`);
-      setInputMode("normal");
-    }
-    setIsProcessing(false);
-  };
-  return _jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, height: paneHeight, children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginBottom: 1, children: [_jsx(Text, { bold: true, color: "white", children: repoName }), _jsxs(Text, { color: "cyan", children: [" [", currentBranch, "]"] }), _jsxs(Text, { color: "gray", children: [" (", windows.length, ")"] })] }), inputMode === "new-window" ? _jsx(NewWindowForm, { windowName: newWindowName, onWindowNameChange: handleWindowNameChange, rootPath, onRootPathChange: setRootPath, validation, onSubmit: handleCreateWindow, onCancel: () => {
-    setInputMode("normal");
-    setNewWindowName("");
-  } }) : _jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginBottom: 1, children: _jsx(Text, { color: "gray", children: "+ New Window (press + or n)" }) }), inputMode === "confirm-delete" && windows[selectedIndex] && _jsx(DeleteConfirm, { windowName: windows[selectedIndex].name, onConfirm: handleDeleteWindow, onCancel: () => setInputMode("normal") }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: windows.length === 0 ? _jsx(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: _jsx(Text, { color: "gray", children: "No windows yet" }) }) : windows.map((win, i) => _jsx(WindowCard, { window: win, isSelected: i === selectedIndex }, win.windowId)) }), _jsx(HintBar, { mode: inputMode }), status && _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: "yellow", children: status }) })] });
-}
-async function runInkDashboard(config) {
-  render(_jsx(Dashboard, { ...config }));
-  await new Promise(() => {
-  });
-}
-
-// dist/dash/index.js
-var tmuxAdapter = new TmuxAdapter();
-var gitAdapter4 = new GitAdapter();
-async function installTmux() {
-  const platform = process.platform;
-  const { spawn: spawn3 } = await import("child_process");
-  let command;
-  let args;
-  if (platform === "darwin") {
-    console.log(chalk2.dim("Installing tmux via Homebrew..."));
-    command = "brew";
-    args = ["install", "tmux"];
-  } else if (platform === "linux") {
-    const { exec: exec3 } = await import("child_process");
-    const { promisify: promisify3 } = await import("util");
-    const execAsync = promisify3(exec3);
-    try {
-      await execAsync("which apt-get");
-      console.log(chalk2.dim("Installing tmux via apt..."));
-      command = "sudo";
-      args = ["apt-get", "install", "-y", "tmux"];
-    } catch {
-      try {
-        await execAsync("which yum");
-        console.log(chalk2.dim("Installing tmux via yum..."));
-        command = "sudo";
-        args = ["yum", "install", "-y", "tmux"];
-      } catch {
-        console.error(chalk2.red("Could not find apt or yum package manager"));
-        return false;
-      }
-    }
-  } else {
-    console.error(chalk2.red(`Unsupported platform: ${platform}`));
-    console.error(chalk2.dim("Please install tmux manually"));
-    return false;
-  }
-  return new Promise((resolve2) => {
-    const proc = spawn3(command, args, { stdio: "inherit" });
-    proc.on("close", (code) => {
-      if (code === 0) {
-        console.log(chalk2.green("\u2713 tmux installed successfully"));
-        resolve2(true);
-      } else {
-        console.error(chalk2.red(`Installation failed with code ${code}`));
-        resolve2(false);
-      }
-    });
-    proc.on("error", (error) => {
-      console.error(chalk2.red(`Installation error: ${error.message}`));
-      resolve2(false);
-    });
-  });
-}
-async function runDash(workspaceRoot) {
-  const repoName = path14.basename(workspaceRoot);
-  if (!await tmuxAdapter.isTmuxAvailable()) {
-    console.log(chalk2.yellow("tmux is not installed."));
-    console.log(chalk2.dim("tmux is required for the dashboard mode."));
-    console.log("");
-    const shouldInstall = await confirm2({
-      message: "Would you like to install tmux now?",
-      default: true
-    });
-    if (shouldInstall) {
-      const success = await installTmux();
-      if (!success) {
-        console.error(chalk2.red("\nFailed to install tmux."));
-        console.error(chalk2.dim("Please install manually:"));
-        console.error(chalk2.dim("  macOS: brew install tmux"));
-        console.error(chalk2.dim("  Ubuntu: sudo apt install tmux"));
-        process.exit(1);
-      }
-      console.log("");
-    } else {
-      console.log(chalk2.dim("\nTo use dashboard mode, install tmux:"));
-      console.error(chalk2.dim("  macOS: brew install tmux"));
-      console.error(chalk2.dim("  Ubuntu: sudo apt install tmux"));
-      console.log(chalk2.dim("\nOr use legacy mode: csq --legacy"));
-      process.exit(0);
-    }
-  }
-  if (!tmuxAdapter.isInsideTmux()) {
-    const sessionName = `csq-${repoName}`;
-    try {
-      const isNewSession = await tmuxAdapter.ensureSession(sessionName, workspaceRoot);
-      await tmuxAdapter.applyUXSettings();
-      const scriptPath = process.argv[1];
-      const nodeCmd = `node "${scriptPath}"`;
-      if (isNewSession) {
-        console.log(chalk2.dim("Starting new tmux session..."));
-        await tmuxAdapter.sendKeys(`${sessionName}:0`, nodeCmd);
-        await tmuxAdapter.sendEnter(`${sessionName}:0`);
-      } else {
-        console.log(chalk2.dim("Restoring dashboard..."));
-        try {
-          await tmuxAdapter.killWindow(`${sessionName}:0`);
-        } catch {
-        }
-        await tmuxAdapter.createWindowAtIndex(sessionName, 0, workspaceRoot);
-        await tmuxAdapter.selectWindow(`${sessionName}:0`);
-        await tmuxAdapter.sendKeys(`${sessionName}:0`, nodeCmd);
-        await tmuxAdapter.sendEnter(`${sessionName}:0`);
-      }
-      const { spawn: spawn3 } = await import("child_process");
-      const tmux = spawn3("tmux", ["attach-session", "-t", sessionName], {
-        stdio: "inherit"
-      });
-      await new Promise((resolve2, reject) => {
-        tmux.on("close", (code) => {
-          if (code === 0) {
-            resolve2();
-          } else {
-            reject(new Error(`tmux exited with code ${code}`));
-          }
-        });
-        tmux.on("error", reject);
-      });
-    } catch (error) {
-      console.error(chalk2.red(`Failed to start tmux session: ${error.message}`));
-      process.exit(1);
-    }
-    return;
-  }
-  console.clear();
-  console.log(chalk2.bold.cyan("Code Squad Dashboard"));
-  console.log(chalk2.dim("Setting up layout..."));
-  await tmuxAdapter.applyUXSettings();
-  try {
-    const dashPaneId = await tmuxAdapter.getCurrentPaneId();
-    if (!dashPaneId) {
-      throw new Error("Could not get current pane ID");
-    }
-    const dashWindowIndex = await tmuxAdapter.getCurrentWindowIndex();
-    if (dashWindowIndex === null) {
-      throw new Error("Could not get current window index");
-    }
-    await tmuxAdapter.setDashboardResizeHook(dashPaneId, 35);
-    const windows = await loadAllWindows(tmuxAdapter, dashWindowIndex);
-    const currentBranch = await gitAdapter4.getCurrentBranch(workspaceRoot);
-    const initialTerminalPaneId = await tmuxAdapter.splitWindow("v", workspaceRoot, 80);
-    await tmuxAdapter.selectPane(dashPaneId);
-    await new Promise((resolve2) => setTimeout(resolve2, 50));
-    process.stdout.columns = await tmuxAdapter.getPaneWidth(dashPaneId);
-    process.stdout.rows = await tmuxAdapter.getPaneHeight(dashPaneId);
-    console.clear();
-    const paneHeight = await tmuxAdapter.getPaneHeight(dashPaneId);
-    await runInkDashboard({
-      workspaceRoot,
-      repoName,
-      currentBranch,
-      initialWindows: windows,
-      tmuxAdapter,
-      dashWindowIndex,
-      paneHeight
-    });
-  } catch (error) {
-    console.error(chalk2.red(`Dashboard error: ${error.message}`));
-    process.exit(1);
-  }
-}
-
-// dist/index.js
-process.on("SIGINT", () => {
-  process.exit(130);
-});
-var gitAdapter5 = new GitAdapter();
-async function main() {
-  const args = process.argv.slice(2);
-  const persistentMode = args.includes("-p") || args.includes("--persistent");
-  const filteredArgs = args.filter((a) => a !== "-p" && a !== "--persistent");
-  const command = filteredArgs[0];
-  if (command === "--init" || command === "init") {
-    printShellInit();
-    return;
-  }
-  if (command === "flip") {
-    await runFlip(filteredArgs.slice(1));
-    return;
+  if (command === "flip") {
+    await runFlip(args.slice(1));
+    return;
   }
   const workspaceRoot = await findGitRoot(process.cwd());
   if (!workspaceRoot) {
-    console.error(chalk3.red("Error: Not a git repository"));
+    console.error(chalk.red("Error: Not a git repository"));
     process.exit(1);
   }
   switch (command) {
-    case "list":
-      await listThreads(workspaceRoot);
-      break;
     case "new":
-      await createWorktreeCommand(workspaceRoot, filteredArgs.slice(1));
+      await createWorktreeCommand(workspaceRoot, args.slice(1));
       break;
     case "quit":
       await quitWorktreeCommand();
       break;
-    case "dash":
-      await runDash(workspaceRoot);
+    case "list":
+      await listWorktrees(workspaceRoot);
       break;
-    case "--legacy":
-      if (persistentMode) {
-        await persistentInteractiveMode(workspaceRoot);
+    default:
+      if (process.stdin.isTTY) {
+        const { runTui: runTui2 } = await Promise.resolve().then(() => (init_App(), App_exports));
+        await runTui2(workspaceRoot);
       } else {
-        await interactiveMode(workspaceRoot);
+        await listWorktrees(workspaceRoot);
       }
-      break;
-    default:
-      await runDash(workspaceRoot);
   }
 }
 async function findGitRoot(cwd) {
-  if (!await gitAdapter5.isGitRepository(cwd)) {
+  if (!await gitAdapter.isGitRepository(cwd)) {
     return null;
   }
   return cwd;
 }
-function getProjectHash(workspaceRoot) {
-  return crypto.createHash("sha256").update(workspaceRoot).digest("hex").slice(0, 8);
-}
-function getSessionsPath(workspaceRoot) {
-  const projectHash = getProjectHash(workspaceRoot);
-  const projectName = path15.basename(workspaceRoot);
-  return path15.join(os7.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
-}
-async function loadLocalThreads(workspaceRoot) {
-  const sessionsPath = getSessionsPath(workspaceRoot);
-  try {
-    const content = await fs13.promises.readFile(sessionsPath, "utf-8");
-    const data = JSON.parse(content);
-    return data.localThreads || [];
-  } catch {
-    return [];
-  }
-}
-async function saveLocalThreads(workspaceRoot, threads) {
-  const sessionsPath = getSessionsPath(workspaceRoot);
-  const dir = path15.dirname(sessionsPath);
-  await fs13.promises.mkdir(dir, { recursive: true });
-  await fs13.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
-}
-async function addLocalThread(workspaceRoot, name) {
-  const threads = await loadLocalThreads(workspaceRoot);
-  const newThread = {
-    id: Date.now().toString(),
-    name,
-    path: workspaceRoot,
-    createdAt: Date.now()
-  };
-  threads.push(newThread);
-  await saveLocalThreads(workspaceRoot, threads);
-  return newThread;
-}
-async function removeLocalThread(workspaceRoot, id) {
-  const threads = await loadLocalThreads(workspaceRoot);
-  const filtered = threads.filter((t) => t.id !== id);
-  await saveLocalThreads(workspaceRoot, filtered);
-}
-async function getAllThreads(workspaceRoot) {
-  const worktrees = await gitAdapter5.listWorktrees(workspaceRoot);
-  const localThreads = await loadLocalThreads(workspaceRoot);
-  const threads = [
-    ...worktrees.map((wt) => ({
-      type: "worktree",
-      name: wt.branch,
-      path: wt.path,
-      branch: wt.branch
-    })),
-    ...localThreads.map((lt) => ({
-      type: "local",
-      name: lt.name,
-      path: lt.path,
-      id: lt.id
-    }))
-  ];
-  return threads;
-}
 function printShellInit() {
   const script = `
 csq() {
@@ -3498,7 +2030,7 @@ csq() {
   fi
 
   local output
-  output=$(command csq "$@" 2>&1)
+  output=$(command csq "$@")
   local exit_code=$?
 
   if [[ $exit_code -ne 0 ]]; then
@@ -3519,92 +2051,65 @@ csq() {
 `.trim();
   console.log(script);
 }
-async function listThreads(workspaceRoot) {
-  const threads = await getAllThreads(workspaceRoot);
-  if (threads.length === 0) {
-    console.log(chalk3.dim("No threads found."));
+async function listWorktrees(workspaceRoot) {
+  const worktrees = await gitAdapter.listWorktrees(workspaceRoot);
+  if (worktrees.length === 0) {
+    console.log(chalk.dim("No worktrees found."));
     return;
   }
-  for (const t of threads) {
-    const typeLabel = t.type === "worktree" ? chalk3.cyan("[W]") : chalk3.yellow("[L]");
-    console.log(`${typeLabel} ${t.name.padEnd(20)} ${chalk3.dim(t.path)}`);
-  }
-}
-function parseNewArgs(args) {
-  let name;
-  let split = false;
-  for (const arg of args) {
-    if (arg === "-s" || arg === "--split") {
-      split = true;
-    } else if (!arg.startsWith("-") && !name) {
-      name = arg;
-    }
+  for (const wt of worktrees) {
+    console.log(`${chalk.cyan("[W]")} ${wt.branch.padEnd(20)} ${chalk.dim(wt.path)}`);
   }
-  return { name, split };
 }
 async function createWorktreeCommand(workspaceRoot, args) {
-  const { name, split } = parseNewArgs(args);
+  const name = args.find((a) => !a.startsWith("-"));
   if (!name) {
-    console.error(chalk3.red("Error: Name is required"));
-    console.error(chalk3.dim("Usage: csq new <name> [-s|--split]"));
+    console.error(chalk.red("Error: Name is required"));
+    console.error(chalk.dim("Usage: csq new <name>"));
     process.exit(1);
   }
-  const repoName = path15.basename(workspaceRoot);
-  const defaultBasePath = path15.join(path15.dirname(workspaceRoot), `${repoName}.worktree`);
-  const worktreePath = path15.join(defaultBasePath, name);
+  const repoName = path12.basename(workspaceRoot);
+  const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
+  const worktreePath = path12.join(defaultBasePath, name);
   try {
-    await gitAdapter5.createWorktree(worktreePath, name, workspaceRoot);
-    console.log(chalk3.green(`\u2713 Created worktree: ${name}`));
+    await gitAdapter.createWorktree(worktreePath, name, workspaceRoot);
+    console.log(chalk.green(`\u2713 Created worktree: ${name}`));
     await copyWorktreeFiles(workspaceRoot, worktreePath);
-    if (split) {
-      await openNewTerminal(worktreePath);
-    } else if (process.platform === "darwin") {
-      const success = await cdInCurrentTerminal(worktreePath);
-      if (!success) {
-        console.log(chalk3.dim("\nNote: Auto-cd may require shell function setup."));
-        console.log(chalk3.dim('Run: eval "$(csq --init)"'));
-      }
-    } else {
-      console.log(worktreePath);
-    }
+    console.log(worktreePath);
   } catch (error) {
-    console.error(chalk3.red(`Failed to create worktree: ${error.message}`));
+    console.error(chalk.red(`Failed to create worktree: ${error.message}`));
     process.exit(1);
   }
 }
 async function quitWorktreeCommand() {
   const cwd = process.cwd();
-  const context = await gitAdapter5.getWorktreeContext(cwd);
+  const context = await gitAdapter.getWorktreeContext(cwd);
   if (!context.isWorktree) {
-    console.error(chalk3.red("Error: Not in a worktree"));
+    console.error(chalk.red("Error: Not in a worktree"));
     process.exit(1);
   }
   if (!context.mainRoot || !context.branch) {
-    console.error(chalk3.red("Error: Could not determine worktree context"));
+    console.error(chalk.red("Error: Could not determine worktree context"));
     process.exit(1);
   }
-  const isDirty = await gitAdapter5.hasDirtyState(cwd);
+  const isDirty = await gitAdapter.hasDirtyState(cwd);
   if (isDirty) {
-    const confirmed = await confirm3({
+    const confirmed = await confirm({
       message: "Uncommitted changes detected. Delete anyway?",
       default: false
     });
     if (!confirmed) {
-      console.log(chalk3.dim("Cancelled."));
+      console.log(chalk.dim("Cancelled."));
       process.exit(0);
     }
   }
   try {
-    await gitAdapter5.removeWorktree(context.currentPath, context.mainRoot, true);
-    await gitAdapter5.deleteBranch(context.branch, context.mainRoot, true);
-    console.log(chalk3.green(`\u2713 Deleted worktree and branch: ${context.branch}`));
-    if (process.platform === "darwin") {
-      await cdInCurrentTerminal(context.mainRoot);
-    } else {
-      console.log(context.mainRoot);
-    }
+    await gitAdapter.removeWorktree(context.currentPath, context.mainRoot, true);
+    await gitAdapter.deleteBranch(context.branch, context.mainRoot, true);
+    console.log(chalk.green(`\u2713 Deleted worktree and branch: ${context.branch}`));
+    console.log(context.mainRoot);
   } catch (error) {
-    console.error(chalk3.red(`Failed to quit: ${error.message}`));
+    console.error(chalk.red(`Failed to quit: ${error.message}`));
     process.exit(1);
   }
 }
@@ -3616,224 +2121,16 @@ async function copyWorktreeFiles(sourceRoot, destRoot) {
   }
   const { copied, failed } = await copyFilesWithPatterns(sourceRoot, destRoot, patterns);
   if (copied.length > 0) {
-    console.log(chalk3.green(`\u2713 Copied ${copied.length} file(s) to worktree`));
+    console.log(chalk.green(`\u2713 Copied ${copied.length} file(s) to worktree`));
   }
   if (failed.length > 0) {
-    console.log(chalk3.yellow(`\u26A0 Failed to copy ${failed.length} file(s)`));
-  }
-}
-async function cdInCurrentTerminal(targetPath) {
-  const { exec: exec3 } = await import("child_process");
-  const escapedPath = targetPath.replace(/'/g, "'\\''");
-  const termProgram = process.env.TERM_PROGRAM;
-  if (termProgram === "vscode" || termProgram?.includes("cursor")) {
-    console.log(targetPath);
-    return true;
-  }
-  if (termProgram === "iTerm.app") {
-    const script = `
-tell application "iTerm"
-    tell current session of current window
-        write text "cd '${escapedPath}'"
-    end tell
-end tell`;
-    return new Promise((resolve2) => {
-      exec3(`osascript -e '${script}'`, (error, stdout, stderr) => {
-        if (error) {
-          console.log(targetPath);
-          resolve2(true);
-          return;
-        }
-        resolve2(true);
-      });
-    });
-  }
-  if (termProgram === "Apple_Terminal") {
-    const terminalScript = `
-tell application "Terminal"
-    do script "cd '${escapedPath}'" in front window
-end tell`;
-    return new Promise((resolve2) => {
-      exec3(`osascript -e '${terminalScript}'`, (error, stdout, stderr) => {
-        if (error) {
-          console.log(targetPath);
-          resolve2(true);
-          return;
-        }
-        resolve2(true);
-      });
-    });
-  }
-  const hasIterm = await new Promise((resolve2) => {
-    exec3('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
-      resolve2(!error && stdout.trim().length > 0);
-    });
-  });
-  if (hasIterm) {
-    const script = `
-tell application "iTerm2"
-    tell current session of current window
-        write text "cd '${escapedPath}'"
-    end tell
-end tell`;
-    return new Promise((resolve2) => {
-      exec3(`osascript -e '${script}'`, (error) => {
-        if (error) {
-          console.log(targetPath);
-        }
-        resolve2(true);
-      });
-    });
-  }
-  console.log(targetPath);
-  return true;
-}
-async function openNewTerminal(targetPath) {
-  const { exec: exec3 } = await import("child_process");
-  const escapedPath = targetPath.replace(/'/g, "'\\''");
-  const hasIterm = await new Promise((resolve2) => {
-    exec3('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
-      resolve2(!error && stdout.trim().length > 0);
-    });
-  });
-  if (hasIterm) {
-    const script = `
-tell application "iTerm2"
-    tell current session of current window
-        set newSession to (split vertically with default profile)
-        tell newSession
-            write text "cd '${escapedPath}'"
-        end tell
-    end tell
-end tell`;
-    return new Promise((resolve2) => {
-      exec3(`osascript -e '${script}'`, (error) => {
-        resolve2(!error);
-      });
-    });
-  }
-  const terminalScript = `
-tell application "Terminal"
-    activate
-    do script "cd '${escapedPath}'"
-end tell`;
-  return new Promise((resolve2) => {
-    exec3(`osascript -e '${terminalScript}'`, (error) => {
-      resolve2(!error);
-    });
-  });
-}
-async function interactiveMode(workspaceRoot) {
-  const result = await runInteraction(workspaceRoot);
-  if (result?.cdPath) {
-    await cdInCurrentTerminal(result.cdPath);
-  }
-}
-async function persistentInteractiveMode(workspaceRoot) {
-  while (true) {
-    console.clear();
-    const result = await runInteraction(workspaceRoot, true);
-    if (result?.exit) {
-      break;
-    }
-    if (result?.cdPath) {
-      await openNewTerminal(result.cdPath);
-    }
-  }
-}
-async function executeDelete(thread, workspaceRoot) {
-  if (thread.type === "local") {
-    const confirmed = await confirmDeleteLocal(thread.name);
-    if (confirmed) {
-      await removeLocalThread(workspaceRoot, thread.id);
-      console.log(chalk3.green(`\u2713 Deleted local thread: ${thread.name}`));
-    } else {
-      console.log(chalk3.dim("Cancelled."));
-    }
-  } else {
-    const { confirmed, removeGitWorktree } = await confirmDeleteWorktree(thread.name);
-    if (confirmed && removeGitWorktree) {
-      try {
-        await gitAdapter5.removeWorktree(thread.path, workspaceRoot, true);
-        await gitAdapter5.deleteBranch(thread.branch, workspaceRoot, true);
-        console.log(chalk3.green(`\u2713 Deleted worktree and branch: ${thread.name}`));
-      } catch (error) {
-        console.error(chalk3.red(`Failed to delete: ${error.message}`));
-      }
-    } else if (confirmed) {
-      console.log(chalk3.yellow("Worktree kept."));
-    } else {
-      console.log(chalk3.dim("Cancelled."));
-    }
-  }
-}
-async function runInteraction(workspaceRoot, _persistent = false) {
-  const threads = await getAllThreads(workspaceRoot);
-  const repoName = path15.basename(workspaceRoot);
-  const choice = await selectThread(threads, repoName);
-  if (choice.type === "exit") {
-    return { exit: true };
-  }
-  let targetPath;
-  switch (choice.type) {
-    case "existing": {
-      const thread = choice.thread;
-      const action = await selectThreadAction(thread.name);
-      if (action === "open") {
-        targetPath = thread.path;
-      } else if (action === "delete") {
-        await executeDelete(thread, workspaceRoot);
-        return null;
-      } else {
-        return null;
-      }
-      break;
-    }
-    case "delete-selected": {
-      const thread = choice.thread;
-      await executeDelete(thread, workspaceRoot);
-      return null;
-    }
-    case "new": {
-      const newType = await selectNewThreadType();
-      if (newType === "back") {
-        return null;
-      }
-      if (newType === "worktree") {
-        const defaultBasePath = path15.join(path15.dirname(workspaceRoot), `${repoName}.worktree`);
-        const form = await newWorktreeForm(defaultBasePath);
-        if (!form) {
-          return null;
-        }
-        try {
-          await gitAdapter5.createWorktree(form.path, form.name, workspaceRoot);
-          console.log(chalk3.green(`\u2713 Created worktree: ${form.name}`));
-          await copyWorktreeFiles(workspaceRoot, form.path);
-          targetPath = form.path;
-        } catch (error) {
-          console.error(chalk3.red(`Failed to create worktree: ${error.message}`));
-        }
-      } else {
-        const name = await newLocalForm();
-        if (!name) {
-          return null;
-        }
-        await addLocalThread(workspaceRoot, name);
-        console.log(chalk3.green(`\u2713 Created local thread: ${name}`));
-        targetPath = workspaceRoot;
-      }
-      break;
-    }
+    console.log(chalk.yellow(`\u26A0 Failed to copy ${failed.length} file(s)`));
   }
-  if (targetPath) {
-    return { cdPath: targetPath };
-  }
-  return null;
 }
 main().catch((error) => {
   if (error.message?.includes("SIGINT") || error.message?.includes("force closed")) {
     process.exit(130);
   }
-  console.error(chalk3.red(`Error: ${error.message}`));
+  console.error(chalk.red(`Error: ${error.message}`));
   process.exit(1);
 });