ccmanager 0.0.6 → 0.1.1

package/dist/components/Session.js

@@ -1,6 +1,7 @@
 import { useEffect, useState } from 'react';
 import { useStdout } from 'ink';
 import { shortcutManager } from '../services/shortcutManager.js';
+import { TerminalSerializer } from '../utils/terminalSerializer.js';
 const Session = ({ session, sessionManager, onReturnToMenu, }) => {
     const { stdout } = useStdout();
     const [isExiting, setIsExiting] = useState(false);
@@ -12,24 +13,24 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         // Handle session restoration
         const handleSessionRestore = (restoredSession) => {
             if (restoredSession.id === session.id) {
-                // Replay all buffered output, but skip the initial clear if present
-                for (let i = 0; i < restoredSession.outputHistory.length; i++) {
-                    const buffer = restoredSession.outputHistory[i];
-                    if (!buffer)
-                        continue;
-                    const str = buffer.toString('utf8');
-                    // Skip clear screen sequences at the beginning
-                    if (i === 0 && (str.includes('\x1B[2J') || str.includes('\x1B[H'))) {
-                        // Skip this buffer or remove the clear sequence
-                        const cleaned = str
-                            .replace(/\x1B\[2J/g, '')
-                            .replace(/\x1B\[H/g, '');
-                        if (cleaned.length > 0) {
-                            stdout.write(Buffer.from(cleaned, 'utf8'));
-                        }
-                    }
-                    else {
-                        stdout.write(buffer);
+                // Instead of replaying all history, use the virtual terminal's current buffer
+                // This avoids duplicate content issues
+                const terminal = restoredSession.terminal;
+                if (terminal) {
+                    // Use the TerminalSerializer to preserve ANSI escape sequences (colors, styles)
+                    const serializedOutput = TerminalSerializer.serialize(terminal, {
+                        trimRight: true,
+                        includeEmptyLines: true,
+                    });
+                    // Write the serialized terminal state with preserved formatting
+                    if (serializedOutput) {
+                        stdout.write(serializedOutput);
+                        // Position cursor at the correct location
+                        const buffer = terminal.buffer.active;
+                        const cursorY = buffer.cursorY;
+                        const cursorX = buffer.cursorX;
+                        // Move cursor to the saved position
+                        stdout.write(`\x1B[${cursorY + 1};${cursorX + 1}H`);
                     }
                 }
             }
@@ -55,7 +56,13 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         sessionManager.on('sessionExit', handleSessionExit);
         // Handle terminal resize
         const handleResize = () => {
-            session.process.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+            const cols = process.stdout.columns || 80;
+            const rows = process.stdout.rows || 24;
+            session.process.resize(cols, rows);
+            // Also resize the virtual terminal
+            if (session.terminal) {
+                session.terminal.resize(cols, rows);
+            }
         };
         stdout.on('resize', handleResize);
         // Set up raw input handling

package/dist/services/sessionManager.colorRestore.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/sessionManager.colorRestore.test.js

@@ -0,0 +1,142 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+import { spawn } from 'node-pty';
+// Create mock pty process
+const createMockPtyProcess = () => {
+    const handlers = {
+        data: [],
+        exit: [],
+    };
+    return {
+        write: vi.fn(),
+        resize: vi.fn(),
+        onData: vi.fn((handler) => {
+            handlers.data.push(handler);
+        }),
+        onExit: vi.fn((handler) => {
+            handlers.exit.push(handler);
+        }),
+        kill: vi.fn(),
+        _emit: (event, ...args) => {
+            if (event === 'data' && handlers.data.length > 0) {
+                handlers.data.forEach(h => h(args[0]));
+            }
+            else if (event === 'exit' && handlers.exit.length > 0) {
+                handlers.exit.forEach(h => h(args[0]));
+            }
+        },
+    };
+};
+// Mock node-pty
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
+// Don't mock @xterm/headless - let it use the real implementation
+// since we need actual terminal functionality for color testing
+describe('SessionManager - Color Restoration', () => {
+    let sessionManager;
+    const mockWorktreePath = '/test/worktree';
+    beforeEach(() => {
+        sessionManager = new SessionManager();
+        vi.clearAllMocks();
+    });
+    it('should preserve ANSI colors when switching between sessions', async () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        expect(session).toBeDefined();
+        // Simulate colorful output from Claude Code
+        const colorfulData = [
+            '\x1b[32m✓\x1b[0m File created successfully\n',
+            '\x1b[1;34mRunning tests...\x1b[0m\n',
+            '\x1b[38;5;196mError:\x1b[0m Test failed\n',
+            '\x1b[38;2;255;165;0mWarning:\x1b[0m Deprecated API\n',
+        ];
+        // Activate session first
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Send colored data to the terminal
+        for (const data of colorfulData) {
+            mockProcess._emit('data', data);
+            // Wait for terminal to process the data
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        // Deactivate session
+        sessionManager.setSessionActive(mockWorktreePath, false);
+        // Set up listener to capture restore event
+        let restoredContent = null;
+        sessionManager.on('sessionRestore', restoredSession => {
+            // In real usage, the Session component would use TerminalSerializer here
+            // For this test, we'll verify the terminal buffer contains the data
+            const terminal = restoredSession.terminal;
+            if (terminal) {
+                // Access the terminal buffer to verify colors are preserved
+                const buffer = terminal.buffer.active;
+                restoredContent = '';
+                // Simple check: verify buffer has content
+                for (let i = 0; i < buffer.length; i++) {
+                    const line = buffer.getLine(i);
+                    if (line) {
+                        // Check if line has colored cells
+                        for (let x = 0; x < terminal.cols; x++) {
+                            const cell = line.getCell(x);
+                            if (cell && cell.getChars()) {
+                                const fgColorMode = cell.getFgColorMode();
+                                const bgColorMode = cell.getBgColorMode();
+                                // If any cell has non-default color, we know colors are preserved
+                                if (fgColorMode !== 0 || bgColorMode !== 0) {
+                                    restoredContent = 'has-colors';
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // Reactivate session (simulating switching back)
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Verify that colors were preserved in the terminal buffer
+        expect(restoredContent).toBe('has-colors');
+    });
+    it('should handle complex color sequences during restoration', async () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Activate session
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Send a complex sequence with cursor movements and color changes
+        const complexSequence = [
+            'Line 1: Normal text\n',
+            '\x1b[32mLine 2: Green text\x1b[0m\n',
+            '\x1b[1A\x1b[K\x1b[31mLine 2: Now red text\x1b[0m\n', // Move up, clear line, write red
+            '\x1b[1;33mLine 3: Bold yellow\x1b[0m\n',
+            '\x1b[48;5;17m\x1b[38;5;231mWhite on dark blue background\x1b[0m\n',
+        ];
+        for (const data of complexSequence) {
+            mockProcess._emit('data', data);
+            await new Promise(resolve => setTimeout(resolve, 10));
+        }
+        // Check terminal has processed the sequences correctly
+        const terminal = session.terminal;
+        expect(terminal).toBeDefined();
+        // Verify buffer contains content (actual color verification would require
+        // checking individual cells, which is done in terminalSerializer.test.ts)
+        const buffer = terminal.buffer.active;
+        let hasContent = false;
+        for (let i = 0; i < buffer.length; i++) {
+            const line = buffer.getLine(i);
+            if (line) {
+                const text = line.translateToString(true);
+                if (text.trim()) {
+                    hasContent = true;
+                    break;
+                }
+            }
+        }
+        expect(hasContent).toBe(true);
+    });
+});

package/dist/services/sessionManager.d.ts

@@ -1,11 +1,13 @@
 import { Session, SessionManager as ISessionManager, SessionState } from '../types/index.js';
 import { EventEmitter } from 'events';
+import pkg from '@xterm/headless';
+declare const Terminal: typeof pkg.Terminal;
 export declare class SessionManager extends EventEmitter implements ISessionManager {
     sessions: Map<string, Session>;
     private waitingWithBottomBorder;
     private busyTimers;
     private stripAnsi;
-    detectSessionState(cleanData: string, currentState: SessionState, sessionId: string): SessionState;
+    detectTerminalState(terminal: InstanceType<typeof Terminal>): SessionState;
     constructor();
     createSession(worktreePath: string): Session;
     private setupBackgroundHandler;
@@ -15,3 +17,4 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     getAllSessions(): Session[];
     destroy(): void;
 }
+export {};

package/dist/services/sessionManager.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/sessionManager.integration.test.js

@@ -0,0 +1,178 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { SessionManager } from './sessionManager.js';
+import { spawn } from 'node-pty';
+// Create mock pty process
+const createMockPtyProcess = () => {
+    const handlers = {
+        data: [],
+        exit: [],
+    };
+    return {
+        write: vi.fn(),
+        resize: vi.fn(),
+        onData: vi.fn((handler) => {
+            handlers.data.push(handler);
+        }),
+        onExit: vi.fn((handler) => {
+            handlers.exit.push(handler);
+        }),
+        kill: vi.fn(),
+        _emit: (event, ...args) => {
+            if (event === 'data' && handlers.data.length > 0) {
+                handlers.data.forEach(h => h(args[0]));
+            }
+            else if (event === 'exit' && handlers.exit.length > 0) {
+                handlers.exit.forEach(h => h(args[0]));
+            }
+        },
+    };
+};
+// Mock node-pty
+vi.mock('node-pty', () => ({
+    spawn: vi.fn(),
+}));
+// Mock @xterm/headless
+vi.mock('@xterm/headless', () => ({
+    default: {
+        Terminal: vi.fn().mockImplementation(() => ({
+            buffer: {
+                active: {
+                    length: 10,
+                    cursorY: 0,
+                    cursorX: 0,
+                    getLine: vi.fn(),
+                },
+            },
+            write: vi.fn(),
+            resize: vi.fn(),
+            clear: vi.fn(),
+            onData: vi.fn(),
+        })),
+    },
+}));
+describe('SessionManager - Partial TUI Update Integration', () => {
+    let sessionManager;
+    const mockWorktreePath = '/test/worktree';
+    beforeEach(() => {
+        sessionManager = new SessionManager();
+        vi.clearAllMocks();
+    });
+    it('should not accumulate duplicate content in output history', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        // Create a session
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        expect(session).toBeDefined();
+        // Simulate multiple partial updates from Claude Code
+        const updates = [
+            '+ Exploring... (10s ・ 53 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 57 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 76 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 89 tokens ・ esc to interrupt)\r',
+            '\x1B[1A\x1B[K+ Exploring... (10s ・ 102 tokens ・ esc to interrupt)\r',
+        ];
+        // Process each update
+        updates.forEach(update => {
+            // Simulate PTY data event
+            mockProcess._emit('data', update);
+        });
+        // Check that the virtual terminal received all updates
+        expect(session.terminal.write).toHaveBeenCalledTimes(5);
+        // The outputHistory should be empty since we removed that functionality
+        expect(session.outputHistory).toEqual([]);
+    });
+    it('should use virtual terminal buffer for session restoration', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Mock the terminal buffer to contain the final state
+        // Type cast is acceptable for test mocks
+        const mockTerminal = session.terminal;
+        mockTerminal.buffer.active.getLine = vi.fn((index) => {
+            const lines = [
+                'Welcome to Claude Code',
+                '+ Exploring... (10s ・ 218 tokens ・ esc to interrupt)',
+                '',
+                'Task completed successfully',
+                '> ',
+            ];
+            if (index < lines.length) {
+                return {
+                    translateToString: () => lines[index],
+                };
+            }
+            return null;
+        });
+        mockTerminal.buffer.active.length = 5;
+        mockTerminal.buffer.active.cursorY = 4;
+        mockTerminal.buffer.active.cursorX = 2;
+        // Emit restore event
+        sessionManager.emit('sessionRestore', session);
+        // The terminal buffer should be used for restoration, not output history
+        // This prevents duplicate content issues
+        expect(session.outputHistory).toEqual([]);
+    });
+    it('should handle ANSI escape sequences correctly in virtual terminal', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Simulate data with ANSI escape sequences
+        const dataWithEscapes = [
+            'Line 1\n',
+            'Line 2\n',
+            '\x1B[1A\x1B[KReplaced Line 2\n', // Move up one line, clear line, write new text
+            '\x1B[2J\x1B[H', // Clear screen and move to home
+            'Fresh start\n',
+        ];
+        dataWithEscapes.forEach(data => {
+            mockProcess._emit('data', data);
+        });
+        // Virtual terminal should handle all the escape sequences
+        expect(session.terminal.write).toHaveBeenCalledTimes(5);
+        // No raw output should be stored
+        expect(session.outputHistory).toEqual([]);
+    });
+    it('should emit sessionData events for active sessions only', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        const dataHandler = vi.fn();
+        sessionManager.on('sessionData', dataHandler);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Session is not active by default
+        mockProcess._emit('data', 'Test data 1');
+        // Should not emit data when inactive
+        expect(dataHandler).not.toHaveBeenCalled();
+        // Activate session
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Now data should be emitted
+        mockProcess._emit('data', 'Test data 2');
+        expect(dataHandler).toHaveBeenCalledWith(session, 'Test data 2');
+    });
+    it('should restore session without replaying output history', () => {
+        // Create a mock PTY process
+        const mockProcess = createMockPtyProcess();
+        vi.mocked(spawn).mockReturnValue(mockProcess);
+        const restoreHandler = vi.fn();
+        sessionManager.on('sessionRestore', restoreHandler);
+        sessionManager.createSession(mockWorktreePath);
+        const session = sessionManager.sessions.get(mockWorktreePath);
+        // Add some data to the session
+        mockProcess._emit('data', 'Old output that should not be replayed\n');
+        mockProcess._emit('data', 'More old output\n');
+        // Deactivate then reactivate session
+        sessionManager.setSessionActive(mockWorktreePath, false);
+        sessionManager.setSessionActive(mockWorktreePath, true);
+        // Should emit restore event
+        expect(restoreHandler).toHaveBeenCalledWith(session);
+        // But should not have any output history to replay
+        expect(session.outputHistory).toEqual([]);
+    });
+});

package/dist/services/sessionManager.js

@@ -1,6 +1,7 @@
 import { spawn } from 'node-pty';
 import { EventEmitter } from 'events';
-import { includesPromptBoxBottomBorder } from '../utils/promptDetector.js';
+import pkg from '@xterm/headless';
+const { Terminal } = pkg;
 export class SessionManager extends EventEmitter {
     stripAnsi(str) {
         // Remove all ANSI escape sequences including cursor movement, color codes, etc.
@@ -16,76 +17,35 @@ export class SessionManager extends EventEmitter {
             .replace(/^[0-9;]+m/gm, '') // Orphaned color codes at line start
             .replace(/[0-9]+;[0-9]+;[0-9;]+m/g, ''); // Orphaned 24-bit color codes
     }
-    detectSessionState(cleanData, currentState, sessionId) {
-        const hasBottomBorder = includesPromptBoxBottomBorder(cleanData);
-        const hasWaitingPrompt = cleanData.includes('│ Do you want') ||
-            cleanData.includes('│ Would you like');
-        const wasWaitingWithBottomBorder = this.waitingWithBottomBorder.get(sessionId) || false;
-        const hasEscToInterrupt = cleanData
-            .toLowerCase()
-            .includes('esc to interrupt');
-        let newState = currentState;
-        // Check if current state is waiting and this is just a prompt box bottom border
-        if (hasWaitingPrompt) {
-            newState = 'waiting_input';
-            // Check if this same data also contains the bottom border
-            if (hasBottomBorder) {
-                this.waitingWithBottomBorder.set(sessionId, true);
-            }
-            else {
-                this.waitingWithBottomBorder.set(sessionId, false);
-            }
-            // Clear any pending busy timer
-            const existingTimer = this.busyTimers.get(sessionId);
-            if (existingTimer) {
-                clearTimeout(existingTimer);
-                this.busyTimers.delete(sessionId);
-            }
-        }
-        else if (currentState === 'waiting_input' &&
-            hasBottomBorder &&
-            !hasWaitingPrompt &&
-            !wasWaitingWithBottomBorder) {
-            // Keep the waiting state and mark that we've seen the bottom border
-            newState = 'waiting_input';
-            this.waitingWithBottomBorder.set(sessionId, true);
-            // Clear any pending busy timer
-            const existingTimer = this.busyTimers.get(sessionId);
-            if (existingTimer) {
-                clearTimeout(existingTimer);
-                this.busyTimers.delete(sessionId);
+    detectTerminalState(terminal) {
+        // Get the last 30 lines from the terminal buffer
+        const buffer = terminal.buffer.active;
+        const lines = [];
+        // Start from the bottom and work our way up
+        for (let i = buffer.length - 1; i >= 0 && lines.length < 30; i--) {
+            const line = buffer.getLine(i);
+            if (line) {
+                const text = line.translateToString(true);
+                // Skip empty lines at the bottom
+                if (lines.length > 0 || text.trim() !== '') {
+                    lines.unshift(text);
+                }
             }
         }
-        else if (hasEscToInterrupt) {
-            // If "esc to interrupt" is present, set state to busy
-            newState = 'busy';
-            this.waitingWithBottomBorder.set(sessionId, false);
-            // Clear any pending timer since we're confirming busy state
-            const existingTimer = this.busyTimers.get(sessionId);
-            if (existingTimer) {
-                clearTimeout(existingTimer);
-                this.busyTimers.delete(sessionId);
-            }
+        // Join lines and check for patterns
+        const content = lines.join('\n');
+        const lowerContent = content.toLowerCase();
+        // Check for waiting prompts with box character
+        if (content.includes('│ Do you want') ||
+            content.includes('│ Would you like')) {
+            return 'waiting_input';
         }
-        else if (currentState === 'busy' && !hasEscToInterrupt) {
-            // If we were busy but no "esc to interrupt" in current data,
-            // start a timer to switch to idle after 500ms
-            if (!this.busyTimers.has(sessionId)) {
-                const timer = setTimeout(() => {
-                    // sessionId is actually the worktreePath
-                    const session = this.sessions.get(sessionId);
-                    if (session && session.state === 'busy') {
-                        session.state = 'idle';
-                        this.emit('sessionStateChanged', session);
-                    }
-                    this.busyTimers.delete(sessionId);
-                }, 500);
-                this.busyTimers.set(sessionId, timer);
-            }
-            // Keep current busy state for now
-            newState = 'busy';
+        // Check for busy state
+        if (lowerContent.includes('esc to interrupt')) {
+            return 'busy';
         }
-        return newState;
+        // Otherwise idle
+        return 'idle';
     }
     constructor() {
         super();
@@ -129,15 +89,22 @@ export class SessionManager extends EventEmitter {
             cwd: worktreePath,
             env: process.env,
         });
+        // Create virtual terminal for state detection
+        const terminal = new Terminal({
+            cols: process.stdout.columns || 80,
+            rows: process.stdout.rows || 24,
+            allowProposedApi: true,
+        });
         const session = {
             id,
             worktreePath,
             process: ptyProcess,
             state: 'busy', // Session starts as busy when created
             output: [],
-            outputHistory: [],
+            outputHistory: [], // Kept for backward compatibility but no longer used
             lastActivity: new Date(),
             isActive: false,
+            terminal,
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
@@ -148,49 +115,30 @@ export class SessionManager extends EventEmitter {
     setupBackgroundHandler(session) {
         // This handler always runs for all data
         session.process.onData((data) => {
-            // Store in output history as Buffer
-            const buffer = Buffer.from(data, 'utf8');
-            session.outputHistory.push(buffer);
-            // Limit memory usage - keep max 10MB of output history
-            const MAX_HISTORY_SIZE = 10 * 1024 * 1024; // 10MB
-            let totalSize = session.outputHistory.reduce((sum, buf) => sum + buf.length, 0);
-            while (totalSize > MAX_HISTORY_SIZE && session.outputHistory.length > 0) {
-                const removed = session.outputHistory.shift();
-                if (removed) {
-                    totalSize -= removed.length;
-                }
-            }
-            // Also store for state detection
-            session.output.push(data);
-            // Keep only last 100 chunks for state detection
-            if (session.output.length > 100) {
-                session.output.shift();
-            }
+            // Write data to virtual terminal - this maintains the proper rendered state
+            session.terminal.write(data);
+            // We no longer need to maintain outputHistory since we use the virtual terminal buffer
+            // This prevents duplicate content issues and reduces memory usage
             session.lastActivity = new Date();
-            // Strip ANSI codes for pattern matching
-            const cleanData = this.stripAnsi(data);
-            // Skip state monitoring if cleanData is empty
-            if (!cleanData.trim()) {
-                // Only emit data events when session is active
-                if (session.isActive) {
-                    this.emit('sessionData', session, data);
-                }
-                return;
+            // Only emit data events when session is active
+            if (session.isActive) {
+                this.emit('sessionData', session, data);
             }
-            // Detect state based on the new data
+        });
+        // Set up interval-based state detection
+        session.stateCheckInterval = setInterval(() => {
             const oldState = session.state;
-            const newState = this.detectSessionState(cleanData, oldState, session.worktreePath);
-            // Update state if changed
+            const newState = this.detectTerminalState(session.terminal);
             if (newState !== oldState) {
                 session.state = newState;
                 this.emit('sessionStateChanged', session);
             }
-            // Only emit data events when session is active
-            if (session.isActive) {
-                this.emit('sessionData', session, data);
-            }
-        });
+        }, 100); // Check every 100ms
         session.process.onExit(() => {
+            // Clear the state check interval
+            if (session.stateCheckInterval) {
+                clearInterval(session.stateCheckInterval);
+            }
             // Update state to idle before destroying
             session.state = 'idle';
             this.emit('sessionStateChanged', session);
@@ -205,8 +153,9 @@ export class SessionManager extends EventEmitter {
         const session = this.sessions.get(worktreePath);
         if (session) {
             session.isActive = active;
-            // If becoming active, emit a restore event with the output history
-            if (active && session.outputHistory.length > 0) {
+            // If becoming active, emit a restore event
+            // The Session component will use the virtual terminal buffer instead of outputHistory
+            if (active) {
                 this.emit('sessionRestore', session);
             }
         }
@@ -214,6 +163,10 @@ export class SessionManager extends EventEmitter {
     destroySession(worktreePath) {
         const session = this.sessions.get(worktreePath);
         if (session) {
+            // Clear the state check interval
+            if (session.stateCheckInterval) {
+                clearInterval(session.stateCheckInterval);
+            }
             try {
                 session.process.kill();
             }