ccmanager 4.0.3 → 4.1.0

package/dist/components/Confirmation.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { Key } from 'ink';
 export interface ConfirmationOption {
     label: string;
     value: string;
@@ -14,9 +15,7 @@ interface ConfirmationProps {
     hint?: React.ReactNode;
     onCancel?: () => void;
     onEscape?: () => void;
-    onCustomInput?: (input: string, key: {
-        [key: string]: boolean;
-    }) => boolean;
+    onCustomInput?: (input: string, key: Key) => boolean;
 }
 /**
  * Reusable confirmation component with SelectInput UI pattern

package/dist/components/PresetSelector.test.js

@@ -60,6 +60,10 @@ const makeKey = (overrides = {}) => ({
     backspace: false,
     delete: false,
     meta: false,
+    super: false,
+    hyper: false,
+    capsLock: false,
+    numLock: false,
     ...overrides,
 });
 describe('PresetSelector component', () => {

package/dist/components/Session.js

@@ -65,23 +65,11 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         stdout.write('\x1b[?7l');
         // Clear screen when entering session
         stdout.write('\x1B[2J\x1B[H');
-        // Handle session restoration by writing all buffered output at once.
-        // This is faster than chunk-by-chunk replay and preserves scrollback.
-        const handleSessionRestore = (restoredSession) => {
+        // Restore the current terminal state from the headless xterm snapshot.
+        const handleSessionRestore = (restoredSession, restoreSnapshot) => {
             if (restoredSession.id === session.id) {
-                if (restoredSession.outputHistory.length === 0)
-                    return;
-                // Concatenate all history buffers and write at once for better performance
-                const allHistory = Buffer.concat(restoredSession.outputHistory);
-                const historyStr = allHistory.toString('utf8');
-                // Normalize the output
-                const normalized = normalizeLineEndings(historyStr);
-                // Remove leading clear screen sequences to avoid double-clear
-                const cleaned = normalized
-                    .replace(/^\x1B\[2J/g, '')
-                    .replace(/^\x1B\[H/g, '');
-                if (cleaned.length > 0) {
-                    stdout.write(cleaned);
+                if (restoreSnapshot.length > 0) {
+                    stdout.write(restoreSnapshot);
                 }
             }
         };
@@ -102,8 +90,6 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         };
         sessionManager.on('sessionData', handleSessionData);
         sessionManager.on('sessionExit', handleSessionExit);
-        // Mark session as active (this will trigger the restore event)
-        sessionManager.setSessionActive(session.id, true);
         // Immediately resize the PTY and terminal to current dimensions
         // This fixes rendering issues when terminal width changed while in menu
         // https://github.com/kbwo/ccmanager/issues/2
@@ -120,6 +106,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         catch {
             /* empty */
         }
+        // Mark session as active after resizing so the restore snapshot matches
+        // the current terminal dimensions.
+        sessionManager.setSessionActive(session.id, true);
         // Handle terminal resize
         const handleResize = () => {
             const cols = process.stdout.columns || 80;

package/dist/components/Session.test.d.ts

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

package/dist/components/Session.test.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { EventEmitter } from 'events';
+const testState = vi.hoisted(() => ({
+    stdout: null,
+}));
+class MockStdout extends EventEmitter {
+    write = vi.fn();
+}
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useStdout: vi.fn(() => ({ stdout: testState.stdout })),
+    };
+});
+import Session from './Session.js';
+describe('Session', () => {
+    const originalColumns = process.stdout.columns;
+    const originalRows = process.stdout.rows;
+    const originalIsTTY = process.stdin.isTTY;
+    beforeEach(() => {
+        testState.stdout = new MockStdout();
+        Object.defineProperty(process.stdout, 'columns', {
+            value: 120,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdout, 'rows', {
+            value: 40,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: false,
+            configurable: true,
+        });
+    });
+    afterEach(() => {
+        testState.stdout = null;
+        Object.defineProperty(process.stdout, 'columns', {
+            value: originalColumns,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdout, 'rows', {
+            value: originalRows,
+            configurable: true,
+        });
+        Object.defineProperty(process.stdin, 'isTTY', {
+            value: originalIsTTY,
+            configurable: true,
+        });
+        vi.restoreAllMocks();
+    });
+    it('resizes before activating and writes restore snapshots verbatim', async () => {
+        const listeners = new Map();
+        const processResize = vi.fn();
+        const processWrite = vi.fn();
+        const terminalResize = vi.fn();
+        const setSessionActive = vi.fn((sessionId, active) => {
+            if (sessionId === session.id && active) {
+                for (const handler of listeners.get('sessionRestore') ?? []) {
+                    handler(session, '\nrestored');
+                }
+            }
+        });
+        const session = {
+            id: 'session-1',
+            process: {
+                write: processWrite,
+                resize: processResize,
+            },
+            terminal: {
+                resize: terminalResize,
+            },
+            stateMutex: {
+                getSnapshot: () => ({ state: 'idle' }),
+            },
+        };
+        const sessionManager = {
+            on: vi.fn((event, handler) => {
+                const handlers = listeners.get(event) ?? new Set();
+                handlers.add(handler);
+                listeners.set(event, handlers);
+                return sessionManager;
+            }),
+            off: vi.fn((event, handler) => {
+                listeners.get(event)?.delete(handler);
+                return sessionManager;
+            }),
+            setSessionActive,
+            cancelAutoApproval: vi.fn(),
+        };
+        render(_jsx(Session, { session: session, sessionManager: sessionManager, onReturnToMenu: vi.fn() }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(processResize).toHaveBeenCalledWith(120, 40);
+        expect(terminalResize).toHaveBeenCalledWith(120, 40);
+        expect(processResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
+        expect(terminalResize.mock.invocationCallOrder[0] ?? 0).toBeLessThan(setSessionActive.mock.invocationCallOrder[0] ?? 0);
+        expect(testState.stdout?.write).toHaveBeenNthCalledWith(3, '\nrestored');
+    });
+});

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

@@ -52,16 +52,31 @@ vi.mock('./config/configReader.js', () => ({
         setAutoApprovalEnabled: vi.fn(),
     },
 }));
+vi.mock('@xterm/addon-serialize', () => ({
+    SerializeAddon: vi.fn().mockImplementation(function () {
+        return {
+            serialize: vi.fn(() => ''),
+            activate: vi.fn(),
+            dispose: vi.fn(),
+        };
+    }),
+}));
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
             return {
+                rows: 24,
+                cols: 80,
                 buffer: {
                     active: {
+                        type: 'normal',
+                        baseY: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },
                 },
+                loadAddon: vi.fn(),
+                resize: vi.fn(),
                 write: vi.fn(),
             };
         }),

package/dist/services/sessionManager.d.ts

@@ -35,6 +35,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private updateSessionState;
     constructor();
     private createTerminal;
+    private getRestoreSnapshot;
     private createSessionInternal;
     /**
      * Create session with command preset using Effect-based error handling
@@ -59,9 +60,8 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     /**
      * Sets up exit handler for the session process.
      * When the process exits with code 1 and it's the primary command,
-     * it will attempt to spawn a fallback process.
-     * If fallbackArgs are configured, they will be used.
-     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     * it will attempt a single retry using the configured command with fallback args.
+     * If fallbackArgs are not configured, it retries the configured command with no args.
      */
     private setupExitHandler;
     private setupBackgroundHandler;

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

@@ -33,17 +33,32 @@ vi.mock('./config/configReader.js', () => ({
         getStatusHooks: vi.fn(() => ({})),
     },
 }));
+vi.mock('@xterm/addon-serialize', () => ({
+    SerializeAddon: vi.fn().mockImplementation(function () {
+        return {
+            serialize: vi.fn(() => ''),
+            activate: vi.fn(),
+            dispose: vi.fn(),
+        };
+    }),
+}));
 // Mock Terminal
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
             return {
+                rows: 24,
+                cols: 80,
                 buffer: {
                     active: {
+                        type: 'normal',
+                        baseY: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },
                 },
+                loadAddon: vi.fn(),
+                resize: vi.fn(),
                 write: vi.fn(),
             };
         }),

package/dist/services/sessionManager.js

@@ -1,6 +1,7 @@
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
+import { SerializeAddon } from '@xterm/addon-serialize';
 import { spawn as childSpawn } from 'child_process';
 import { configReader } from './config/configReader.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
@@ -17,6 +18,7 @@ import { injectTeammateMode } from '../utils/commandArgs.js';
 import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
+const TERMINAL_SCROLLBACK_LINES = 5000;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
@@ -192,14 +194,22 @@ export class SessionManager extends EventEmitter {
         return new Terminal({
             cols: process.stdout.columns || 80,
             rows: process.stdout.rows || 24,
+            scrollback: TERMINAL_SCROLLBACK_LINES,
             allowProposedApi: true,
             logLevel: 'off',
         });
     }
+    getRestoreSnapshot(session) {
+        return session.serializer.serialize({
+            scrollback: TERMINAL_SCROLLBACK_LINES,
+        });
+    }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
         const maxNumber = existingSessions.reduce((max, s) => Math.max(max, s.sessionNumber), 0);
         const terminal = this.createTerminal();
+        const serializer = new SerializeAddon();
+        terminal.loadAddon(serializer);
         const detectionStrategy = options.detectionStrategy ?? 'claude';
         const stateDetector = createStateDetector(detectionStrategy);
         const session = {
@@ -207,13 +217,15 @@ export class SessionManager extends EventEmitter {
             worktreePath,
             sessionNumber: maxNumber + 1,
             sessionName: undefined,
+            command: options.command ?? 'claude',
+            fallbackArgs: options.fallbackArgs,
             lastAccessedAt: Date.now(),
             process: ptyProcess,
             output: [],
-            outputHistory: [],
             lastActivity: new Date(),
             isActive: false,
             terminal,
+            serializer,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             presetName: options.presetName,
@@ -257,6 +269,8 @@ export class SessionManager extends EventEmitter {
                 const ptyProcess = await this.spawn(command, args, worktreePath);
                 const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
+                    command,
+                    fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
                     detectionStrategy: preset.detectionStrategy,
                 });
@@ -287,24 +301,6 @@ export class SessionManager extends EventEmitter {
         session.process.onData((data) => {
             // Write data to virtual terminal
             session.terminal.write(data);
-            // Check for screen clear escape sequence (e.g., from /clear command)
-            // When detected, clear the output history to prevent replaying old content on restore
-            // This helps avoid excessive scrolling when restoring sessions with large output history
-            if (data.includes('\x1B[2J')) {
-                session.outputHistory = [];
-            }
-            // 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;
-                }
-            }
             session.lastActivity = new Date();
             // Only emit data events when session is active
             if (session.isActive) {
@@ -315,9 +311,8 @@ export class SessionManager extends EventEmitter {
     /**
      * Sets up exit handler for the session process.
      * When the process exits with code 1 and it's the primary command,
-     * it will attempt to spawn a fallback process.
-     * If fallbackArgs are configured, they will be used.
-     * If no fallbackArgs are configured, the command will be retried with no arguments.
+     * it will attempt a single retry using the configured command with fallback args.
+     * If fallbackArgs are not configured, it retries the configured command with no args.
      */
     setupExitHandler(session) {
         session.process.onExit(async (e) => {
@@ -325,26 +320,23 @@ export class SessionManager extends EventEmitter {
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
                     let fallbackProcess;
+                    const fallbackArgs = injectTeammateMode(session.command, session.fallbackArgs ?? [], session.detectionStrategy);
                     // Check if we're in a devcontainer session
                     if (session.devcontainerConfig) {
                         // Parse the exec command to extract arguments
                         const execParts = session.devcontainerConfig.execCommand.split(/\s+/);
                         const devcontainerCmd = execParts[0] || 'devcontainer';
                         const execArgs = execParts.slice(1);
-                        // Build fallback command for devcontainer
-                        const fallbackClaudeArgs = injectTeammateMode('claude', [], session.detectionStrategy);
                         const fallbackFullArgs = [
                             ...execArgs,
                             '--',
-                            'claude',
-                            ...fallbackClaudeArgs,
+                            session.command,
+                            ...fallbackArgs,
                         ];
                         fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath, { rawMode: false });
                     }
                     else {
-                        // Regular fallback without devcontainer
-                        const fallbackArgs = injectTeammateMode('claude', [], session.detectionStrategy);
-                        fallbackProcess = await this.spawn('claude', fallbackArgs, session.worktreePath);
+                        fallbackProcess = await this.spawn(session.command, fallbackArgs, session.worktreePath);
                     }
                     // Replace the process
                     session.process = fallbackProcess;
@@ -479,9 +471,9 @@ export class SessionManager extends EventEmitter {
             session.isActive = active;
             if (active) {
                 session.lastAccessedAt = Date.now();
-                // Emit a restore event with the output history if available
-                if (session.outputHistory.length > 0) {
-                    this.emit('sessionRestore', session);
+                const restoreSnapshot = this.getRestoreSnapshot(session);
+                if (restoreSnapshot.length > 0) {
+                    this.emit('sessionRestore', session, restoreSnapshot);
                 }
             }
         }
@@ -691,6 +683,8 @@ export class SessionManager extends EventEmitter {
                 const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath, { rawMode: false });
                 const session = await this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
+                    command: preset.command,
+                    fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,

package/dist/services/sessionManager.test.js

@@ -37,19 +37,38 @@ vi.mock('./config/configReader.js', () => ({
         setAutoApprovalEnabled: vi.fn(),
     },
 }));
+vi.mock('@xterm/addon-serialize', () => ({
+    SerializeAddon: vi.fn().mockImplementation(function () {
+        return {
+            serialize: vi.fn(() => ''),
+            activate: vi.fn(),
+            dispose: vi.fn(),
+        };
+    }),
+}));
 // Mock Terminal
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn(function () {
             return {
+                rows: 24,
+                cols: 80,
                 buffer: {
                     active: {
+                        type: 'normal',
+                        baseY: 0,
                         length: 0,
                         getLine: vi.fn(function () {
                             return null;
                         }),
                     },
                 },
+                loadAddon: vi.fn(function () {
+                    return undefined;
+                }),
+                resize: vi.fn(function () {
+                    return undefined;
+                }),
                 write: vi.fn(function () {
                     return undefined;
                 }),
@@ -238,13 +257,14 @@ describe('SessionManager', () => {
             // Expect createSessionWithPresetEffect to throw the original error
             await expect(Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'))).rejects.toThrow('Command not found');
         });
-        it('should fallback to default command when main command exits with code 1', async () => {
+        it('should retry the configured command with fallback args when main command exits with code 1', async () => {
             // Setup mock preset with args
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
                 args: ['--invalid-flag'],
+                fallbackArgs: ['--safe-flag'],
             });
             // First spawn attempt - will exit with code 1
             const firstMockPty = new MockPty();
@@ -262,11 +282,13 @@ describe('SessionManager', () => {
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called (with no args since commandConfig was removed)
+            // Verify fallback spawn was called with the configured fallback args
             expect(spawn).toHaveBeenCalledTimes(2);
-            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--safe-flag', '--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
+            expect(session.command).toBe('claude');
+            expect(session.fallbackArgs).toEqual(['--safe-flag']);
             expect(session.isPrimaryCommand).toBe(false);
         });
         it('should not use fallback if main command succeeds', async () => {
@@ -318,8 +340,37 @@ describe('SessionManager', () => {
             expect(spawn).toHaveBeenNthCalledWith(2, 'claude', ['--teammate-mode', 'in-process'], expect.objectContaining({ cwd: '/test/worktree' }));
             // Verify session process was replaced
             expect(session.process).toBe(secondMockPty);
+            expect(session.command).toBe('claude');
+            expect(session.fallbackArgs).toBeUndefined();
             expect(session.isPrimaryCommand).toBe(false);
         });
+        it('should cleanup and emit exit when fallback command also exits with code 1', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'opencode',
+                args: ['run', '--bad-flag'],
+                fallbackArgs: ['run', '--safe-mode'],
+                detectionStrategy: 'opencode',
+            });
+            const firstMockPty = new MockPty();
+            const secondMockPty = new MockPty();
+            let exitedSession = null;
+            vi.mocked(spawn)
+                .mockReturnValueOnce(firstMockPty)
+                .mockReturnValueOnce(secondMockPty);
+            sessionManager.on('sessionExit', (session) => {
+                exitedSession = session;
+            });
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            firstMockPty.emit('exit', { exitCode: 1 });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            secondMockPty.emit('exit', { exitCode: 1 });
+            await new Promise(resolve => setTimeout(resolve, 50));
+            expect(spawn).toHaveBeenNthCalledWith(2, 'opencode', ['run', '--safe-mode'], expect.objectContaining({ cwd: '/test/worktree' }));
+            expect(exitedSession).toBe(session);
+            expect(sessionManager.getSessionsForWorktree('/test/worktree')).toHaveLength(0);
+        });
         it('should handle custom command configuration', async () => {
             // Setup mock preset with custom command
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -655,13 +706,14 @@ describe('SessionManager', () => {
             expect(session.process).toBe(secondMockPty);
             expect(session.isPrimaryCommand).toBe(false);
         });
-        it('should fallback to default command in devcontainer when primary command exits with code 1', async () => {
+        it('should retry the configured command with fallback args in devcontainer when primary command exits with code 1', async () => {
             // Setup preset with args
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
                 args: ['--bad-flag'],
+                fallbackArgs: ['--safe-flag'],
             });
             // First spawn attempt - will exit with code 1
             const firstMockPty = new MockPty();
@@ -690,7 +742,7 @@ describe('SessionManager', () => {
             firstMockPty.emit('exit', { exitCode: 1 });
             // Wait for fallback to occur
             await new Promise(resolve => setTimeout(resolve, 50));
-            // Verify fallback spawn was called with teammate-mode args
+            // Verify fallback spawn was called with the configured fallback args
             expect(spawn).toHaveBeenCalledTimes(2);
             expect(spawn).toHaveBeenNthCalledWith(2, 'devcontainer', [
                 'exec',
@@ -698,6 +750,7 @@ describe('SessionManager', () => {
                 '.',
                 '--',
                 'claude',
+                '--safe-flag',
                 '--teammate-mode',
                 'in-process',
             ], expect.objectContaining({ cwd: '/test/worktree', rawMode: false }));
@@ -706,63 +759,37 @@ describe('SessionManager', () => {
             expect(session.isPrimaryCommand).toBe(false);
         });
     });
-    describe('clearHistoryOnClear', () => {
-        it('should clear output history when screen clear escape sequence is detected', async () => {
-            // Setup
+    describe('session restore snapshots', () => {
+        it('should emit serialized terminal output when activating a session', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Simulate some data output
-            mockPty.emit('data', 'Hello World');
-            mockPty.emit('data', 'More data');
-            // Verify output history has data
-            expect(session.outputHistory.length).toBe(2);
-            // Simulate screen clear escape sequence
-            mockPty.emit('data', '\x1B[2J');
-            // Verify output history was cleared and only contains the clear sequence
-            expect(session.outputHistory.length).toBe(1);
-            expect(session.outputHistory[0]?.toString()).toBe('\x1B[2J');
-        });
-        it('should not clear output history for normal data', async () => {
-            // Setup
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('\u001b[31mrestored\u001b[0m');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
+            expect(serializeMock).toHaveBeenCalledWith({ scrollback: 5000 });
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m');
+        });
+        it('should skip restore event when serialized output is empty', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
-            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Simulate normal data output without screen clear
-            mockPty.emit('data', 'Hello World');
-            mockPty.emit('data', 'More data');
-            mockPty.emit('data', 'Even more data');
-            // Verify output history contains all data
-            expect(session.outputHistory.length).toBe(3);
-        });
-        it('should clear history when screen clear is part of larger data chunk', async () => {
-            // Setup
-            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                id: '1',
-                name: 'Main',
-                command: 'claude',
-            });
-            vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Simulate some data output
-            mockPty.emit('data', 'Hello World');
-            mockPty.emit('data', 'More data');
-            // Simulate screen clear as part of larger data chunk (e.g., from /clear command)
-            mockPty.emit('data', 'prefix\x1B[2Jsuffix');
-            // Verify output history was cleared and only contains the new chunk
-            expect(session.outputHistory.length).toBe(1);
-            expect(session.outputHistory[0]?.toString()).toBe('prefix\x1B[2Jsuffix');
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
+            expect(restoreHandler).not.toHaveBeenCalled();
         });
     });
     describe('static methods', () => {

package/dist/services/stateDetector/cursor.js

@@ -13,7 +13,11 @@ export class CursorStateDetector extends BaseStateDetector {
             /auto .* \(shift\+tab\)/.test(lowerContent) ||
             /allow .+ \(y\)/.test(lowerContent) ||
             /run .+ \(y\)/.test(lowerContent) ||
-            lowerContent.includes('skip (esc or n)')) {
+            lowerContent.includes('skip (esc or n)') ||
+            lowerContent.includes('write to this file?') ||
+            lowerContent.includes('reject & propose changes') ||
+            (lowerContent.includes('add write(') &&
+                lowerContent.includes('allowlist'))) {
             return 'waiting_input';
         }
         // Check for busy state - Priority 2

package/dist/services/stateDetector/cursor.test.js

@@ -114,6 +114,21 @@ describe('CursorStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input state for Write to this file? prompt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            ' │ Write to this file?                                                                                                                                                                                                                                                                                                                                                                  │',
+            ' │ in /Users/kbwo/go/projects/github.com/kbwo/ccmanager--feature-takt/src/services/stateDetector/takt.ts                                                                                                                                                                                                                                                                                │',
+            ' │  → Proceed (y)                                                                                                                                                                                                                                                                                                                                                                       │',
+            ' │    Reject & propose changes (esc or n or p)                                                                                                                                                                                                                                                                                                                                          │',
+            ' │    Add Write(/Users/.../takt.ts) to allowlist? (tab)                                                                                                                                                                                                                                                                                                                                 │',
+            ' │    Run Everything (shift+tab)                                                                                                                                                                                                                                                                                                                                                        │',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
     it('should detect busy state for ctrl+c to stop pattern', () => {
         // Arrange
         terminal = createMockTerminal([

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 import type { IPty } from '../services/bunTerminal.js';
 import type pkg from '@xterm/headless';
+import type { SerializeAddon } from '@xterm/addon-serialize';
 import { GitStatus } from '../utils/gitStatus.js';
 import { Mutex, SessionStateData } from '../utils/mutex.js';
 import type { StateDetector } from '../services/stateDetector/types.js';
@@ -20,13 +21,15 @@ export interface Session {
     worktreePath: string;
     sessionNumber: number;
     sessionName?: string;
+    command: string;
+    fallbackArgs?: string[];
     lastAccessedAt: number;
     process: IPty;
     output: string[];
-    outputHistory: Buffer[];
     lastActivity: Date;
     isActive: boolean;
     terminal: Terminal;
+    serializer: SerializeAddon;
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
     presetName: string | undefined;

package/dist/utils/hookExecutor.test.js

@@ -377,11 +377,13 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-123',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
@@ -434,11 +436,13 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-456',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
@@ -489,11 +493,13 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-789',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
@@ -546,11 +552,13 @@ describe('hookExecutor Integration Tests', () => {
                 id: 'test-session-failure',
                 worktreePath: tmpDir,
                 sessionNumber: 1,
+                command: 'claude',
+                fallbackArgs: undefined,
                 lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
+                serializer: {},
                 output: [],
-                outputHistory: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,

package/dist/utils/worktreeUtils.test.js

@@ -124,13 +124,15 @@ describe('prepareSessionItems', () => {
         id: 'test-session',
         worktreePath: '/path/to/worktree',
         sessionNumber: 1,
+        command: 'claude',
+        fallbackArgs: undefined,
         lastAccessedAt: Date.now(),
         process: {},
         output: [],
-        outputHistory: [],
         lastActivity: new Date(),
         isActive: true,
         terminal: {},
+        serializer: {},
         stateCheckInterval: undefined,
         isPrimaryCommand: true,
         presetName: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.0.3",
+	"version": "4.1.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "4.0.3",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.0.3",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.0.3",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.0.3",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.0.3"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.0",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.0",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.0",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.0",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",
@@ -68,6 +68,7 @@
 	},
 	"prettier": "@vdemedes/prettier-config",
 	"dependencies": {
+		"@xterm/addon-serialize": "^0.14.0",
 		"@xterm/headless": "^6.0.0",
 		"effect": "^3.18.2",
 		"ink": "^6.6.0",