code-squad-cli 1.2.21 → 1.3.0

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 
 // dist/index.js
-import * as path12 from "path";
-import * as fs11 from "fs";
-import * as os5 from "os";
+import * as path15 from "path";
+import * as fs13 from "fs";
+import * as os7 from "os";
 import * as crypto from "crypto";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // dist/adapters/GitAdapter.js
 import { exec as execCallback } from "child_process";
@@ -23,8 +23,17 @@ var GitAdapter = class {
     }
   }
   async getCurrentBranch(workspaceRoot) {
-    const { stdout } = await exec(`cd "${workspaceRoot}" && git rev-parse --abbrev-ref HEAD`, execOptions);
-    return stdout.trim();
+    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 "";
+      }
+    }
   }
   async listWorktrees(workspaceRoot) {
     try {
@@ -44,11 +53,11 @@ var GitAdapter = class {
         const headMatch = headLine.match(/^HEAD (.+)$/);
         const branchMatch = branchLine?.match(/^branch refs\/heads\/(.+)$/);
         if (pathMatch && headMatch) {
-          const path13 = pathMatch[1];
+          const path16 = pathMatch[1];
           const head = headMatch[1];
           const branch = branchMatch ? branchMatch[1] : "HEAD";
-          if (path13 !== workspaceRoot) {
-            worktrees.push({ path: path13, branch, head });
+          if (path16 !== workspaceRoot) {
+            worktrees.push({ path: path16, branch, head });
           }
         }
         i += 3;
@@ -59,9 +68,11 @@ var GitAdapter = class {
     }
   }
   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 "${worktreePath}" -b "${branch}"`, execOptions);
+    await exec(`cd "${workspaceRoot}" && ${mkdirCmd}git worktree add -f "${worktreePath}" -b "${branch}"`, execOptions);
   }
   async removeWorktree(worktreePath, workspaceRoot, force = false) {
     const forceFlag = force ? " --force" : "";
@@ -79,19 +90,19 @@ var GitAdapter = class {
       throw new Error(`Failed to delete branch: ${error.message}`);
     }
   }
-  async isValidWorktree(path13, workspaceRoot) {
+  async isValidWorktree(path16, workspaceRoot) {
     try {
-      await fs.promises.access(path13, fs.constants.R_OK);
+      await fs.promises.access(path16, fs.constants.R_OK);
     } catch {
       return false;
     }
     try {
-      await exec(`cd "${path13}" && git rev-parse --git-dir`, execOptions);
+      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 === path13);
+    return worktrees.some((wt) => wt.path === path16);
   }
   async getWorktreeBranch(worktreePath) {
     try {
@@ -411,7 +422,7 @@ async function confirmDeleteLocal(threadName) {
 }
 
 // dist/index.js
-import { confirm as confirm2 } from "@inquirer/prompts";
+import { confirm as confirm3 } from "@inquirer/prompts";
 
 // dist/flip/server/Server.js
 import express2 from "express";
@@ -694,9 +705,9 @@ var filenameMap = {
   "CODEOWNERS": "gitignore"
 };
 function detectLanguage(filePath) {
-  const basename2 = path3.basename(filePath);
-  if (filenameMap[basename2]) {
-    return filenameMap[basename2];
+  const basename5 = path3.basename(filePath);
+  if (filenameMap[basename5]) {
+    return filenameMap[basename5];
   }
   const ext = path3.extname(filePath).slice(1).toLowerCase();
   if (extensionMap[ext]) {
@@ -2005,6 +2016,537 @@ 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;
+    }
+  }
+  /**
+   * 현재 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";
@@ -2084,11 +2626,761 @@ async function copySingleFile(absolutePath, sourceRoot, destRoot) {
   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 gitAdapter = new GitAdapter();
+var gitAdapter5 = new GitAdapter();
 async function main() {
   const args = process.argv.slice(2);
   const persistentMode = args.includes("-p") || args.includes("--persistent");
@@ -2104,7 +3396,7 @@ async function main() {
   }
   const workspaceRoot = await findGitRoot(process.cwd());
   if (!workspaceRoot) {
-    console.error(chalk2.red("Error: Not a git repository"));
+    console.error(chalk3.red("Error: Not a git repository"));
     process.exit(1);
   }
   switch (command) {
@@ -2117,16 +3409,22 @@ async function main() {
     case "quit":
       await quitWorktreeCommand();
       break;
-    default:
+    case "dash":
+      await runDash(workspaceRoot);
+      break;
+    case "--legacy":
       if (persistentMode) {
         await persistentInteractiveMode(workspaceRoot);
       } else {
         await interactiveMode(workspaceRoot);
       }
+      break;
+    default:
+      await runDash(workspaceRoot);
   }
 }
 async function findGitRoot(cwd) {
-  if (!await gitAdapter.isGitRepository(cwd)) {
+  if (!await gitAdapter5.isGitRepository(cwd)) {
     return null;
   }
   return cwd;
@@ -2136,13 +3434,13 @@ function getProjectHash(workspaceRoot) {
 }
 function getSessionsPath(workspaceRoot) {
   const projectHash = getProjectHash(workspaceRoot);
-  const projectName = path12.basename(workspaceRoot);
-  return path12.join(os5.homedir(), ".code-squad", "sessions", `${projectName}-${projectHash}.json`);
+  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 fs11.promises.readFile(sessionsPath, "utf-8");
+    const content = await fs13.promises.readFile(sessionsPath, "utf-8");
     const data = JSON.parse(content);
     return data.localThreads || [];
   } catch {
@@ -2151,9 +3449,9 @@ async function loadLocalThreads(workspaceRoot) {
 }
 async function saveLocalThreads(workspaceRoot, threads) {
   const sessionsPath = getSessionsPath(workspaceRoot);
-  const dir = path12.dirname(sessionsPath);
-  await fs11.promises.mkdir(dir, { recursive: true });
-  await fs11.promises.writeFile(sessionsPath, JSON.stringify({ localThreads: threads }, null, 2));
+  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);
@@ -2173,7 +3471,7 @@ async function removeLocalThread(workspaceRoot, id) {
   await saveLocalThreads(workspaceRoot, filtered);
 }
 async function getAllThreads(workspaceRoot) {
-  const worktrees = await gitAdapter.listWorktrees(workspaceRoot);
+  const worktrees = await gitAdapter5.listWorktrees(workspaceRoot);
   const localThreads = await loadLocalThreads(workspaceRoot);
   const threads = [
     ...worktrees.map((wt) => ({
@@ -2224,12 +3522,12 @@ csq() {
 async function listThreads(workspaceRoot) {
   const threads = await getAllThreads(workspaceRoot);
   if (threads.length === 0) {
-    console.log(chalk2.dim("No threads found."));
+    console.log(chalk3.dim("No threads found."));
     return;
   }
   for (const t of threads) {
-    const typeLabel = t.type === "worktree" ? chalk2.cyan("[W]") : chalk2.yellow("[L]");
-    console.log(`${typeLabel} ${t.name.padEnd(20)} ${chalk2.dim(t.path)}`);
+    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) {
@@ -2247,62 +3545,66 @@ function parseNewArgs(args) {
 async function createWorktreeCommand(workspaceRoot, args) {
   const { name, split } = parseNewArgs(args);
   if (!name) {
-    console.error(chalk2.red("Error: Name is required"));
-    console.error(chalk2.dim("Usage: csq new <name> [-s|--split]"));
+    console.error(chalk3.red("Error: Name is required"));
+    console.error(chalk3.dim("Usage: csq new <name> [-s|--split]"));
     process.exit(1);
   }
-  const repoName = path12.basename(workspaceRoot);
-  const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
-  const worktreePath = path12.join(defaultBasePath, name);
+  const repoName = path15.basename(workspaceRoot);
+  const defaultBasePath = path15.join(path15.dirname(workspaceRoot), `${repoName}.worktree`);
+  const worktreePath = path15.join(defaultBasePath, name);
   try {
-    await gitAdapter.createWorktree(worktreePath, name, workspaceRoot);
-    console.log(chalk2.green(`\u2713 Created worktree: ${name}`));
+    await gitAdapter5.createWorktree(worktreePath, name, workspaceRoot);
+    console.log(chalk3.green(`\u2713 Created worktree: ${name}`));
     await copyWorktreeFiles(workspaceRoot, worktreePath);
     if (split) {
       await openNewTerminal(worktreePath);
     } else if (process.platform === "darwin") {
-      await cdInCurrentTerminal(worktreePath);
+      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);
     }
   } catch (error) {
-    console.error(chalk2.red(`Failed to create worktree: ${error.message}`));
+    console.error(chalk3.red(`Failed to create worktree: ${error.message}`));
     process.exit(1);
   }
 }
 async function quitWorktreeCommand() {
   const cwd = process.cwd();
-  const context = await gitAdapter.getWorktreeContext(cwd);
+  const context = await gitAdapter5.getWorktreeContext(cwd);
   if (!context.isWorktree) {
-    console.error(chalk2.red("Error: Not in a worktree"));
+    console.error(chalk3.red("Error: Not in a worktree"));
     process.exit(1);
   }
   if (!context.mainRoot || !context.branch) {
-    console.error(chalk2.red("Error: Could not determine worktree context"));
+    console.error(chalk3.red("Error: Could not determine worktree context"));
     process.exit(1);
   }
-  const isDirty = await gitAdapter.hasDirtyState(cwd);
+  const isDirty = await gitAdapter5.hasDirtyState(cwd);
   if (isDirty) {
-    const confirmed = await confirm2({
+    const confirmed = await confirm3({
       message: "Uncommitted changes detected. Delete anyway?",
       default: false
     });
     if (!confirmed) {
-      console.log(chalk2.dim("Cancelled."));
+      console.log(chalk3.dim("Cancelled."));
       process.exit(0);
     }
   }
   try {
-    await gitAdapter.removeWorktree(context.currentPath, context.mainRoot, true);
-    await gitAdapter.deleteBranch(context.branch, context.mainRoot, true);
-    console.log(chalk2.green(`\u2713 Deleted worktree and branch: ${context.branch}`));
+    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);
     }
   } catch (error) {
-    console.error(chalk2.red(`Failed to quit: ${error.message}`));
+    console.error(chalk3.red(`Failed to quit: ${error.message}`));
     process.exit(1);
   }
 }
@@ -2314,17 +3616,56 @@ async function copyWorktreeFiles(sourceRoot, destRoot) {
   }
   const { copied, failed } = await copyFilesWithPatterns(sourceRoot, destRoot, patterns);
   if (copied.length > 0) {
-    console.log(chalk2.green(`\u2713 Copied ${copied.length} file(s) to worktree`));
+    console.log(chalk3.green(`\u2713 Copied ${copied.length} file(s) to worktree`));
   }
   if (failed.length > 0) {
-    console.log(chalk2.yellow(`\u26A0 Failed to copy ${failed.length} file(s)`));
+    console.log(chalk3.yellow(`\u26A0 Failed to copy ${failed.length} file(s)`));
   }
 }
 async function cdInCurrentTerminal(targetPath) {
-  const { exec: exec2 } = await import("child_process");
+  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) => {
-    exec2('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
+    exec3('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
       resolve2(!error && stdout.trim().length > 0);
     });
   });
@@ -2336,26 +3677,22 @@ tell application "iTerm2"
     end tell
 end tell`;
     return new Promise((resolve2) => {
-      exec2(`osascript -e '${script}'`, (error) => {
-        resolve2(!error);
+      exec3(`osascript -e '${script}'`, (error) => {
+        if (error) {
+          console.log(targetPath);
+        }
+        resolve2(true);
       });
     });
   }
-  const terminalScript = `
-tell application "Terminal"
-    do script "cd '${escapedPath}'" in front window
-end tell`;
-  return new Promise((resolve2) => {
-    exec2(`osascript -e '${terminalScript}'`, (error) => {
-      resolve2(!error);
-    });
-  });
+  console.log(targetPath);
+  return true;
 }
 async function openNewTerminal(targetPath) {
-  const { exec: exec2 } = await import("child_process");
+  const { exec: exec3 } = await import("child_process");
   const escapedPath = targetPath.replace(/'/g, "'\\''");
   const hasIterm = await new Promise((resolve2) => {
-    exec2('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
+    exec3('mdfind "kMDItemCFBundleIdentifier == com.googlecode.iterm2"', (error, stdout) => {
       resolve2(!error && stdout.trim().length > 0);
     });
   });
@@ -2370,7 +3707,7 @@ tell application "iTerm2"
     end tell
 end tell`;
     return new Promise((resolve2) => {
-      exec2(`osascript -e '${script}'`, (error) => {
+      exec3(`osascript -e '${script}'`, (error) => {
         resolve2(!error);
       });
     });
@@ -2381,7 +3718,7 @@ tell application "Terminal"
     do script "cd '${escapedPath}'"
 end tell`;
   return new Promise((resolve2) => {
-    exec2(`osascript -e '${terminalScript}'`, (error) => {
+    exec3(`osascript -e '${terminalScript}'`, (error) => {
       resolve2(!error);
     });
   });
@@ -2409,30 +3746,30 @@ async function executeDelete(thread, workspaceRoot) {
     const confirmed = await confirmDeleteLocal(thread.name);
     if (confirmed) {
       await removeLocalThread(workspaceRoot, thread.id);
-      console.log(chalk2.green(`\u2713 Deleted local thread: ${thread.name}`));
+      console.log(chalk3.green(`\u2713 Deleted local thread: ${thread.name}`));
     } else {
-      console.log(chalk2.dim("Cancelled."));
+      console.log(chalk3.dim("Cancelled."));
     }
   } else {
     const { confirmed, removeGitWorktree } = await confirmDeleteWorktree(thread.name);
     if (confirmed && removeGitWorktree) {
       try {
-        await gitAdapter.removeWorktree(thread.path, workspaceRoot, true);
-        await gitAdapter.deleteBranch(thread.branch, workspaceRoot, true);
-        console.log(chalk2.green(`\u2713 Deleted worktree and branch: ${thread.name}`));
+        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(chalk2.red(`Failed to delete: ${error.message}`));
+        console.error(chalk3.red(`Failed to delete: ${error.message}`));
       }
     } else if (confirmed) {
-      console.log(chalk2.yellow("Worktree kept."));
+      console.log(chalk3.yellow("Worktree kept."));
     } else {
-      console.log(chalk2.dim("Cancelled."));
+      console.log(chalk3.dim("Cancelled."));
     }
   }
 }
 async function runInteraction(workspaceRoot, _persistent = false) {
   const threads = await getAllThreads(workspaceRoot);
-  const repoName = path12.basename(workspaceRoot);
+  const repoName = path15.basename(workspaceRoot);
   const choice = await selectThread(threads, repoName);
   if (choice.type === "exit") {
     return { exit: true };
@@ -2463,18 +3800,18 @@ async function runInteraction(workspaceRoot, _persistent = false) {
         return null;
       }
       if (newType === "worktree") {
-        const defaultBasePath = path12.join(path12.dirname(workspaceRoot), `${repoName}.worktree`);
+        const defaultBasePath = path15.join(path15.dirname(workspaceRoot), `${repoName}.worktree`);
         const form = await newWorktreeForm(defaultBasePath);
         if (!form) {
           return null;
         }
         try {
-          await gitAdapter.createWorktree(form.path, form.name, workspaceRoot);
-          console.log(chalk2.green(`\u2713 Created worktree: ${form.name}`));
+          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(chalk2.red(`Failed to create worktree: ${error.message}`));
+          console.error(chalk3.red(`Failed to create worktree: ${error.message}`));
         }
       } else {
         const name = await newLocalForm();
@@ -2482,7 +3819,7 @@ async function runInteraction(workspaceRoot, _persistent = false) {
           return null;
         }
         await addLocalThread(workspaceRoot, name);
-        console.log(chalk2.green(`\u2713 Created local thread: ${name}`));
+        console.log(chalk3.green(`\u2713 Created local thread: ${name}`));
         targetPath = workspaceRoot;
       }
       break;
@@ -2497,6 +3834,6 @@ main().catch((error) => {
   if (error.message?.includes("SIGINT") || error.message?.includes("force closed")) {
     process.exit(130);
   }
-  console.error(chalk2.red(`Error: ${error.message}`));
+  console.error(chalk3.red(`Error: ${error.message}`));
   process.exit(1);
 });