dmux 1.2.0 → 1.3.0

package/dist/DmuxApp.js

@@ -28,11 +28,23 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
     const [generatingCommand, setGeneratingCommand] = useState(false);
     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 Claude status monitoring
+        const claudeInterval = setInterval(() => {
+            monitorClaudeStatus();
+        }, 200);
         // Add cleanup handlers for process termination
         const handleTermination = () => {
             // Clear screen before exit
@@ -48,10 +60,89 @@ const DmuxApp = ({ dmuxDir, panesFile, projectName, sessionName, settingsFile })
         process.on('SIGTERM', handleTermination);
         return () => {
             clearInterval(interval);
+            process.stdout.removeListener('resize', handleResize);
+            clearInterval(claudeInterval);
             process.removeListener('SIGINT', handleTermination);
             process.removeListener('SIGTERM', handleTermination);
         };
     }, []);
+    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 150ms to avoid overlapping checks)
+                if (pane.lastClaudeCheck && Date.now() - pane.lastClaudeCheck < 150) {
+                    return pane;
+                }
+                // Capture the last 20 lines of the pane
+                const captureOutput = execSync(`tmux capture-pane -t '${pane.paneId}' -p -S -20`, { encoding: 'utf-8', stdio: 'pipe' });
+                // Pattern detection for Claude Code states
+                // Working patterns - Claude is processing
+                // Look for the loading symbols and "(esc to interrupt)"
+                const workingPatterns = [
+                    /\(esc to interrupt\)/i, // Most reliable indicator
+                    /✻|✢|✽|·|✳/, // Loading symbols you identified
+                    /⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/, // Braille spinner characters (might also be used)
+                ];
+                // Permission/attention patterns - needs user input
+                const attentionPatterns = [
+                    /Do you want to (allow|approve|grant|trust)/i,
+                    /Permission required/i,
+                    /\[y\/n\]/i,
+                    /\(y\/n\)/i,
+                    /Would you like to/i,
+                    /Continue\?/i,
+                    /Proceed\?/i,
+                    /Accept.*\?/i,
+                    /Allow.*\?/i,
+                    /Approve.*\?/i,
+                    /Grant.*\?/i,
+                    /Trust.*\?/i,
+                    /press.*enter.*continue/i,
+                    /press.*enter.*accept/i,
+                    /waiting for.*input/i,
+                    /requires.*permission/i,
+                    /needs.*approval/i
+                ];
+                // 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));
+                // Determine status
+                let newStatus = 'idle';
+                if (isWorking) {
+                    newStatus = 'working';
+                }
+                else if (needsAttention) {
+                    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));
+        }
+    };
     const loadSettings = async () => {
         try {
             const content = await fs.readFile(settingsFile, 'utf-8');
@@ -81,10 +172,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 +197,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 +561,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 +570,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 +621,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 +744,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 +753,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 +858,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
@@ -759,7 +1120,7 @@ OR ` : ''}To provide the final command:
                     response = actualResult;
                 }
                 catch (parseError) {
-                    console.error('Failed to parse Claude response:', result);
+                    // Failed to parse Claude response
                     throw new Error(`Failed to parse AI response: ${parseError}`);
                 }
                 // Handle the response
@@ -997,8 +1358,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
@@ -1132,13 +1523,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 +1613,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")),
@@ -1302,7 +1710,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",