dmux 1.2.0 → 1.3.1

package/dist/DmuxApp.js

@@ -23,16 +23,23 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
     const [projectSettings, setProjectSettings] = useState({});
     const [showCommandPrompt, setShowCommandPrompt] = useState(null);
     const [commandInput, setCommandInput] = useState('');
-    const [showAIPrompt, setShowAIPrompt] = useState(false);
-    const [aiChangeRequest, setAIChangeRequest] = useState('');
-    const [generatingCommand, setGeneratingCommand] = useState(false);
+    const [showFileCopyPrompt, setShowFileCopyPrompt] = useState(false);
+    const [currentCommandType, setCurrentCommandType] = useState(null);
     const [runningCommand, setRunningCommand] = useState(false);
     const { exit } = useApp();
+    // Track terminal dimensions for responsive layout
+    const [terminalWidth, setTerminalWidth] = useState(process.stdout.columns || 80);
     // Load panes and settings on mount and refresh periodically
     useEffect(() => {
         loadPanes();
         loadSettings();
         const interval = setInterval(loadPanes, 2000);
+        // Handle terminal resize
+        const handleResize = () => {
+            setTerminalWidth(process.stdout.columns || 80);
+        };
+        // Add resize listener
+        process.stdout.on('resize', handleResize);
         // Add cleanup handlers for process termination
         const handleTermination = () => {
             // Clear screen before exit
@@ -48,10 +55,129 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         process.on('SIGTERM', handleTermination);
         return () => {
             clearInterval(interval);
+            process.stdout.removeListener('resize', handleResize);
             process.removeListener('SIGINT', handleTermination);
             process.removeListener('SIGTERM', handleTermination);
         };
     }, []);
+    // Monitor Claude status in all panes with proper dependency tracking
+    useEffect(() => {
+        if (panes.length === 0)
+            return;
+        const monitorClaudeStatus = async () => {
+            // Monitor Claude Code status for all panes
+            const updatedPanes = await Promise.all(panes.map(async (pane) => {
+                try {
+                    // Skip if recently checked (within 500ms to avoid overlapping checks)
+                    if (pane.lastClaudeCheck && Date.now() - pane.lastClaudeCheck < 500) {
+                        return pane;
+                    }
+                    // Capture the last 30 lines of the pane for better detection
+                    const captureOutput = execSync(`tmux capture-pane -t '${pane.paneId}' -p -S -30`, { encoding: 'utf-8', stdio: 'pipe' });
+                    // Pattern detection for Claude Code states
+                    // Working patterns - Claude is processing
+                    // The ONLY reliable indicator is "(esc to interrupt)"
+                    const workingPatterns = [
+                        /esc to interrupt/i, // The ONLY reliable indicator that Claude is actively working
+                    ];
+                    // Extract last few lines to check for patterns
+                    const lines = captureOutput.split('\n');
+                    const lastLines = lines.slice(-10).join('\n');
+                    // Check if Claude's input box is present (waiting for input)
+                    const hasInputBox = /╭─+╮/.test(lastLines) && /╰─+╯/.test(lastLines) && /│\s+>\s+.*│/.test(lastLines);
+                    // Permission/attention patterns - needs user input (very forgiving)
+                    const attentionPatterns = [
+                        /\?\s*$/m, // Any line ending with a question mark
+                        /y\/n/i, // Any y/n prompt
+                        /yes.*no/i, // Yes or no prompts
+                        /\ballow\b.*\?/i,
+                        /\bapprove\b.*\?/i,
+                        /\bgrant\b.*\?/i,
+                        /\btrust\b.*\?/i,
+                        /\baccept\b.*\?/i,
+                        /\bcontinue\b.*\?/i,
+                        /\bproceed\b.*\?/i,
+                        /permission/i,
+                        /confirmation/i,
+                        /press.*enter/i,
+                        /waiting for/i,
+                        /are you sure/i,
+                        /would you like/i,
+                        /do you want/i,
+                        /please confirm/i,
+                        /requires.*approval/i,
+                        /needs.*input/i,
+                        /⏵⏵\s*accept edits/i, // Claude's accept edits mode
+                        /shift\+tab to cycle/i, // Claude's interface hints
+                    ];
+                    // Check if Claude is working
+                    const isWorking = workingPatterns.some(pattern => pattern.test(captureOutput));
+                    // Check if Claude needs attention
+                    const needsAttention = attentionPatterns.some(pattern => pattern.test(captureOutput)) || hasInputBox;
+                    // Determine status - working takes precedence
+                    let newStatus = 'idle';
+                    if (isWorking) {
+                        newStatus = 'working';
+                    }
+                    else if (needsAttention && !isWorking) {
+                        // Only show as waiting if NOT working (working takes precedence)
+                        newStatus = 'waiting';
+                    }
+                    // Additional checks for specific Claude states
+                    // If we see "accept edits" without other working indicators, it's waiting
+                    if (/accept edits/i.test(captureOutput) && !/esc to interrupt/i.test(captureOutput)) {
+                        newStatus = 'waiting';
+                    }
+                    // If Claude's input box is visible and no working indicators, it's waiting for input
+                    if (hasInputBox && !isWorking) {
+                        newStatus = 'waiting';
+                    }
+                    // Check for specific Claude question patterns that might not end with ?
+                    const claudeQuestionPatterns = [
+                        /I (can|could|should|would|will|may|might)/i,
+                        /Let me know/i,
+                        /Please (tell|let|inform|advise)/i,
+                        /Would you prefer/i,
+                        /Should I (proceed|continue|go ahead)/i,
+                    ];
+                    if (claudeQuestionPatterns.some(pattern => pattern.test(lastLines)) && !isWorking) {
+                        newStatus = 'waiting';
+                    }
+                    // Return updated pane if status changed
+                    if (pane.claudeStatus !== newStatus) {
+                        return {
+                            ...pane,
+                            claudeStatus: newStatus,
+                            lastClaudeCheck: Date.now()
+                        };
+                    }
+                    // Just update timestamp
+                    return {
+                        ...pane,
+                        lastClaudeCheck: Date.now()
+                    };
+                }
+                catch (error) {
+                    // If we can't capture the pane, it might be dead
+                    return pane;
+                }
+            }));
+            // Only update state if something changed
+            const hasChanges = updatedPanes.some((pane, index) => pane.claudeStatus !== panes[index]?.claudeStatus);
+            if (hasChanges) {
+                setPanes(updatedPanes);
+                // Save to file
+                await fs.writeFile(panesFile, JSON.stringify(updatedPanes, null, 2));
+            }
+        };
+        // Run monitoring immediately
+        monitorClaudeStatus();
+        // Set up interval for continuous monitoring
+        const claudeInterval = setInterval(monitorClaudeStatus, 1000); // Check every second
+        return () => {
+            clearInterval(claudeInterval);
+        };
+    }, [panes, panesFile]); // Re-run when panes change
     const loadSettings = async () => {
         try {
             const content = await fs.readFile(settingsFile, 'utf-8');
@@ -81,10 +207,9 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
                     }).trim().split('\n');
                     // Check if our pane ID exists in the list
                     if (paneIds.includes(pane.paneId)) {
-                        // Update pane title while we're at it
-                        const paneTitle = pane.prompt ? pane.prompt.substring(0, 30) : pane.slug;
+                        // Update pane title to match the slug
                         try {
-                            execSync(`tmux select-pane -t '${pane.paneId}' -T "${paneTitle}"`, { stdio: 'pipe' });
+                            execSync(`tmux select-pane -t '${pane.paneId}' -T "${pane.slug}"`, { stdio: 'pipe' });
                         }
                         catch {
                             // Ignore if setting title fails
@@ -107,6 +232,163 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
             setPanes([]);
         }
     };
+    const getPanePositions = () => {
+        try {
+            const output = execSync(`tmux list-panes -F '#{pane_id} #{pane_left} #{pane_top} #{pane_width} #{pane_height}'`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            return output.split('\n').map(line => {
+                const [paneId, left, top, width, height] = line.split(' ');
+                return {
+                    paneId,
+                    left: parseInt(left),
+                    top: parseInt(top),
+                    width: parseInt(width),
+                    height: parseInt(height)
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    };
+    // Calculate the visual grid position of cards based on their index
+    const getCardGridPosition = (index) => {
+        // Cards are displayed in a flexbox with wrapping
+        // With card width of 35 and typical terminal width of 80-120, we get 2-3 cards per row
+        const cardWidth = 35 + 2; // Card width plus gap
+        const cardsPerRow = Math.max(1, Math.floor(terminalWidth / cardWidth));
+        const row = Math.floor(index / cardsPerRow);
+        const col = index % cardsPerRow;
+        return { row, col };
+    };
+    const findCardInDirection = (currentIndex, direction) => {
+        const totalItems = panes.length + 1; // +1 for "New dmux pane" button
+        const currentPos = getCardGridPosition(currentIndex);
+        // Calculate cards per row based on current terminal width
+        const cardWidth = 35 + 2; // Card width plus gap
+        const cardsPerRow = Math.max(1, Math.floor(terminalWidth / cardWidth));
+        let targetIndex = null;
+        switch (direction) {
+            case 'up':
+                // Move up one row, same column
+                if (currentPos.row > 0) {
+                    targetIndex = (currentPos.row - 1) * cardsPerRow + currentPos.col;
+                    // Make sure target exists
+                    if (targetIndex >= totalItems) {
+                        // Try to find the last item in the row above
+                        targetIndex = Math.min((currentPos.row - 1) * cardsPerRow + cardsPerRow - 1, totalItems - 1);
+                    }
+                }
+                break;
+            case 'down':
+                // Move down one row, same column
+                targetIndex = (currentPos.row + 1) * cardsPerRow + currentPos.col;
+                if (targetIndex >= totalItems) {
+                    // If moving down from last row, try to go to "New dmux pane" if not already there
+                    if (currentIndex < totalItems - 1) {
+                        targetIndex = totalItems - 1;
+                    }
+                    else {
+                        targetIndex = null;
+                    }
+                }
+                break;
+            case 'left':
+                // Move left one column, same row
+                if (currentPos.col > 0) {
+                    targetIndex = currentIndex - 1;
+                }
+                else if (currentPos.row > 0) {
+                    // Wrap to end of previous row
+                    targetIndex = currentPos.row * cardsPerRow - 1;
+                    if (targetIndex >= totalItems) {
+                        targetIndex = totalItems - 1;
+                    }
+                }
+                break;
+            case 'right':
+                // Move right one column, same row
+                if (currentPos.col < cardsPerRow - 1 && currentIndex < totalItems - 1) {
+                    targetIndex = currentIndex + 1;
+                }
+                else if ((currentPos.row + 1) * cardsPerRow < totalItems) {
+                    // Wrap to start of next row
+                    targetIndex = (currentPos.row + 1) * cardsPerRow;
+                }
+                break;
+        }
+        // Validate target index
+        if (targetIndex !== null && targetIndex >= 0 && targetIndex < totalItems) {
+            return targetIndex;
+        }
+        return null;
+    };
+    const findPaneInDirection = (currentPane, direction) => {
+        const positions = getPanePositions();
+        const currentPos = positions.find(p => p.paneId === currentPane.paneId);
+        if (!currentPos)
+            return null;
+        // Calculate center point of current pane
+        const currentCenterX = currentPos.left + currentPos.width / 2;
+        const currentCenterY = currentPos.top + currentPos.height / 2;
+        // Filter panes based on direction
+        const candidatePanes = panes.filter(pane => {
+            if (pane.paneId === currentPane.paneId)
+                return false;
+            const pos = positions.find(p => p.paneId === pane.paneId);
+            if (!pos)
+                return false;
+            const centerX = pos.left + pos.width / 2;
+            const centerY = pos.top + pos.height / 2;
+            switch (direction) {
+                case 'up':
+                    return centerY < currentCenterY;
+                case 'down':
+                    return centerY > currentCenterY;
+                case 'left':
+                    return centerX < currentCenterX;
+                case 'right':
+                    return centerX > currentCenterX;
+                default:
+                    return false;
+            }
+        });
+        if (candidatePanes.length === 0)
+            return null;
+        // Find the closest pane in the given direction
+        let closestPane = candidatePanes[0];
+        let minDistance = Infinity;
+        for (const pane of candidatePanes) {
+            const pos = positions.find(p => p.paneId === pane.paneId);
+            if (!pos)
+                continue;
+            const centerX = pos.left + pos.width / 2;
+            const centerY = pos.top + pos.height / 2;
+            let distance;
+            switch (direction) {
+                case 'up':
+                case 'down':
+                    // For vertical movement, prioritize vertical alignment, then distance
+                    const xDiff = Math.abs(centerX - currentCenterX);
+                    const yDiff = Math.abs(centerY - currentCenterY);
+                    // Weight horizontal difference less than vertical
+                    distance = yDiff + xDiff * 0.3;
+                    break;
+                case 'left':
+                case 'right':
+                    // For horizontal movement, prioritize horizontal alignment, then distance
+                    const xDiff2 = Math.abs(centerX - currentCenterX);
+                    const yDiff2 = Math.abs(centerY - currentCenterY);
+                    // Weight vertical difference less than horizontal
+                    distance = xDiff2 + yDiff2 * 0.3;
+                    break;
+            }
+            if (distance < minDistance) {
+                minDistance = distance;
+                closestPane = pane;
+            }
+        }
+        return closestPane;
+    };
     const savePanes = async (newPanes) => {
         await fs.writeFile(panesFile, JSON.stringify(newPanes, null, 2));
         setPanes(newPanes);
@@ -314,10 +596,8 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
             execSync('tmux send-keys C-l', { stdio: 'pipe' });
         }
         catch { }
-        // Exit Ink app cleanly before creating tmux pane (no cleanup needed here as we're re-launching)
-        exit();
-        // Wait for exit to complete
-        await new Promise(resolve => setTimeout(resolve, 500));
+        // Wait a bit for clearing to settle
+        await new Promise(resolve => setTimeout(resolve, 100));
         // 4. Force tmux to refresh the display
         try {
             execSync('tmux refresh-client', { stdio: 'pipe' });
@@ -325,14 +605,20 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         catch { }
         // Get current pane count to determine layout
         const paneCount = parseInt(execSync('tmux list-panes | wc -l', { encoding: 'utf-8' }).trim());
+        // Enable pane borders to show titles
+        try {
+            execSync(`tmux set-option -g pane-border-status top`, { stdio: 'pipe' });
+        }
+        catch {
+            // Ignore if already set or fails
+        }
         // Create new pane
         const paneInfo = execSync(`tmux split-window -h -P -F '#{pane_id}'`, { encoding: 'utf-8' }).trim();
         // Wait for pane creation to settle
         await new Promise(resolve => setTimeout(resolve, 500));
-        // Set pane title based on prompt or slug
-        const paneTitle = prompt ? prompt.substring(0, 30) : slug;
+        // Set pane title to match the slug
         try {
-            execSync(`tmux select-pane -t '${paneInfo}' -T "${paneTitle}"`, { stdio: 'pipe' });
+            execSync(`tmux select-pane -t '${paneInfo}' -T "${slug}"`, { stdio: 'pipe' });
         }
         catch {
             // Ignore if setting title fails
@@ -370,47 +656,117 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         execSync(`tmux send-keys -t '${paneInfo}' Enter`, { stdio: 'pipe' });
         // Monitor for Claude Code trust prompt and auto-respond
         const autoApproveTrust = async () => {
-            // Give Claude time to start and potentially show the trust prompt
-            await new Promise(resolve => setTimeout(resolve, 500));
-            try {
-                // Capture the pane content to check for trust prompt
-                const paneContent = execSync(`tmux capture-pane -t '${paneInfo}' -p`, { encoding: 'utf-8', stdio: 'pipe' });
-                // Check for various versions of the trust prompt
-                const trustPromptPatterns = [
-                    /Do you trust the files in this folder\?/i,
-                    /Trust the files in this workspace\?/i,
-                    /Do you trust the authors of the files/i,
-                    /Do you want to trust this workspace\?/i,
-                    /trust.*files.*folder/i,
-                    /trust.*workspace/i
-                ];
-                const hasTrustPrompt = trustPromptPatterns.some(pattern => pattern.test(paneContent));
-                if (hasTrustPrompt) {
-                    // Auto-respond with Enter (yes) to the trust prompt
-                    execSync(`tmux send-keys -t '${paneInfo}' Enter`, { stdio: 'pipe' });
-                    // Optionally wait a bit more and check if we need to send the command again
-                    await new Promise(resolve => setTimeout(resolve, 300));
-                    // Check if Claude is now ready (no longer showing trust prompt)
-                    const updatedContent = execSync(`tmux capture-pane -t '${paneInfo}' -p`, { encoding: 'utf-8', stdio: 'pipe' });
-                    // If the trust prompt is gone but Claude hasn't started processing the prompt,
-                    // we might need to resend the command
-                    if (!trustPromptPatterns.some(p => p.test(updatedContent)) &&
-                        !updatedContent.includes(prompt.substring(0, 20))) {
-                        // Claude might need the command again after trust approval
-                        // This handles cases where the trust dialog cleared the initial command
-                        if (prompt && prompt.trim()) {
-                            execSync(`tmux send-keys -t '${paneInfo}' '${escapedCmd}'`, { stdio: 'pipe' });
+            // Wait for Claude to start up before checking for prompts
+            await new Promise(resolve => setTimeout(resolve, 800));
+            const maxChecks = 100; // 100 checks * 100ms = 10 seconds total
+            const checkInterval = 100; // Check every 100ms
+            let lastContent = '';
+            let stableContentCount = 0;
+            let promptHandled = false;
+            // More comprehensive trust prompt patterns
+            const trustPromptPatterns = [
+                /Do you trust the files in this folder\?/i,
+                /Trust the files in this workspace\?/i,
+                /Do you trust the authors of the files/i,
+                /Do you want to trust this workspace\?/i,
+                /trust.*files.*folder/i,
+                /trust.*workspace/i,
+                /Do you trust/i,
+                /Trust this folder/i,
+                /trust.*directory/i,
+                /permission.*grant/i,
+                /allow.*access/i,
+                /workspace.*trust/i,
+                /accept.*edits/i, // Claude's accept edits prompt
+                /permission.*mode/i, // Permission mode prompt
+                /allow.*claude/i, // Allow Claude prompt
+                /\[y\/n\]/i, // Common yes/no prompt pattern
+                /\(y\/n\)/i,
+                /Yes\/No/i,
+                /\[Y\/n\]/i, // Default yes pattern
+                /press.*enter.*accept/i, // Press enter to accept
+                /press.*enter.*continue/i // Press enter to continue
+            ];
+            for (let i = 0; i < maxChecks; i++) {
+                await new Promise(resolve => setTimeout(resolve, checkInterval));
+                try {
+                    // Capture the pane content
+                    const paneContent = execSync(`tmux capture-pane -t '${paneInfo}' -p -S -30`, // Capture last 30 lines
+                    { encoding: 'utf-8', stdio: 'pipe' });
+                    // Check if content has stabilized (same for 3 checks = prompt is waiting)
+                    if (paneContent === lastContent) {
+                        stableContentCount++;
+                    }
+                    else {
+                        stableContentCount = 0;
+                        lastContent = paneContent;
+                    }
+                    // Look for trust prompt in the current content
+                    const hasTrustPrompt = trustPromptPatterns.some(pattern => pattern.test(paneContent));
+                    // Also check if we see specific Claude permission text
+                    const hasClaudePermissionPrompt = paneContent.includes('Do you trust') ||
+                        paneContent.includes('trust the files') ||
+                        paneContent.includes('permission') ||
+                        paneContent.includes('allow') ||
+                        (paneContent.includes('folder') && paneContent.includes('?'));
+                    if ((hasTrustPrompt || hasClaudePermissionPrompt) && !promptHandled) {
+                        // Log what we detected for debugging
+                        // Detected trust prompt in pane, content stable
+                        // Content is stable and we found a prompt
+                        if (stableContentCount >= 2) {
+                            // Attempting to auto-approve trust prompt
+                            // Try multiple response methods to ensure it works
+                            // Method 1: Send 'y' followed by Enter (most explicit)
+                            // Sending 'y' + Enter
+                            execSync(`tmux send-keys -t '${paneInfo}' 'y'`, { stdio: 'pipe' });
+                            await new Promise(resolve => setTimeout(resolve, 50));
                             execSync(`tmux send-keys -t '${paneInfo}' Enter`, { stdio: 'pipe' });
+                            // Method 2: Just Enter (if it's a yes/no with default yes)
+                            await new Promise(resolve => setTimeout(resolve, 100));
+                            // Sending additional Enter
+                            execSync(`tmux send-keys -t '${paneInfo}' Enter`, { stdio: 'pipe' });
+                            // Mark as handled to avoid duplicate responses
+                            promptHandled = true;
+                            // Wait and check if prompt is gone
+                            await new Promise(resolve => setTimeout(resolve, 500));
+                            // Verify the prompt is gone
+                            const updatedContent = execSync(`tmux capture-pane -t '${paneInfo}' -p -S -10`, { encoding: 'utf-8', stdio: 'pipe' });
+                            // If trust prompt is gone, check if we need to resend the Claude command
+                            const promptGone = !trustPromptPatterns.some(p => p.test(updatedContent));
+                            if (promptGone) {
+                                // Check if Claude is running or if we need to restart it
+                                const claudeRunning = updatedContent.includes('Claude') ||
+                                    updatedContent.includes('claude') ||
+                                    updatedContent.includes('Assistant') ||
+                                    (prompt && updatedContent.includes(prompt.substring(0, Math.min(20, prompt.length))));
+                                if (!claudeRunning && !updatedContent.includes('$')) {
+                                    // Claude might have exited after permission was granted, restart it
+                                    // Claude not running after trust approval, restarting
+                                    await new Promise(resolve => setTimeout(resolve, 300));
+                                    execSync(`tmux send-keys -t '${paneInfo}' '${escapedCmd}'`, { stdio: 'pipe' });
+                                    execSync(`tmux send-keys -t '${paneInfo}' Enter`, { stdio: 'pipe' });
+                                }
+                                // Successfully handled the prompt
+                                break;
+                            }
                         }
                     }
+                    // If we see Claude is already running without prompts, we're done
+                    if (!hasTrustPrompt && !hasClaudePermissionPrompt &&
+                        (paneContent.includes('Claude') || paneContent.includes('Assistant'))) {
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Continue checking, errors are non-fatal
+                    // Error checking for trust prompt
                 }
-            }
-            catch (error) {
-                // Ignore errors in auto-approval, it's a best-effort feature
             }
         };
         // Start monitoring for trust prompt in background
-        autoApproveTrust();
+        autoApproveTrust().catch(err => {
+            // Error in autoApproveTrust
+        });
         // Keep focus on the new pane
         execSync(`tmux select-pane -t '${paneInfo}'`, { stdio: 'pipe' });
         // Save pane info
@@ -423,7 +779,7 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         };
         const updatedPanes = [...panes, newPane];
         await fs.writeFile(panesFile, JSON.stringify(updatedPanes, null, 2));
-        // Switch back to the original pane (where dmux was running)
+        // Switch back to the original pane (where dmux is running)
         execSync(`tmux select-pane -t '${originalPaneId}'`, { stdio: 'pipe' });
         // Re-set the title for the dmux pane
         try {
@@ -432,13 +788,23 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         catch {
             // Ignore if setting title fails
         }
-        // Small delay to ensure pane is fully established before re-launching
-        await new Promise(resolve => setTimeout(resolve, 100));
-        // Re-launch dmux in the original pane
-        execSync(`tmux send-keys -t '${originalPaneId}' 'dmux' Enter`, { stdio: 'pipe' });
+        // Clear the screen and redraw the UI
+        process.stdout.write('\x1b[2J\x1b[H');
+        // Reset the creating pane flag and refresh
+        setIsCreatingPane(false);
+        setStatusMessage('');
+        // Force a reload of panes to ensure UI is up to date
+        await loadPanes();
     };
     const jumpToPane = (paneId) => {
         try {
+            // Enable pane borders to show titles (if not already enabled)
+            try {
+                execSync(`tmux set-option -g pane-border-status top`, { stdio: 'pipe' });
+            }
+            catch {
+                // Ignore if already set or fails
+            }
             execSync(`tmux select-pane -t '${paneId}'`, { stdio: 'pipe' });
             setStatusMessage('Jumped to pane');
             setTimeout(() => setStatusMessage(''), 2000);
@@ -527,8 +893,38 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
                 execSync(`git -C "${pane.worktreePath}" commit -m '${escapedMessage}'`, { stdio: 'pipe' });
             }
             setStatusMessage('Merging into main...');
-            // Merge the worktree branch
-            execSync(`git merge ${pane.slug}`, { stdio: 'pipe' });
+            // Try to merge the worktree branch
+            try {
+                execSync(`git merge ${pane.slug}`, { stdio: 'pipe' });
+            }
+            catch (mergeError) {
+                // Check if this is a merge conflict
+                const errorMessage = mergeError.message || mergeError.toString();
+                if (errorMessage.includes('CONFLICT') || errorMessage.includes('conflict')) {
+                    // Merge conflict detected - exit dmux and inform user
+                    // Merge conflict detected - exit dmux and inform user
+                    process.stderr.write('\n\x1b[31m✗ Merge conflict detected!\x1b[0m\n');
+                    process.stderr.write(`\nThere are merge conflicts when merging branch '${pane.slug}' into '${mainBranch}'.\n`);
+                    process.stderr.write('\nTo resolve:\n');
+                    process.stderr.write('1. Manually resolve the merge conflicts in your editor\n');
+                    process.stderr.write('2. Stage the resolved files: git add <resolved-files>\n');
+                    process.stderr.write('3. Complete the merge: git commit\n');
+                    process.stderr.write('4. Run dmux again to continue managing your panes\n');
+                    process.stderr.write('\nExiting dmux now...\n\n');
+                    // Clean exit
+                    process.stdout.write('\x1b[2J\x1b[H');
+                    process.stdout.write('\x1b[3J');
+                    try {
+                        execSync('tmux clear-history', { stdio: 'pipe' });
+                    }
+                    catch { }
+                    process.exit(1);
+                }
+                else {
+                    // Some other merge error
+                    throw mergeError;
+                }
+            }
             // Remove worktree
             execSync(`git worktree remove "${pane.worktreePath}"`, { stdio: 'pipe' });
             // Delete branch
@@ -639,163 +1035,131 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         // Final fallback
         return 'chore: merge worktree changes';
     };
-    const generateCommand = async (type, changeRequest) => {
-        setGeneratingCommand(true);
-        setStatusMessage(`Generating ${type} command with AI...`);
+    const detectPackageManager = async () => {
         try {
-            // Find claude command
-            const claudeCmd = await findClaudeCommand();
-            if (!claudeCmd) {
-                throw new Error('Claude Code not found. Please ensure Claude Code is installed and accessible');
-            }
             // Get project root
             const projectRoot = execSync('git rev-parse --show-toplevel', {
                 encoding: 'utf-8',
                 stdio: 'pipe'
             }).trim();
-            // Pre-fetch directory listings
-            setStatusMessage('Analyzing project structure...');
-            // Get main directory listing
-            const mainFiles = execSync(`ls -la "${projectRoot}"`, {
-                encoding: 'utf-8',
-                stdio: 'pipe'
-            });
-            // Get worktree listing (simulate what it would look like)
-            // For now we'll use main, but in reality worktrees start with the same files
-            const worktreeFiles = mainFiles;
-            // Check for package.json to understand the project type
-            let packageJsonContent = '';
+            // Check if package.json exists
             try {
-                packageJsonContent = await fs.readFile(path.join(projectRoot, 'package.json'), 'utf-8');
-            }
-            catch { }
-            let requestedFile = '';
-            let maxAttempts = 2; // Allow one file request, then must generate command
-            for (let attempt = 0; attempt < maxAttempts; attempt++) {
-                const isLastAttempt = attempt === maxAttempts - 1;
-                // Build the prompt
-                let prompt = `You are generating a ${type === 'test' ? 'test' : 'development server'} command for a git worktree.
-
-CRITICAL CONTEXT:
-- Main project directory: ${projectRoot}
-- Worktrees are siblings: ${path.dirname(projectRoot)}/{project-name}-{branch}
-- Command runs INSIDE the worktree (not main)
-- Files like .env, .wrangler, node_modules are NOT shared between worktrees
-
-Files in MAIN directory:
-${mainFiles}
-
-Files in WORKTREE (initially same as main):
-${worktreeFiles}
-
-${packageJsonContent ? `package.json contents:\n${packageJsonContent.substring(0, 3000)}\n` : ''}
-
-${requestedFile}
-
-${changeRequest ? `User's requested change: ${changeRequest}\n` : ''}
-
-Your task: Generate a command to ${type === 'test' ? 'run tests' : 'start a dev server'} in the worktree.
-
-Consider:
-1. Copy needed files from main (e.g., cp ../${path.basename(projectRoot)}/.env .)
-2. Install dependencies (npm/pnpm/yarn install)
-3. Build if needed
-4. Run the ${type} command
-
-${isLastAttempt ? 'YOU MUST PROVIDE THE FINAL COMMAND NOW. No more file requests allowed.' : 'You can request ONE file to read, then you must provide the command.'}
-
-Respond with ONLY a JSON object:
-
-${!isLastAttempt ? `To read ONE file (only one chance):
-{
-  "type": "cat",
-  "path": "path/to/file"
-}
-
-OR ` : ''}To provide the final command:
-{
-  "type": "command",
-  "command": "cp ../${path.basename(projectRoot)}/.env . && npm install && npm run ${type}",
-  "description": "Copy env, install deps, run ${type}"
-}`;
-                // Write prompt to a temporary file
-                const tmpFile = `/tmp/dmux-prompt-${Date.now()}.txt`;
-                await fs.writeFile(tmpFile, prompt);
-                // Use Claude to generate the response
-                const result = execSync(`${claudeCmd} -p "$(cat ${tmpFile})" --output-format json`, {
-                    encoding: 'utf-8',
-                    stdio: 'pipe',
-                    maxBuffer: 1024 * 1024 * 10
-                });
-                // Clean up temp file
-                try {
-                    await fs.unlink(tmpFile);
+                await fs.access(path.join(projectRoot, 'package.json'));
+                // Check for lock files to determine package manager
+                const files = await fs.readdir(projectRoot);
+                if (files.includes('pnpm-lock.yaml')) {
+                    return { manager: 'pnpm', hasPackageJson: true };
                 }
-                catch { }
-                // Parse the response
-                let response;
-                try {
-                    const wrapper = JSON.parse(result);
-                    let actualResult = wrapper.result || wrapper;
-                    if (typeof actualResult === 'string') {
-                        actualResult = actualResult.trim();
-                        // Extract JSON from the response
-                        const jsonMatch = actualResult.match(/\{[\s\S]*\}/);
-                        if (jsonMatch) {
-                            let jsonStr = jsonMatch[0];
-                            // Clean up markdown code blocks if present
-                            if (actualResult.includes('```')) {
-                                const codeBlockMatch = actualResult.match(/```(?:json)?\s*([\s\S]*?)```/);
-                                if (codeBlockMatch) {
-                                    jsonStr = codeBlockMatch[1].trim();
-                                }
-                            }
-                            actualResult = JSON.parse(jsonStr);
-                        }
-                        else {
-                            throw new Error('No JSON object found in response');
-                        }
-                    }
-                    response = actualResult;
-                }
-                catch (parseError) {
-                    console.error('Failed to parse Claude response:', result);
-                    throw new Error(`Failed to parse AI response: ${parseError}`);
+                else if (files.includes('yarn.lock')) {
+                    return { manager: 'yarn', hasPackageJson: true };
                 }
-                // Handle the response
-                if (response.type === 'cat' && !isLastAttempt) {
-                    // Read the requested file
-                    const targetPath = path.join(projectRoot, response.path);
-                    try {
-                        const content = await fs.readFile(targetPath, 'utf-8');
-                        const truncated = content.length > 4000
-                            ? content.substring(0, 4000) + '\n... [truncated]'
-                            : content;
-                        requestedFile = `\nContents of ${response.path}:\n${truncated}\n`;
-                    }
-                    catch (err) {
-                        requestedFile = `\nError reading ${response.path}: File not found\n`;
-                    }
-                    // Continue to next iteration to get the command
+                else if (files.includes('package-lock.json')) {
+                    return { manager: 'npm', hasPackageJson: true };
                 }
-                else if (response.type === 'command') {
-                    // Got the command!
-                    setGeneratingCommand(false);
-                    setStatusMessage('');
-                    return response.command;
+                else {
+                    // Default to npm if no lock file found
+                    return { manager: 'npm', hasPackageJson: true };
                 }
-                else if (isLastAttempt) {
-                    // Last attempt must provide a command
-                    throw new Error('AI did not provide a command on final attempt');
+            }
+            catch {
+                // No package.json found
+                return { manager: null, hasPackageJson: false };
+            }
+        }
+        catch {
+            return { manager: null, hasPackageJson: false };
+        }
+    };
+    const suggestCommand = async (type) => {
+        const { manager, hasPackageJson } = await detectPackageManager();
+        if (!hasPackageJson) {
+            return null;
+        }
+        // Suggest standard commands based on package manager
+        if (type === 'test') {
+            return `${manager} run test`;
+        }
+        else {
+            return `${manager} run dev`;
+        }
+    };
+    const copyNonGitFiles = async (worktreePath) => {
+        try {
+            setStatusMessage('Copying non-git files from main...');
+            // Get project root
+            const projectRoot = execSync('git rev-parse --show-toplevel', {
+                encoding: 'utf-8',
+                stdio: 'pipe'
+            }).trim();
+            // Use rsync to copy non-tracked files
+            // This copies everything except git-tracked files, .git, and common build directories
+            const rsyncCmd = `rsync -avz --exclude='.git' --exclude='node_modules' --exclude='dist' --exclude='build' --exclude='.next' --exclude='.turbo' "${projectRoot}/" "${worktreePath}/"`;
+            execSync(rsyncCmd, { stdio: 'pipe' });
+            setStatusMessage('Non-git files copied successfully');
+            setTimeout(() => setStatusMessage(''), 2000);
+        }
+        catch (error) {
+            setStatusMessage('Failed to copy non-git files');
+            setTimeout(() => setStatusMessage(''), 2000);
+        }
+    };
+    const runCommandInternal = async (type, pane) => {
+        if (!pane.worktreePath) {
+            setStatusMessage('No worktree path for this pane');
+            setTimeout(() => setStatusMessage(''), 2000);
+            return;
+        }
+        const command = type === 'test' ? projectSettings.testCommand : projectSettings.devCommand;
+        if (!command) {
+            setStatusMessage('No command configured');
+            setTimeout(() => setStatusMessage(''), 2000);
+            return;
+        }
+        try {
+            setRunningCommand(true);
+            setStatusMessage(`Starting ${type} in background window...`);
+            // Kill existing window if present
+            const existingWindowId = type === 'test' ? pane.testWindowId : pane.devWindowId;
+            if (existingWindowId) {
+                try {
+                    execSync(`tmux kill-window -t '${existingWindowId}'`, { stdio: 'pipe' });
                 }
+                catch { }
             }
-            throw new Error('Failed to generate command after maximum attempts');
+            // Create a new background window for the command
+            const windowName = `${pane.slug}-${type}`;
+            const windowId = execSync(`tmux new-window -d -n '${windowName}' -P -F '#{window_id}'`, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+            // Create a log file to capture output
+            const logFile = `/tmp/dmux-${pane.id}-${type}.log`;
+            // Build the command with output capture
+            const fullCommand = `cd "${pane.worktreePath}" && ${command} 2>&1 | tee ${logFile}`;
+            // Send the command to the new window
+            execSync(`tmux send-keys -t '${windowId}' '${fullCommand.replace(/'/g, "'\\''")}' Enter`, { stdio: 'pipe' });
+            // Update pane with window info
+            const updatedPane = {
+                ...pane,
+                [type === 'test' ? 'testWindowId' : 'devWindowId']: windowId,
+                [type === 'test' ? 'testStatus' : 'devStatus']: 'running'
+            };
+            const updatedPanes = panes.map(p => p.id === pane.id ? updatedPane : p);
+            await savePanes(updatedPanes);
+            // Start monitoring the output
+            if (type === 'test') {
+                // For tests, monitor for completion
+                setTimeout(() => monitorTestOutput(pane.id, logFile), 2000);
+            }
+            else {
+                // For dev, monitor for server URL
+                setTimeout(() => monitorDevOutput(pane.id, logFile), 2000);
+            }
+            setRunningCommand(false);
+            setStatusMessage(`${type === 'test' ? 'Test' : 'Dev server'} started in background`);
+            setTimeout(() => setStatusMessage(''), 3000);
         }
         catch (error) {
-            setGeneratingCommand(false);
-            setStatusMessage(`Failed to generate command: ${error}`);
+            setRunningCommand(false);
+            setStatusMessage(`Failed to run ${type} command`);
             setTimeout(() => setStatusMessage(''), 3000);
-            return null;
         }
     };
     const runCommand = async (type, pane) => {
@@ -805,11 +1169,21 @@ OR ` : ''}To provide the final command:
             return;
         }
         const command = type === 'test' ? projectSettings.testCommand : projectSettings.devCommand;
+        const isFirstRun = type === 'test' ? !projectSettings.firstTestRun : !projectSettings.firstDevRun;
         if (!command) {
             // No command configured, prompt user
             setShowCommandPrompt(type);
             return;
         }
+        // Check if this is the first run and offer to copy non-git files
+        if (isFirstRun) {
+            // Show file copy prompt and wait for response
+            setShowFileCopyPrompt(true);
+            setCurrentCommandType(type);
+            setStatusMessage(`First time running ${type} command...`);
+            // Return here - the actual command will be run after user responds to prompt
+            return;
+        }
         try {
             setRunningCommand(true);
             setStatusMessage(`Starting ${type} in background window...`);
@@ -997,8 +1371,38 @@ OR ` : ''}To provide the final command:
                 execSync(`git -C "${pane.worktreePath}" commit -m '${escapedMessage}'`, { stdio: 'pipe' });
             }
             setStatusMessage('Merging into main...');
-            // Merge the worktree branch
-            execSync(`git merge ${pane.slug}`, { stdio: 'pipe' });
+            // Try to merge the worktree branch
+            try {
+                execSync(`git merge ${pane.slug}`, { stdio: 'pipe' });
+            }
+            catch (mergeError) {
+                // Check if this is a merge conflict
+                const errorMessage = mergeError.message || mergeError.toString();
+                if (errorMessage.includes('CONFLICT') || errorMessage.includes('conflict')) {
+                    // Merge conflict detected - exit dmux and inform user
+                    // Merge conflict detected - exit dmux and inform user
+                    process.stderr.write('\n\x1b[31m✗ Merge conflict detected!\x1b[0m\n');
+                    process.stderr.write(`\nThere are merge conflicts when merging branch '${pane.slug}' into '${mainBranch}'.\n`);
+                    process.stderr.write('\nTo resolve:\n');
+                    process.stderr.write('1. Manually resolve the merge conflicts in your editor\n');
+                    process.stderr.write('2. Stage the resolved files: git add <resolved-files>\n');
+                    process.stderr.write('3. Complete the merge: git commit\n');
+                    process.stderr.write('4. Run dmux again to continue managing your panes\n');
+                    process.stderr.write('\nExiting dmux now...\n\n');
+                    // Clean exit
+                    process.stdout.write('\x1b[2J\x1b[H');
+                    process.stdout.write('\x1b[3J');
+                    try {
+                        execSync('tmux clear-history', { stdio: 'pipe' });
+                    }
+                    catch { }
+                    process.exit(1);
+                }
+                else {
+                    // Some other merge error
+                    throw mergeError;
+                }
+            }
             // Remove worktree
             execSync(`git worktree remove "${pane.worktreePath}"`, { stdio: 'pipe' });
             // Delete branch
@@ -1030,24 +1434,55 @@ OR ` : ''}To provide the final command:
         exit();
     };
     useInput(async (input, key) => {
-        if (isCreatingPane || generatingCommand || runningCommand) {
+        if (isCreatingPane || runningCommand) {
             // Disable input while performing operations
             return;
         }
+        if (showFileCopyPrompt) {
+            if (input === 'y' || input === 'Y') {
+                setShowFileCopyPrompt(false);
+                const selectedPane = panes[selectedIndex];
+                if (selectedPane && selectedPane.worktreePath && currentCommandType) {
+                    await copyNonGitFiles(selectedPane.worktreePath);
+                    // Mark as not first run and continue with command
+                    const newSettings = {
+                        ...projectSettings,
+                        [currentCommandType === 'test' ? 'firstTestRun' : 'firstDevRun']: true
+                    };
+                    await saveSettings(newSettings);
+                    // Now run the actual command
+                    await runCommandInternal(currentCommandType, selectedPane);
+                }
+                setCurrentCommandType(null);
+            }
+            else if (input === 'n' || input === 'N' || key.escape) {
+                setShowFileCopyPrompt(false);
+                const selectedPane = panes[selectedIndex];
+                if (selectedPane && currentCommandType) {
+                    // Mark as not first run and continue without copying
+                    const newSettings = {
+                        ...projectSettings,
+                        [currentCommandType === 'test' ? 'firstTestRun' : 'firstDevRun']: true
+                    };
+                    await saveSettings(newSettings);
+                    // Now run the actual command
+                    await runCommandInternal(currentCommandType, selectedPane);
+                }
+                setCurrentCommandType(null);
+            }
+            return;
+        }
         if (showCommandPrompt) {
             if (key.escape) {
                 setShowCommandPrompt(null);
                 setCommandInput('');
-                setShowAIPrompt(false);
-                setAIChangeRequest('');
             }
-            else if (key.return && !showAIPrompt) {
+            else if (key.return) {
                 if (commandInput.trim() === '') {
-                    // User wants AI to generate
-                    const generated = await generateCommand(showCommandPrompt);
-                    if (generated) {
-                        setCommandInput(generated);
-                        setShowAIPrompt(true);
+                    // If empty, suggest a default command based on package manager
+                    const suggested = await suggestCommand(showCommandPrompt);
+                    if (suggested) {
+                        setCommandInput(suggested);
                     }
                 }
                 else {
@@ -1059,36 +1494,22 @@ OR ` : ''}To provide the final command:
                     await saveSettings(newSettings);
                     const selectedPane = panes[selectedIndex];
                     if (selectedPane) {
-                        await runCommand(showCommandPrompt, selectedPane);
-                    }
-                    setShowCommandPrompt(null);
-                    setCommandInput('');
-                    setShowAIPrompt(false);
-                }
-            }
-            else if (key.return && showAIPrompt) {
-                if (aiChangeRequest.trim() === '') {
-                    // User accepts AI generated command
-                    const newSettings = {
-                        ...projectSettings,
-                        [showCommandPrompt === 'test' ? 'testCommand' : 'devCommand']: commandInput.trim()
-                    };
-                    await saveSettings(newSettings);
-                    const selectedPane = panes[selectedIndex];
-                    if (selectedPane) {
-                        await runCommand(showCommandPrompt, selectedPane);
+                        // Check if first run
+                        const isFirstRun = showCommandPrompt === 'test' ? !projectSettings.firstTestRun : !projectSettings.firstDevRun;
+                        if (isFirstRun) {
+                            setCurrentCommandType(showCommandPrompt);
+                            setShowCommandPrompt(null);
+                            setShowFileCopyPrompt(true);
+                        }
+                        else {
+                            await runCommandInternal(showCommandPrompt, selectedPane);
+                            setShowCommandPrompt(null);
+                            setCommandInput('');
+                        }
                     }
-                    setShowCommandPrompt(null);
-                    setCommandInput('');
-                    setShowAIPrompt(false);
-                    setAIChangeRequest('');
-                }
-                else {
-                    // User wants changes, regenerate
-                    const generated = await generateCommand(showCommandPrompt, aiChangeRequest);
-                    if (generated) {
-                        setCommandInput(generated);
-                        setAIChangeRequest('');
+                    else {
+                        setShowCommandPrompt(null);
+                        setCommandInput('');
                     }
                 }
             }
@@ -1132,13 +1553,27 @@ OR ` : ''}To provide the final command:
             }
             return;
         }
-        if (key.upArrow) {
-            setSelectedIndex(Math.max(0, selectedIndex - 1));
-        }
-        else if (key.downArrow) {
-            setSelectedIndex(Math.min(panes.length, selectedIndex + 1));
+        // Handle directional navigation with spatial awareness based on card grid layout
+        if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow) {
+            let targetIndex = null;
+            if (key.upArrow) {
+                targetIndex = findCardInDirection(selectedIndex, 'up');
+            }
+            else if (key.downArrow) {
+                targetIndex = findCardInDirection(selectedIndex, 'down');
+            }
+            else if (key.leftArrow) {
+                targetIndex = findCardInDirection(selectedIndex, 'left');
+            }
+            else if (key.rightArrow) {
+                targetIndex = findCardInDirection(selectedIndex, 'right');
+            }
+            if (targetIndex !== null) {
+                setSelectedIndex(targetIndex);
+            }
+            return;
         }
-        else if (input === 'q') {
+        if (input === 'q') {
             cleanExit();
         }
         else if (input === 'n' || (key.return && selectedIndex === panes.length)) {
@@ -1208,6 +1643,9 @@ OR ` : ''}To provide the final command:
                             React.createElement(Text, { color: selectedIndex === index ? 'cyan' : 'white', bold: true, wrap: "truncate" }, pane.slug),
                             pane.worktreePath && (React.createElement(Text, { color: "gray" }, " (wt)"))),
                         React.createElement(Text, { color: "gray", dimColor: true, wrap: "truncate" }, pane.prompt.substring(0, 30)),
+                        pane.claudeStatus && (React.createElement(Box, null,
+                            pane.claudeStatus === 'working' && (React.createElement(Text, { color: "cyan" }, "\u273B Working...")),
+                            pane.claudeStatus === 'waiting' && (React.createElement(Text, { color: "yellow", bold: true }, "\u26A0 Needs attention")))),
                         (pane.testStatus || pane.devStatus) && (React.createElement(Box, null,
                             pane.testStatus === 'running' && (React.createElement(Text, { color: "yellow" }, "\u23F3 Test")),
                             pane.testStatus === 'passed' && (React.createElement(Text, { color: "green" }, "\u2713 Test")),
@@ -1267,7 +1705,7 @@ OR ` : ''}To provide the final command:
                         React.createElement(Text, { color: selectedCloseOption === 3 ? 'cyan' : 'white' },
                             selectedCloseOption === 3 ? '▶ ' : '  ',
                             "Just Close - Close pane only")))))),
-        showCommandPrompt && !showAIPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "magenta", paddingX: 1, marginTop: 1 },
+        showCommandPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "magenta", paddingX: 1, marginTop: 1 },
             React.createElement(Box, { flexDirection: "column" },
                 React.createElement(Text, { color: "magenta", bold: true },
                     "Configure ",
@@ -1277,24 +1715,16 @@ OR ` : ''}To provide the final command:
                     "Enter command to run ",
                     showCommandPrompt === 'test' ? 'tests' : 'dev server',
                     " in worktrees"),
-                React.createElement(Text, { dimColor: true }, "(Press Enter with empty input to generate with AI, ESC to cancel)"),
+                React.createElement(Text, { dimColor: true }, "(Press Enter with empty input for suggested command, ESC to cancel)"),
                 React.createElement(Box, { marginTop: 1 },
                     React.createElement(TextInput, { value: commandInput, onChange: setCommandInput, placeholder: showCommandPrompt === 'test' ? 'e.g., npm test, pnpm test' : 'e.g., npm run dev, pnpm dev' }))))),
-        showCommandPrompt && showAIPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "magenta", paddingX: 1, marginTop: 1 },
+        showFileCopyPrompt && (React.createElement(Box, { borderStyle: "double", borderColor: "yellow", paddingX: 1, marginTop: 1 },
             React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { color: "magenta", bold: true },
-                    "AI Generated ",
-                    showCommandPrompt === 'test' ? 'Test' : 'Dev',
-                    " Command"),
-                React.createElement(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", paddingX: 1 },
-                    React.createElement(Text, null, commandInput)),
-                React.createElement(Box, { marginTop: 1 },
-                    React.createElement(Text, { dimColor: true }, "Press Enter to accept, or describe changes needed:")),
+                React.createElement(Text, { color: "yellow", bold: true }, "First Run Setup"),
+                React.createElement(Text, null, "Copy non-git files (like .env, configs) from main to worktree?"),
+                React.createElement(Text, { dimColor: true }, "This includes files not tracked by git but excludes node_modules, dist, etc."),
                 React.createElement(Box, { marginTop: 1 },
-                    React.createElement(TextInput, { value: aiChangeRequest, onChange: setAIChangeRequest, placeholder: "e.g., 'also copy .env file' or press Enter to accept" }))))),
-        generatingCommand && (React.createElement(Box, { borderStyle: "single", borderColor: "yellow", paddingX: 1, marginTop: 1 },
-            React.createElement(Text, { color: "yellow" },
-                React.createElement(Text, { bold: true }, "\u23F3 Generating command with AI...")))),
+                    React.createElement(Text, null, "(y/n):"))))),
         runningCommand && (React.createElement(Box, { borderStyle: "single", borderColor: "blue", paddingX: 1, marginTop: 1 },
             React.createElement(Text, { color: "blue" },
                 React.createElement(Text, { bold: true }, "\u25B6 Running command...")))),
@@ -1302,7 +1732,20 @@ OR ` : ''}To provide the final command:
             React.createElement(Text, { color: "green" }, statusMessage))),
         !showNewPaneDialog && !showCommandPrompt && (React.createElement(Box, { marginTop: 1, flexDirection: "column" },
             React.createElement(Text, { dimColor: true }, "Commands: [j]ump \u2022 [t]est \u2022 [d]ev \u2022 [o]pen \u2022 [x]close \u2022 [m]erge \u2022 [n]ew \u2022 [q]uit"),
-            React.createElement(Text, { dimColor: true }, "Use \u2191\u2193 arrows to navigate, Enter to select"))),
+            React.createElement(Text, { dimColor: true }, "Use arrow keys (\u2191\u2193\u2190\u2192) for spatial navigation, Enter to select"),
+            process.env.DEBUG_DMUX && (React.createElement(Text, { dimColor: true },
+                "Grid: ",
+                Math.max(1, Math.floor(terminalWidth / 37)),
+                " cols \u00D7 ",
+                Math.ceil((panes.length + 1) / Math.max(1, Math.floor(terminalWidth / 37))),
+                " rows | Selected: ",
+                (() => {
+                    const pos = getCardGridPosition(selectedIndex);
+                    return ` row ${pos.row}, col ${pos.col}`;
+                })(),
+                " | Terminal: ",
+                terminalWidth,
+                "w")))),
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true },
                 "dmux v",