ccmanager 0.1.0 → 0.1.2

package/README.md

@@ -11,6 +11,7 @@ https://github.com/user-attachments/assets/a6d80e73-dc06-4ef8-849d-e3857f6c7024
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
 - Configurable keyboard shortcuts
+- Status change hooks for automation and notifications
 
 ## Why CCManager over Claude Squad?
 
@@ -76,26 +77,38 @@ The arguments are applied to all Claude Code sessions started by CCManager.
 
 You can customize keyboard shortcuts in two ways:
 
-1. **Through the UI**: Select "Configure Shortcuts" from the main menu
-2. **Configuration file**: Edit `~/.config/ccmanager/shortcuts.json`
+1. **Through the UI**: Select "Configuration" → "Configure Shortcuts" from the main menu
+2. **Configuration file**: Edit `~/.config/ccmanager/config.json` (or legacy `~/.config/ccmanager/shortcuts.json`)
 
 Example configuration:
 ```json
+// config.json (new format)
+{
+  "shortcuts": {
+    "returnToMenu": {
+      "ctrl": true,
+      "key": "r"
+    },
+    "cancel": {
+      "key": "escape"
+    }
+  }
+}
+
+// shortcuts.json (legacy format, still supported)
 {
   "returnToMenu": {
     "ctrl": true,
     "key": "r"
   },
-  "exitApp": {
-    "ctrl": true,
-    "key": "x"
-  },
   "cancel": {
     "key": "escape"
   }
 }
 ```
 
+Note: Shortcuts from `shortcuts.json` will be automatically migrated to `config.json` on first use.
+
 ### Restrictions
 
 - Shortcuts must use a modifier key (Ctrl) except for special keys like Escape
@@ -104,6 +117,20 @@ Example configuration:
   - Ctrl+D
   - Ctrl+[ (equivalent to Escape)
 
+## Status Change Hooks
+
+CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.
+
+### Overview
+
+Status hooks allow you to:
+- Get notified when Claude needs your input
+- Track time spent in different states
+- Trigger automations based on session activity
+- Integrate with notification systems like [noti](https://github.com/variadico/noti)
+
+For detailed setup instructions, see [docs/state-hooks.md](docs/state-hooks.md).
+
 ## Development
 
 ```bash

package/dist/components/App.js

@@ -5,7 +5,7 @@ import Session from './Session.js';
 import NewWorktree from './NewWorktree.js';
 import DeleteWorktree from './DeleteWorktree.js';
 import MergeWorktree from './MergeWorktree.js';
-import ConfigureShortcuts from './ConfigureShortcuts.js';
+import Configuration from './Configuration.js';
 import { SessionManager } from '../services/sessionManager.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { shortcutManager } from '../services/shortcutManager.js';
@@ -62,9 +62,9 @@ const App = () => {
             setView('merge-worktree');
             return;
         }
-        // Check if this is the configure shortcuts option
-        if (worktree.path === 'CONFIGURE_SHORTCUTS') {
-            setView('configure-shortcuts');
+        // Check if this is the configuration option
+        if (worktree.path === 'CONFIGURATION') {
+            setView('configuration');
             return;
         }
         // Check if this is the exit application option
@@ -220,8 +220,8 @@ const App = () => {
         return (React.createElement(Box, { flexDirection: "column" },
             React.createElement(Text, { color: "green" }, "Merging worktrees...")));
     }
-    if (view === 'configure-shortcuts') {
-        return React.createElement(ConfigureShortcuts, { onComplete: handleReturnToMenu });
+    if (view === 'configuration') {
+        return React.createElement(Configuration, { onComplete: handleReturnToMenu });
     }
     return null;
 };

package/dist/components/Configuration.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigurationProps {
+    onComplete: () => void;
+}
+declare const Configuration: React.FC<ConfigurationProps>;
+export default Configuration;

package/dist/components/Configuration.js

@@ -0,0 +1,49 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import ConfigureShortcuts from './ConfigureShortcuts.js';
+import ConfigureHooks from './ConfigureHooks.js';
+const Configuration = ({ onComplete }) => {
+    const [view, setView] = useState('menu');
+    const menuItems = [
+        {
+            label: '⌨  Configure Shortcuts',
+            value: 'shortcuts',
+        },
+        {
+            label: '🔧  Configure Status Hooks',
+            value: 'hooks',
+        },
+        {
+            label: '← Back to Main Menu',
+            value: 'back',
+        },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            onComplete();
+        }
+        else if (item.value === 'shortcuts') {
+            setView('shortcuts');
+        }
+        else if (item.value === 'hooks') {
+            setView('hooks');
+        }
+    };
+    const handleSubMenuComplete = () => {
+        setView('menu');
+    };
+    if (view === 'shortcuts') {
+        return React.createElement(ConfigureShortcuts, { onComplete: handleSubMenuComplete });
+    }
+    if (view === 'hooks') {
+        return React.createElement(ConfigureHooks, { onComplete: handleSubMenuComplete });
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configuration")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Select a configuration option:")),
+        React.createElement(SelectInput, { items: menuItems, onSelect: handleSelect, isFocused: true })));
+};
+export default Configuration;

package/dist/components/ConfigureHooks.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ConfigureHooksProps {
+    onComplete: () => void;
+}
+declare const ConfigureHooks: React.FC<ConfigureHooksProps>;
+export default ConfigureHooks;

package/dist/components/ConfigureHooks.js

@@ -0,0 +1,133 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import TextInput from 'ink-text-input';
+import SelectInput from 'ink-select-input';
+import { configurationManager } from '../services/configurationManager.js';
+const STATUS_LABELS = {
+    idle: 'Idle',
+    busy: 'Busy',
+    waiting_input: 'Waiting for Input',
+};
+const ConfigureHooks = ({ onComplete }) => {
+    const [view, setView] = useState('menu');
+    const [selectedStatus, setSelectedStatus] = useState('idle');
+    const [hooks, setHooks] = useState({});
+    const [currentCommand, setCurrentCommand] = useState('');
+    const [currentEnabled, setCurrentEnabled] = useState(false);
+    const [showSaveMessage, setShowSaveMessage] = useState(false);
+    useEffect(() => {
+        setHooks(configurationManager.getStatusHooks());
+    }, []);
+    useInput((input, key) => {
+        if (key.escape) {
+            if (view === 'edit') {
+                setView('menu');
+            }
+            else {
+                onComplete();
+            }
+        }
+        else if (key.tab && view === 'edit') {
+            toggleEnabled();
+        }
+    });
+    const getMenuItems = () => {
+        const items = [];
+        // Add status hook items
+        ['idle', 'busy', 'waiting_input'].forEach(status => {
+            const hook = hooks[status];
+            const enabled = hook?.enabled ? '✓' : '✗';
+            const command = hook?.command || '(not set)';
+            items.push({
+                label: `${STATUS_LABELS[status]}: ${enabled} ${command}`,
+                value: status,
+            });
+        });
+        items.push({
+            label: '─────────────',
+            value: 'separator',
+        });
+        items.push({
+            label: '💾 Save and Return',
+            value: 'save',
+        });
+        items.push({
+            label: '← Cancel',
+            value: 'cancel',
+        });
+        return items;
+    };
+    const handleMenuSelect = (item) => {
+        if (item.value === 'save') {
+            configurationManager.setStatusHooks(hooks);
+            setShowSaveMessage(true);
+            setTimeout(() => {
+                onComplete();
+            }, 1000);
+        }
+        else if (item.value === 'cancel') {
+            onComplete();
+        }
+        else if (item.value !== 'separator') {
+            const status = item.value;
+            setSelectedStatus(status);
+            const hook = hooks[status];
+            setCurrentCommand(hook?.command || '');
+            setCurrentEnabled(hook?.enabled ?? true); // Default to true if not set
+            setView('edit');
+        }
+    };
+    const handleCommandSubmit = (value) => {
+        setHooks(prev => ({
+            ...prev,
+            [selectedStatus]: {
+                command: value,
+                enabled: currentEnabled,
+            },
+        }));
+        setView('menu');
+    };
+    const toggleEnabled = () => {
+        setCurrentEnabled(prev => !prev);
+    };
+    if (showSaveMessage) {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Text, { color: "green" }, "\u2713 Configuration saved successfully!")));
+    }
+    if (view === 'edit') {
+        return (React.createElement(Box, { flexDirection: "column" },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" },
+                    "Configure ",
+                    STATUS_LABELS[selectedStatus],
+                    " Hook")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Command to execute when status changes to",
+                    ' ',
+                    STATUS_LABELS[selectedStatus],
+                    ":")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(TextInput, { value: currentCommand, onChange: setCurrentCommand, onSubmit: handleCommandSubmit, placeholder: "Enter command (e.g., notify-send 'Claude is idle')" })),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, null,
+                    "Enabled: ",
+                    currentEnabled ? '✓' : '✗',
+                    " (Press Tab to toggle)")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Environment variables available: CCMANAGER_OLD_STATE, CCMANAGER_NEW_STATE,")),
+            React.createElement(Box, null,
+                React.createElement(Text, { dimColor: true }, "CCMANAGER_WORKTREE, CCMANAGER_WORKTREE_BRANCH, CCMANAGER_SESSION_ID")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "Press Enter to save, Tab to toggle enabled, Esc to cancel"))));
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "Configure Status Change Hooks")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "Set commands to run when Claude Code session status changes:")),
+        React.createElement(SelectInput, { items: getMenuItems(), onSelect: handleMenuSelect, isFocused: true }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true }, "Press Esc to go back"))));
+};
+export default ConfigureHooks;

package/dist/components/Menu.js

@@ -67,8 +67,8 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
             value: 'delete-worktree',
         });
         menuItems.push({
-            label: `${MENU_ICONS.CONFIGURE_SHORTCUTS} Configure Shortcuts`,
-            value: 'configure-shortcuts',
+            label: `${MENU_ICONS.CONFIGURE_SHORTCUTS} Configuration`,
+            value: 'configuration',
         });
         menuItems.push({
             label: `${MENU_ICONS.EXIT} Exit`,
@@ -107,10 +107,10 @@ const Menu = ({ sessionManager, onSelectWorktree }) => {
                 hasSession: false,
             });
         }
-        else if (item.value === 'configure-shortcuts') {
+        else if (item.value === 'configuration') {
             // Handle in parent component - use special marker
             onSelectWorktree({
-                path: 'CONFIGURE_SHORTCUTS',
+                path: 'CONFIGURATION',
                 branch: '',
                 isMainWorktree: false,
                 hasSession: false,

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`);
                     }
                 }
             }

package/dist/services/configurationManager.d.ts

@@ -0,0 +1,17 @@
+import { ConfigurationData, StatusHookConfig, ShortcutConfig } from '../types/index.js';
+export declare class ConfigurationManager {
+    private configPath;
+    private legacyShortcutsPath;
+    private config;
+    constructor();
+    private loadConfig;
+    private migrateLegacyShortcuts;
+    private saveConfig;
+    getShortcuts(): ShortcutConfig;
+    setShortcuts(shortcuts: ShortcutConfig): void;
+    getStatusHooks(): StatusHookConfig;
+    setStatusHooks(hooks: StatusHookConfig): void;
+    getConfiguration(): ConfigurationData;
+    setConfiguration(config: ConfigurationData): void;
+}
+export declare const configurationManager: ConfigurationManager;

package/dist/services/configurationManager.js

@@ -0,0 +1,115 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { DEFAULT_SHORTCUTS, } from '../types/index.js';
+export class ConfigurationManager {
+    constructor() {
+        Object.defineProperty(this, "configPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "legacyShortcutsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        // Determine config directory based on platform
+        const homeDir = homedir();
+        const configDir = process.platform === 'win32'
+            ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+            : join(homeDir, '.config', 'ccmanager');
+        // Ensure config directory exists
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        this.configPath = join(configDir, 'config.json');
+        this.legacyShortcutsPath = join(configDir, 'shortcuts.json');
+        this.loadConfig();
+    }
+    loadConfig() {
+        // Try to load the new config file
+        if (existsSync(this.configPath)) {
+            try {
+                const configData = readFileSync(this.configPath, 'utf-8');
+                this.config = JSON.parse(configData);
+            }
+            catch (error) {
+                console.error('Failed to load configuration:', error);
+                this.config = {};
+            }
+        }
+        else {
+            // If new config doesn't exist, check for legacy shortcuts.json
+            this.migrateLegacyShortcuts();
+        }
+        // Check if shortcuts need to be loaded from legacy file
+        // This handles the case where config.json exists but doesn't have shortcuts
+        if (!this.config.shortcuts && existsSync(this.legacyShortcutsPath)) {
+            this.migrateLegacyShortcuts();
+        }
+        // Ensure default values
+        if (!this.config.shortcuts) {
+            this.config.shortcuts = DEFAULT_SHORTCUTS;
+        }
+        if (!this.config.statusHooks) {
+            this.config.statusHooks = {};
+        }
+    }
+    migrateLegacyShortcuts() {
+        if (existsSync(this.legacyShortcutsPath)) {
+            try {
+                const shortcutsData = readFileSync(this.legacyShortcutsPath, 'utf-8');
+                const shortcuts = JSON.parse(shortcutsData);
+                // Validate that it's a valid shortcuts config
+                if (shortcuts && typeof shortcuts === 'object') {
+                    this.config.shortcuts = shortcuts;
+                    // Save to new config format
+                    this.saveConfig();
+                    console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                }
+            }
+            catch (error) {
+                console.error('Failed to migrate legacy shortcuts:', error);
+            }
+        }
+    }
+    saveConfig() {
+        try {
+            writeFileSync(this.configPath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error('Failed to save configuration:', error);
+        }
+    }
+    getShortcuts() {
+        return this.config.shortcuts || DEFAULT_SHORTCUTS;
+    }
+    setShortcuts(shortcuts) {
+        this.config.shortcuts = shortcuts;
+        this.saveConfig();
+    }
+    getStatusHooks() {
+        return this.config.statusHooks || {};
+    }
+    setStatusHooks(hooks) {
+        this.config.statusHooks = hooks;
+        this.saveConfig();
+    }
+    getConfiguration() {
+        return this.config;
+    }
+    setConfiguration(config) {
+        this.config = config;
+        this.saveConfig();
+    }
+}
+export const configurationManager = new ConfigurationManager();

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

@@ -15,6 +15,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     setSessionActive(worktreePath: string, active: boolean): void;
     destroySession(worktreePath: string): void;
     getAllSessions(): Session[];
+    private executeStatusHook;
     destroy(): void;
 }
 export {};

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

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