ccmanager 4.1.6 → 4.1.8

package/dist/components/ConfigureWorktree.js

@@ -16,6 +16,7 @@ const ConfigureWorktree = ({ onComplete }) => {
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
     const [sortByLastSession, setSortByLastSession] = useState(worktreeConfig.sortByLastSession ?? false);
     const [autoUseDefaultBranch, setAutoUseDefaultBranch] = useState(worktreeConfig.autoUseDefaultBranch ?? false);
+    const [includeRemoteBranches, setIncludeRemoteBranches] = useState(worktreeConfig.includeRemoteBranches ?? false);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
     // Show if inheriting from global (for project scope)
@@ -50,6 +51,10 @@ const ConfigureWorktree = ({ onComplete }) => {
             label: `Auto Use Default Branch: ${autoUseDefaultBranch ? '✅ Enabled' : '❌ Disabled'}`,
             value: 'toggleAutoUseDefault',
         },
+        {
+            label: `Include Remote Branches: ${includeRemoteBranches ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleIncludeRemote',
+        },
         {
             label: '💾 Save Changes',
             value: 'save',
@@ -77,6 +82,9 @@ const ConfigureWorktree = ({ onComplete }) => {
             case 'toggleAutoUseDefault':
                 setAutoUseDefaultBranch(!autoUseDefaultBranch);
                 break;
+            case 'toggleIncludeRemote':
+                setIncludeRemoteBranches(!includeRemoteBranches);
+                break;
             case 'save':
                 // Save the configuration
                 configEditor.setWorktreeConfig({
@@ -85,6 +93,7 @@ const ConfigureWorktree = ({ onComplete }) => {
                     copySessionData,
                     sortByLastSession,
                     autoUseDefaultBranch,
+                    includeRemoteBranches,
                 });
                 onComplete();
                 break;

package/dist/components/NewWorktree.js

@@ -8,6 +8,7 @@ import { configReader } from '../services/config/configReader.js';
 import { generateWorktreeDirectory } from '../utils/worktreeUtils.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
+import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
 import SearchableList from './SearchableList.js';
 import { Effect } from 'effect';
 import { describePromptInjection, getPromptInjectionMethod, } from '../utils/presetPrompt.js';
@@ -16,7 +17,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const presetsConfig = configReader.getCommandPresets();
     const isAutoDirectory = worktreeConfig.autoDirectory;
     const isAutoUseDefaultBranch = worktreeConfig.autoUseDefaultBranch ?? false;
-    const limit = 10;
+    const includeRemoteBranches = worktreeConfig.includeRemoteBranches ?? false;
     const getInitialStep = () => {
         if (isAutoDirectory) {
             return 'base-branch';
@@ -34,20 +35,28 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const [isLoadingBranches, setIsLoadingBranches] = useState(true);
     const [branchLoadError, setBranchLoadError] = useState(null);
     const [branches, setBranches] = useState([]);
+    const [remoteBranches, setRemoteBranches] = useState([]);
     const [defaultBranch, setDefaultBranch] = useState('main');
     useEffect(() => {
         let cancelled = false;
         const service = new WorktreeService(projectPath);
         const loadBranches = async () => {
-            const workflow = Effect.all([service.getAllBranchesEffect(), service.getDefaultBranchEffect()], { concurrency: 2 });
+            const branchesEffect = includeRemoteBranches
+                ? service.getBranchesWithRemotesEffect()
+                : Effect.map(service.getAllBranchesEffect(), (list) => ({
+                    local: list,
+                    remote: [],
+                }));
+            const workflow = Effect.all([branchesEffect, service.getDefaultBranchEffect()], { concurrency: 2 });
             const result = await Effect.runPromise(Effect.match(workflow, {
                 onFailure: (error) => ({
                     type: 'error',
                     message: formatError(error),
                 }),
-                onSuccess: ([branchList, defaultBr]) => ({
+                onSuccess: ([branchData, defaultBr]) => ({
                     type: 'success',
-                    branches: branchList,
+                    local: branchData.local,
+                    remote: branchData.remote,
                     defaultBranch: defaultBr,
                 }),
             }));
@@ -57,7 +66,8 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
                     setIsLoadingBranches(false);
                 }
                 else {
-                    setBranches(result.branches);
+                    setBranches(result.local);
+                    setRemoteBranches(result.remote);
                     setDefaultBranch(result.defaultBranch);
                     setIsLoadingBranches(false);
                     if (isAutoUseDefaultBranch && result.defaultBranch) {
@@ -76,16 +86,31 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
         return () => {
             cancelled = true;
         };
-    }, [projectPath, isAutoUseDefaultBranch]);
-    const allBranchItems = useMemo(() => [
-        { label: `${defaultBranch} (default)`, value: defaultBranch },
-        ...branches
-            .filter(br => br !== defaultBranch)
-            .map(br => ({ label: br, value: br })),
-    ], [branches, defaultBranch]);
+    }, [projectPath, isAutoUseDefaultBranch, includeRemoteBranches]);
+    const allBranchItems = useMemo(() => {
+        const defaultRemoteSuffix = `/${defaultBranch}`;
+        const defaultRemotes = remoteBranches.filter(br => br.endsWith(defaultRemoteSuffix));
+        const otherRemotes = remoteBranches.filter(br => !br.endsWith(defaultRemoteSuffix));
+        return [
+            { label: `${defaultBranch} (default)`, value: defaultBranch },
+            ...defaultRemotes.map(br => ({
+                label: `${br} (default remote)`,
+                value: br,
+            })),
+            ...branches
+                .filter(br => br !== defaultBranch)
+                .map(br => ({ label: br, value: br })),
+            ...otherRemotes.map(br => ({ label: br, value: br })),
+        ];
+    }, [branches, remoteBranches, defaultBranch]);
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(allBranchItems.length, {
         isDisabled: step !== 'base-branch',
     });
+    const limit = useDynamicLimit({
+        fixedRows: includeRemoteBranches ? 10 : 8,
+        isSearchMode,
+        hasError: !!branchLoadError,
+    });
     const branchItems = useMemo(() => {
         if (!searchQuery)
             return allBranchItems;
@@ -239,7 +264,7 @@ const NewWorktree = ({ projectPath, onComplete, onCancel, }) => {
     const promptMethod = selectedPreset
         ? getPromptInjectionMethod(selectedPreset)
         : 'stdin';
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Tip: Enable "Auto Directory" in settings to generate paths automatically from branch names.' }) })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: branchItems, limit: limit, placeholder: "Type to filter branches...", noMatchMessage: "No branches match your search", children: _jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode }) }), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "green", children: "Create New Worktree" }) }), step === 'path' && !isAutoDirectory ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Enter worktree path (relative to repository root):" }) }), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(TextInputWrapper, { value: path, onChange: setPath, onSubmit: handlePathSubmit, placeholder: "e.g., ../myproject-feature" })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Tip: Enable "Auto Directory" in settings to generate paths automatically from branch names.' }) })] })) : null, step === 'base-branch' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "Select base branch for the worktree:" }) }), _jsx(SearchableList, { isSearchMode: isSearchMode, searchQuery: searchQuery, onSearchQueryChange: setSearchQuery, selectedIndex: selectedIndex, items: branchItems, limit: limit, placeholder: "Type to filter branches...", noMatchMessage: "No branches match your search", children: _jsx(SelectInput, { items: branchItems, onSelect: handleBaseBranchSelect, initialIndex: selectedIndex, limit: limit, isFocused: !isSearchMode }) }), !isSearchMode && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press / to search" }) })), includeRemoteBranches && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Tip: If the branch list feels slow, disable \"Include Remote Branches\" in Configuration \u2192 Configure Worktree Settings." }) }))] })), step === 'creation-mode' && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { children: ["Base branch: ", _jsx(Text, { color: "cyan", children: baseBranch })] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: "How do you want to create the new worktree?" }) }), _jsx(SelectInput, { items: [
                             {
                                 label: '1. Choose the branch name yourself',
                                 value: 'manual',

package/dist/components/Session.js

@@ -65,9 +65,9 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
         stdout.write('\x1B[2J\x1B[H');
         // Restore the current terminal state from the headless xterm snapshot.
         // The xterm serialize addon relies on auto-wrap (DECAWM) being enabled to
-        // render wrapped lines — it omits row separators for wrapped rows, expecting
-        // characters to naturally overflow to the next line.  We therefore keep
-        // auto-wrap enabled while writing the snapshot and only disable it afterward.
+        // render wrapped lines. It omits row separators for wrapped rows and expects
+        // characters to naturally overflow to the next line, so auto-wrap must stay
+        // enabled while writing the snapshot and only be disabled afterward.
         const handleSessionRestore = (restoredSession, restoreSnapshot) => {
             if (restoredSession.id === session.id) {
                 if (restoreSnapshot.length > 0) {
@@ -109,15 +109,12 @@ const Session = ({ session, sessionManager, onReturnToMenu, }) => {
             /* empty */
         }
         // Mark session as active after resizing so the restore snapshot matches
-        // the current terminal dimensions.  setSessionActive synchronously emits
-        // the 'sessionRestore' event, so the snapshot is written to stdout before
-        // we proceed.
+        // the current terminal dimensions. setSessionActive synchronously emits the
+        // restore event, so the snapshot is written to stdout before we proceed.
         sessionManager.setSessionActive(session.id, true);
         // Prevent line wrapping from drifting redraws in TUIs that rely on
-        // cursor-up clears.  This MUST come after the restore snapshot write
-        // because the xterm serialize addon relies on auto-wrap (DECAWM) being
-        // enabled — it omits row separators for wrapped rows, expecting characters
-        // to naturally overflow to the next line.
+        // cursor-up clears. This must happen after the restore snapshot write,
+        // otherwise wrapped restore content can overlap on the same row.
         stdout.write('\x1b[?7l');
         // Handle terminal resize
         const handleResize = () => {

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

@@ -69,13 +69,25 @@ vi.mock('@xterm/addon-serialize', () => ({
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
+            const normalBuffer = {
+                type: 'normal',
+                baseY: 0,
+                cursorY: 0,
+                cursorX: 0,
+                length: 0,
+                getLine: vi.fn(),
+            };
             return {
                 rows: 24,
                 cols: 80,
                 buffer: {
-                    active: {
-                        type: 'normal',
+                    active: normalBuffer,
+                    normal: normalBuffer,
+                    alternate: {
+                        type: 'alternate',
                         baseY: 0,
+                        cursorY: 0,
+                        cursorX: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },

package/dist/services/sessionManager.d.ts

@@ -16,6 +16,8 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private waitingWithBottomBorder;
     private busyTimers;
     private autoApprovalDisabledWorktrees;
+    private restoringSessions;
+    private bufferedRestoreData;
     private spawn;
     private resolvePreset;
     detectTerminalState(session: Session): SessionState;
@@ -35,6 +37,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private updateSessionState;
     constructor();
     private createTerminal;
+    private shouldResetRestoreScrollback;
     private getRestoreSnapshot;
     private createSessionInternal;
     /**

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

@@ -46,13 +46,25 @@ vi.mock('@xterm/addon-serialize', () => ({
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn().mockImplementation(function () {
+            const normalBuffer = {
+                type: 'normal',
+                baseY: 0,
+                cursorY: 0,
+                cursorX: 0,
+                length: 0,
+                getLine: vi.fn(),
+            };
             return {
                 rows: 24,
                 cols: 80,
                 buffer: {
-                    active: {
-                        type: 'normal',
+                    active: normalBuffer,
+                    normal: normalBuffer,
+                    alternate: {
+                        type: 'alternate',
                         baseY: 0,
+                        cursorY: 0,
+                        cursorX: 0,
                         length: 0,
                         getLine: vi.fn(),
                     },

package/dist/services/sessionManager.js

@@ -20,11 +20,14 @@ import { preparePresetLaunch } from '../utils/presetPrompt.js';
 const { Terminal } = pkg;
 const TERMINAL_CONTENT_MAX_LINES = 300;
 const TERMINAL_SCROLLBACK_LINES = 5000;
+const TERMINAL_RESTORE_SCROLLBACK_LINES = 200;
 export class SessionManager extends EventEmitter {
     sessions;
     waitingWithBottomBorder = new Map();
     busyTimers = new Map();
     autoApprovalDisabledWorktrees = new Set();
+    restoringSessions = new Set();
+    bufferedRestoreData = new Map();
     async spawn(command, args, worktreePath, options = {}) {
         const spawnOptions = {
             name: 'xterm-256color',
@@ -197,10 +200,36 @@ export class SessionManager extends EventEmitter {
             logLevel: 'off',
         });
     }
+    shouldResetRestoreScrollback(data) {
+        return (data.includes('\x1b[2J') ||
+            data.includes('\x1b[3J') ||
+            data.includes('\x1bc'));
+    }
     getRestoreSnapshot(session) {
-        return session.serializer.serialize({
-            scrollback: 0,
+        const activeBuffer = session.terminal.buffer.active;
+        if (activeBuffer.type !== 'normal') {
+            return session.serializer.serialize({
+                scrollback: 0,
+            });
+        }
+        const normalBuffer = session.terminal.buffer.normal;
+        const bufferLength = normalBuffer.length;
+        if (bufferLength === 0) {
+            return '';
+        }
+        const scrollbackStart = Math.max(0, normalBuffer.baseY - TERMINAL_RESTORE_SCROLLBACK_LINES);
+        const rangeStart = Math.max(session.restoreScrollbackBaseLine, scrollbackStart);
+        const rangeEnd = bufferLength - 1;
+        const snapshot = session.serializer.serialize({
+            range: {
+                start: rangeStart,
+                end: rangeEnd,
+            },
+            excludeAltBuffer: true,
         });
+        const cursorRow = normalBuffer.cursorY + 1;
+        const cursorCol = normalBuffer.cursorX + 1;
+        return `${snapshot}\x1b[${cursorRow};${cursorCol}H`;
     }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const existingSessions = this.getSessionsForWorktree(worktreePath);
@@ -224,6 +253,7 @@ export class SessionManager extends EventEmitter {
             isActive: false,
             terminal,
             serializer,
+            restoreScrollbackBaseLine: 0,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             presetName: options.presetName,
@@ -299,9 +329,19 @@ export class SessionManager extends EventEmitter {
         session.process.onData((data) => {
             // Write data to virtual terminal
             session.terminal.write(data);
+            if (this.shouldResetRestoreScrollback(data)) {
+                session.restoreScrollbackBaseLine =
+                    session.terminal.buffer.normal.baseY;
+            }
             session.lastActivity = new Date();
             // Only emit data events when session is active
             if (session.isActive) {
+                if (this.restoringSessions.has(session.id)) {
+                    const bufferedData = this.bufferedRestoreData.get(session.id) ?? [];
+                    bufferedData.push(data);
+                    this.bufferedRestoreData.set(session.id, bufferedData);
+                    return;
+                }
                 this.emit('sessionData', session, data);
             }
         });
@@ -436,10 +476,27 @@ export class SessionManager extends EventEmitter {
             session.isActive = active;
             if (active) {
                 session.lastAccessedAt = Date.now();
-                const restoreSnapshot = this.getRestoreSnapshot(session);
-                if (restoreSnapshot.length > 0) {
-                    this.emit('sessionRestore', session, restoreSnapshot);
+                this.restoringSessions.add(session.id);
+                try {
+                    const restoreSnapshot = this.getRestoreSnapshot(session);
+                    if (restoreSnapshot.length > 0) {
+                        this.emit('sessionRestore', session, restoreSnapshot);
+                    }
                 }
+                finally {
+                    this.restoringSessions.delete(session.id);
+                    const bufferedData = this.bufferedRestoreData.get(session.id);
+                    if (bufferedData && bufferedData.length > 0) {
+                        this.bufferedRestoreData.delete(session.id);
+                        for (const chunk of bufferedData) {
+                            this.emit('sessionData', session, chunk);
+                        }
+                    }
+                }
+            }
+            else {
+                this.restoringSessions.delete(session.id);
+                this.bufferedRestoreData.delete(session.id);
             }
         }
     }
@@ -512,6 +569,8 @@ export class SessionManager extends EventEmitter {
             }
             this.sessions.delete(sessionId);
             this.waitingWithBottomBorder.delete(sessionId);
+            this.restoringSessions.delete(sessionId);
+            this.bufferedRestoreData.delete(sessionId);
             this.emit('sessionDestroyed', session);
         }
     }

package/dist/services/sessionManager.test.js

@@ -50,13 +50,27 @@ vi.mock('@xterm/addon-serialize', () => ({
 vi.mock('@xterm/headless', () => ({
     default: {
         Terminal: vi.fn(function () {
+            const normalBuffer = {
+                type: 'normal',
+                baseY: 0,
+                cursorY: 0,
+                cursorX: 0,
+                length: 0,
+                getLine: vi.fn(function () {
+                    return null;
+                }),
+            };
             return {
                 rows: 24,
                 cols: 80,
                 buffer: {
-                    active: {
-                        type: 'normal',
+                    active: normalBuffer,
+                    normal: normalBuffer,
+                    alternate: {
+                        type: 'alternate',
                         baseY: 0,
+                        cursorY: 0,
+                        cursorX: 0,
                         length: 0,
                         getLine: vi.fn(function () {
                             return null;
@@ -760,7 +774,7 @@ describe('SessionManager', () => {
         });
     });
     describe('session restore snapshots', () => {
-        it('should emit serialized terminal output when activating a session', async () => {
+        it('should emit a bounded normal-buffer restore snapshot and restore the cursor position', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
@@ -768,14 +782,44 @@ describe('SessionManager', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const normalBuffer = session.terminal.buffer.normal;
+            normalBuffer.baseY = 260;
+            normalBuffer.length = 300;
+            normalBuffer.cursorY = 7;
+            normalBuffer.cursorX = 11;
+            session.restoreScrollbackBaseLine = 120;
             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({
+                range: {
+                    start: 120,
+                    end: 299,
+                },
+                excludeAltBuffer: true,
+            });
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m\u001b[8;12H');
+        });
+        it('should keep viewport-only restore behavior for alternate screen sessions', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            session.terminal.buffer.active = session.terminal.buffer.alternate;
+            const serializeMock = vi
+                .spyOn(session.serializer, 'serialize')
+                .mockReturnValue('\u001b[31malt\u001b[0m');
+            const restoreHandler = vi.fn();
+            sessionManager.on('sessionRestore', restoreHandler);
+            sessionManager.setSessionActive(session.id, true);
             expect(serializeMock).toHaveBeenCalledWith({ scrollback: 0 });
-            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31mrestored\u001b[0m');
+            expect(restoreHandler).toHaveBeenCalledWith(session, '\u001b[31malt\u001b[0m');
         });
         it('should skip restore event when serialized output is empty', async () => {
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
@@ -791,6 +835,43 @@ describe('SessionManager', () => {
             sessionManager.setSessionActive(session.id, true);
             expect(restoreHandler).not.toHaveBeenCalled();
         });
+        it('should reset restore scrollback baseline after a clear-screen sequence', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            session.terminal.buffer.normal.baseY = 17;
+            mockPty.emit('data', '\x1b[2J\x1b[Hfresh');
+            expect(session.restoreScrollbackBaseLine).toBe(17);
+        });
+        it('should flush live session data after the restore snapshot completes', async () => {
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
+                id: '1',
+                name: 'Main',
+                command: 'claude',
+            });
+            vi.mocked(spawn).mockReturnValue(mockPty);
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            session.terminal.buffer.normal.length = 1;
+            vi.spyOn(session.serializer, 'serialize').mockReturnValue('restored');
+            const eventOrder = [];
+            sessionManager.on('sessionRestore', restoredSession => {
+                if (restoredSession.id === session.id) {
+                    eventOrder.push('restore');
+                    mockPty.emit('data', 'live-output');
+                }
+            });
+            sessionManager.on('sessionData', activeSession => {
+                if (activeSession.id === session.id) {
+                    eventOrder.push('data');
+                }
+            });
+            sessionManager.setSessionActive(session.id, true);
+            expect(eventOrder).toEqual(['restore', 'data']);
+        });
     });
     describe('static methods', () => {
         describe('getSessionCounts', () => {

package/dist/services/stateDetector/claude.js

@@ -6,7 +6,6 @@ const SPINNER_CHARS = '✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃
 const SPINNER_ACTIVITY_PATTERN = new RegExp(`^[${SPINNER_CHARS}] \\S+ing.*\u2026`, 'm');
 // Session stats above the prompt, e.g. "(9m 21s · ↓ 13.7k tokens)" — requires parens, a digit, and "tokens"
 const TOKEN_STATS_LINE_PATTERN = /\([^)]*\d[^)]*tokens\s*\)/i;
-const BUSY_LOOKBACK_LINES = 5;
 // Workaround: Claude Code sometimes appears idle in terminal output while
 // still actively processing (busy). To mitigate false idle transitions,
 // require terminal output to remain unchanged for this duration before
@@ -88,8 +87,7 @@ export class ClaudeStateDetector extends BaseStateDetector {
             }
             start--;
         }
-        const recentBlock = lines.slice(Math.max(start, 0));
-        return recentBlock.slice(-BUSY_LOOKBACK_LINES).join('\n');
+        return lines.slice(Math.max(start, 0)).join('\n');
     }
     detectState(terminal, currentState) {
         // Check for search prompt (⌕ Search…) within 200 lines - always idle (debounced)

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

@@ -446,6 +446,27 @@ describe('ClaudeStateDetector', () => {
             // Assert - Should be idle because search prompt takes precedence
             expect(state).toBe('idle');
         });
+        it('should detect busy when spinner + token stats header is followed by a long TodoWrite checklist', () => {
+            // Regression: the recent block contains a spinner/token header and
+            // many checklist items with no internal blank line. All lines are
+            // part of the same contiguous update and should be inspected.
+            terminal = createMockTerminal([
+                '✽ Add GitHub Actions workflow and commit… (50s · ↓ 794 tokens)',
+                '  ⎿  ✔ Create docs/index.config.json',
+                '     ✔ Reorganize existing docs into topic directories',
+                '     ✔ Add frontmatter to existing docs',
+                '     ✔ Create docs/INDEX.md, docs/README.md, templates, workflow',
+                '     ✔ Create root AGENTS.md and README.md',
+                '     ✔ Write manifest generation Go script',
+                '     ✔ Add Makefile tasks and run first generation',
+                '     ◼ Add GitHub Actions workflow and commit',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            const state = detector.detectState(terminal, 'idle');
+            expect(state).toBe('busy');
+        });
         it('should ignore stale spinner output outside the latest block above the prompt box', () => {
             terminal = createMockTerminal([
                 '✻ Seasoning… (44s · ↓ 247 tokens)',

package/dist/services/worktreeService.d.ts

@@ -201,6 +201,17 @@ export declare class WorktreeService {
      * @throws {GitError} When git branch command fails (but falls back to empty array)
      */
     getAllBranchesEffect(): Effect.Effect<string[], GitError, never>;
+    /**
+     * Effect-based getBranchesWithRemotes operation
+     * Returns local and remote branches separately so callers can distinguish them.
+     * Remote branches keep their `<remote>/<branch>` prefix (e.g. `origin/main`).
+     *
+     * @returns {Effect.Effect<{local: string[]; remote: string[]}, GitError, never>}
+     */
+    getBranchesWithRemotesEffect(): Effect.Effect<{
+        local: string[];
+        remote: string[];
+    }, GitError, never>;
     /**
      * Effect-based getCurrentBranch operation
      * Returns Effect that may fail with GitError

package/dist/services/worktreeService.js

@@ -499,6 +499,43 @@ export class WorktreeService {
             return Effect.succeed([]);
         });
     }
+    /**
+     * Effect-based getBranchesWithRemotes operation
+     * Returns local and remote branches separately so callers can distinguish them.
+     * Remote branches keep their `<remote>/<branch>` prefix (e.g. `origin/main`).
+     *
+     * @returns {Effect.Effect<{local: string[]; remote: string[]}, GitError, never>}
+     */
+    getBranchesWithRemotesEffect() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return Effect.catchAll(Effect.try({
+            try: () => {
+                const output = execSync("git branch -a --format='%(refname:short)' | grep -v HEAD | sort -u", {
+                    cwd: self.rootPath,
+                    encoding: 'utf8',
+                    shell: '/bin/bash',
+                });
+                const remotes = self.getAllRemotes();
+                const remotePrefixes = remotes.map(r => `${r}/`);
+                const local = [];
+                const remote = [];
+                for (const raw of output.trim().split('\n')) {
+                    const branch = raw.trim();
+                    if (!branch)
+                        continue;
+                    if (remotePrefixes.some(prefix => branch.startsWith(prefix))) {
+                        remote.push(branch);
+                    }
+                    else {
+                        local.push(branch);
+                    }
+                }
+                return { local, remote };
+            },
+            catch: (error) => error,
+        }), (_error) => Effect.succeed({ local: [], remote: [] }));
+    }
     /**
      * Effect-based getCurrentBranch operation
      * Returns Effect that may fail with GitError

package/dist/types/index.d.ts

@@ -30,6 +30,7 @@ export interface Session {
     isActive: boolean;
     terminal: Terminal;
     serializer: SerializeAddon;
+    restoreScrollbackBaseLine: number;
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
     presetName: string | undefined;
@@ -123,6 +124,7 @@ export interface WorktreeConfig {
     copySessionData?: boolean;
     sortByLastSession?: boolean;
     autoUseDefaultBranch?: boolean;
+    includeRemoteBranches?: boolean;
 }
 export interface MergeConfig {
     mergeArgs?: string[];

package/dist/utils/hookExecutor.test.js

@@ -383,6 +383,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
@@ -442,6 +443,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
@@ -499,6 +501,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
@@ -558,6 +561,7 @@ describe('hookExecutor Integration Tests', () => {
                 process: {},
                 terminal: {},
                 serializer: {},
+                restoreScrollbackBaseLine: 0,
                 output: [],
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,

package/dist/utils/worktreeUtils.test.js

@@ -133,6 +133,7 @@ describe('prepareSessionItems', () => {
         isActive: true,
         terminal: {},
         serializer: {},
+        restoreScrollbackBaseLine: 0,
         stateCheckInterval: undefined,
         isPrimaryCommand: true,
         presetName: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "4.1.6",
+	"version": "4.1.8",
 	"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.1.6",
-		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.6",
-		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.6",
-		"@kodaikabasawa/ccmanager-linux-x64": "4.1.6",
-		"@kodaikabasawa/ccmanager-win32-x64": "4.1.6"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "4.1.8",
+		"@kodaikabasawa/ccmanager-darwin-x64": "4.1.8",
+		"@kodaikabasawa/ccmanager-linux-arm64": "4.1.8",
+		"@kodaikabasawa/ccmanager-linux-x64": "4.1.8",
+		"@kodaikabasawa/ccmanager-win32-x64": "4.1.8"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",