ccmanager 3.4.0 → 3.5.0

package/dist/services/config/testUtils.js

@@ -0,0 +1,351 @@
+/**
+ * @fileoverview Test utilities for config module
+ *
+ * WARNING: This file is intended for TEST USE ONLY.
+ * Do not import from production code.
+ *
+ * These functions provide Effect-based wrappers for testing config operations.
+ */
+import { Effect, Either } from 'effect';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { DEFAULT_SHORTCUTS, } from '../../types/index.js';
+import { FileSystemError, ConfigError, ValidationError, } from '../../types/errors.js';
+/**
+ * TEST ONLY: Load configuration from file with Effect-based error handling
+ *
+ * @param configPath - Path to the config file
+ * @param legacyShortcutsPath - Path to legacy shortcuts file for migration
+ * @returns Effect with ConfigurationData on success, errors on failure
+ */
+export function loadConfigEffect(configPath, legacyShortcutsPath) {
+    return Effect.try({
+        try: () => {
+            if (existsSync(configPath)) {
+                const configData = readFileSync(configPath, 'utf-8');
+                const parsedConfig = JSON.parse(configData);
+                return applyDefaults(parsedConfig);
+            }
+            else {
+                const migratedConfig = migrateLegacyShortcutsSync(configPath, legacyShortcutsPath);
+                return applyDefaults(migratedConfig || {});
+            }
+        },
+        catch: (error) => {
+            if (error instanceof SyntaxError) {
+                return new ConfigError({
+                    configPath,
+                    reason: 'parse',
+                    details: String(error),
+                });
+            }
+            return new FileSystemError({
+                operation: 'read',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * Type guard to check if value is a non-null object
+ */
+function isObject(value) {
+    return value !== null && typeof value === 'object';
+}
+function validationError(constraint, receivedValue) {
+    return Either.left(new ValidationError({
+        field: 'config',
+        constraint,
+        receivedValue,
+    }));
+}
+function validationSuccess(config) {
+    return Either.right(config);
+}
+/**
+ * TEST ONLY: Validate configuration structure
+ */
+export function validateConfig(config) {
+    if (!isObject(config)) {
+        return validationError('must be a valid configuration object', config);
+    }
+    const shortcuts = config['shortcuts'];
+    if (shortcuts !== undefined && !isObject(shortcuts)) {
+        return validationError('shortcuts must be a valid object', config);
+    }
+    return validationSuccess(config);
+}
+/**
+ * Apply default values to configuration
+ */
+function applyDefaults(config) {
+    if (!config.shortcuts) {
+        config.shortcuts = DEFAULT_SHORTCUTS;
+    }
+    if (!config.statusHooks) {
+        config.statusHooks = {};
+    }
+    if (!config.worktreeHooks) {
+        config.worktreeHooks = {};
+    }
+    if (!config.worktree) {
+        config.worktree = {
+            autoDirectory: false,
+            copySessionData: true,
+            sortByLastSession: false,
+        };
+    }
+    if (!Object.prototype.hasOwnProperty.call(config.worktree, 'copySessionData')) {
+        config.worktree.copySessionData = true;
+    }
+    if (!Object.prototype.hasOwnProperty.call(config.worktree, 'sortByLastSession')) {
+        config.worktree.sortByLastSession = false;
+    }
+    if (!config.autoApproval) {
+        config.autoApproval = {
+            enabled: false,
+            timeout: 30,
+        };
+    }
+    else {
+        if (!Object.prototype.hasOwnProperty.call(config.autoApproval, 'enabled')) {
+            config.autoApproval.enabled = false;
+        }
+        if (!Object.prototype.hasOwnProperty.call(config.autoApproval, 'timeout')) {
+            config.autoApproval.timeout = 30;
+        }
+    }
+    return config;
+}
+/**
+ * Synchronous legacy shortcuts migration helper
+ */
+function migrateLegacyShortcutsSync(configPath, legacyShortcutsPath) {
+    if (existsSync(legacyShortcutsPath)) {
+        try {
+            const shortcutsData = readFileSync(legacyShortcutsPath, 'utf-8');
+            const shortcuts = JSON.parse(shortcutsData);
+            if (shortcuts && typeof shortcuts === 'object') {
+                const config = { shortcuts };
+                writeFileSync(configPath, JSON.stringify(config, null, 2));
+                console.log('Migrated shortcuts from legacy shortcuts.json to config.json');
+                return config;
+            }
+        }
+        catch (error) {
+            console.error('Failed to migrate legacy shortcuts:', error);
+        }
+    }
+    return null;
+}
+// ============================================================================
+// Test-only helper functions for GlobalConfigManager
+// These functions were moved from GlobalConfigManager class to reduce its API
+// surface while keeping tests functional.
+// ============================================================================
+/**
+ * TEST ONLY: Add or update a preset in the config manager
+ */
+export function addPreset(configManager, preset) {
+    const presets = configManager.getCommandPresets();
+    // Replace if exists, otherwise add
+    const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+    if (existingIndex >= 0) {
+        presets.presets[existingIndex] = preset;
+    }
+    else {
+        presets.presets.push(preset);
+    }
+    configManager.setCommandPresets(presets);
+}
+/**
+ * TEST ONLY: Delete a preset by ID
+ */
+export function deletePreset(configManager, id) {
+    const presets = configManager.getCommandPresets();
+    // Don't delete if it's the last preset
+    if (presets.presets.length <= 1) {
+        return;
+    }
+    // Remove the preset
+    presets.presets = presets.presets.filter(p => p.id !== id);
+    // Update default if needed
+    if (presets.defaultPresetId === id && presets.presets.length > 0) {
+        presets.defaultPresetId = presets.presets[0].id;
+    }
+    configManager.setCommandPresets(presets);
+}
+/**
+ * TEST ONLY: Set the default preset ID
+ */
+export function setDefaultPreset(configManager, id) {
+    const presets = configManager.getCommandPresets();
+    // Only update if preset exists
+    if (presets.presets.some(p => p.id === id)) {
+        presets.defaultPresetId = id;
+        configManager.setCommandPresets(presets);
+    }
+}
+/**
+ * TEST ONLY: Save configuration to file with Effect-based error handling
+ */
+export function saveConfigEffect(configManager, config, configPath) {
+    return Effect.try({
+        try: () => {
+            configManager.setCommandPresets(config.commandPresets || configManager.getCommandPresets());
+            if (config.shortcuts) {
+                configManager.setShortcuts(config.shortcuts);
+            }
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+        },
+        catch: (error) => {
+            return new FileSystemError({
+                operation: 'write',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * TEST ONLY: Set shortcuts with Effect-based error handling
+ */
+export function setShortcutsEffect(configManager, shortcuts, configPath) {
+    return Effect.try({
+        try: () => {
+            configManager.setShortcuts(shortcuts);
+            const config = {
+                ...{},
+                shortcuts,
+                commandPresets: configManager.getCommandPresets(),
+            };
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+        },
+        catch: (error) => {
+            return new FileSystemError({
+                operation: 'write',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * TEST ONLY: Set command presets with Effect-based error handling
+ */
+export function setCommandPresetsEffect(configManager, presets, configPath) {
+    return Effect.try({
+        try: () => {
+            configManager.setCommandPresets(presets);
+            const config = {
+                ...{},
+                commandPresets: presets,
+            };
+            writeFileSync(configPath, JSON.stringify(config, null, 2));
+        },
+        catch: (error) => {
+            return new FileSystemError({
+                operation: 'write',
+                path: configPath,
+                cause: String(error),
+            });
+        },
+    });
+}
+/**
+ * TEST ONLY: Add or update preset with Effect-based error handling
+ */
+export function addPresetEffect(configManager, preset, configPath) {
+    const presets = configManager.getCommandPresets();
+    // Replace if exists, otherwise add
+    const existingIndex = presets.presets.findIndex(p => p.id === preset.id);
+    if (existingIndex >= 0) {
+        presets.presets[existingIndex] = preset;
+    }
+    else {
+        presets.presets.push(preset);
+    }
+    return setCommandPresetsEffect(configManager, presets, configPath);
+}
+/**
+ * TEST ONLY: Delete preset with Effect-based error handling
+ */
+export function deletePresetEffect(configManager, id, configPath) {
+    const presets = configManager.getCommandPresets();
+    // Don't delete if it's the last preset
+    if (presets.presets.length <= 1) {
+        return Effect.fail(new ValidationError({
+            field: 'presetId',
+            constraint: 'Cannot delete last preset',
+            receivedValue: id,
+        }));
+    }
+    // Remove the preset
+    presets.presets = presets.presets.filter(p => p.id !== id);
+    // Update default if needed
+    if (presets.defaultPresetId === id && presets.presets.length > 0) {
+        presets.defaultPresetId = presets.presets[0].id;
+    }
+    return setCommandPresetsEffect(configManager, presets, configPath);
+}
+/**
+ * TEST ONLY: Set default preset with Effect-based error handling
+ */
+export function setDefaultPresetEffect(configManager, id, configPath) {
+    const presets = configManager.getCommandPresets();
+    // Only update if preset exists
+    if (!presets.presets.some(p => p.id === id)) {
+        return Effect.fail(new ValidationError({
+            field: 'presetId',
+            constraint: 'Preset not found',
+            receivedValue: id,
+        }));
+    }
+    presets.defaultPresetId = id;
+    return setCommandPresetsEffect(configManager, presets, configPath);
+}
+/**
+ * TEST ONLY: Get the default preset
+ */
+export function getDefaultPreset(configManager) {
+    const presets = configManager.getCommandPresets();
+    const defaultPreset = presets.presets.find(p => p.id === presets.defaultPresetId);
+    return defaultPreset || presets.presets[0];
+}
+/**
+ * TEST ONLY: Get whether to select preset on start
+ */
+export function getSelectPresetOnStart(configManager) {
+    const presets = configManager.getCommandPresets();
+    return presets.selectPresetOnStart ?? false;
+}
+/**
+ * TEST ONLY: Set whether to select preset on start
+ */
+export function setSelectPresetOnStart(configManager, enabled) {
+    const presets = configManager.getCommandPresets();
+    presets.selectPresetOnStart = enabled;
+    configManager.setCommandPresets(presets);
+}
+/**
+ * TEST ONLY: Get whether auto-approval is enabled
+ */
+export function isAutoApprovalEnabled(configManager) {
+    const config = configManager.getAutoApprovalConfig();
+    return config?.enabled ?? false;
+}
+/**
+ * TEST ONLY: Get preset by ID with Either-based error handling
+ */
+export function getPresetByIdEffect(configManager, id) {
+    const presets = configManager.getCommandPresets();
+    const preset = presets.presets.find(p => p.id === id);
+    if (!preset) {
+        return Either.left(new ValidationError({
+            field: 'presetId',
+            constraint: 'Preset not found',
+            receivedValue: id,
+        }));
+    }
+    return Either.right(preset);
+}

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

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { EventEmitter } from 'events';
 import { spawn } from './bunTerminal.js';
 import { STATE_CHECK_INTERVAL_MS, STATE_PERSISTENCE_DURATION_MS, } from '../constants/statePersistence.js';
-import { Effect } from 'effect';
+import { Effect, Either } from 'effect';
 const detectStateMock = vi.fn();
 // Create a deferred promise pattern for controllable mock
 let verifyResolve = null;
@@ -20,8 +20,8 @@ vi.mock('./stateDetector/index.js', () => ({
         detectBackgroundTask: () => false,
     }),
 }));
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getConfig: vi.fn().mockReturnValue({
             commands: [
                 {
@@ -33,12 +33,12 @@ vi.mock('./configurationManager.js', () => ({
             ],
             defaultCommandId: 'test',
         }),
-        getPresetById: vi.fn().mockReturnValue({
+        getPresetByIdEffect: vi.fn().mockReturnValue(Either.right({
             id: 'test',
             name: 'Test',
             command: 'test',
             args: [],
-        }),
+        })),
         getDefaultPreset: vi.fn().mockReturnValue({
             id: 'test',
             name: 'Test',

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

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { Effect, Either } from 'effect';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
+import { ValidationError } from '../types/errors.js';
 // Mock bunTerminal
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
@@ -14,10 +15,10 @@ vi.mock('child_process', () => ({
     execFile: vi.fn(),
 }));
 // Mock configuration manager
-vi.mock('./configurationManager.js', () => ({
-    configurationManager: {
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
         getDefaultPreset: vi.fn(),
-        getPresetById: vi.fn(),
+        getPresetByIdEffect: vi.fn(),
         setWorktreeLastOpened: vi.fn(),
         getWorktreeLastOpenedTime: vi.fn(),
         getWorktreeLastOpened: vi.fn(() => ({})),
@@ -83,14 +84,14 @@ describe('SessionManager Effect-based Operations', () => {
     let sessionManager;
     let mockPty;
     let SessionManager;
-    let configurationManager;
+    let configReader;
     beforeEach(async () => {
         vi.clearAllMocks();
         // Dynamically import after mocks are set up
         const sessionManagerModule = await import('./sessionManager.js');
-        const configManagerModule = await import('./configurationManager.js');
+        const configManagerModule = await import('./config/configReader.js');
         SessionManager = sessionManagerModule.SessionManager;
-        configurationManager = configManagerModule.configurationManager;
+        configReader = configManagerModule.configReader;
         sessionManager = new SessionManager();
         mockPty = new MockPty();
     });
@@ -100,7 +101,7 @@ describe('SessionManager Effect-based Operations', () => {
     describe('createSessionWithPreset returning Effect', () => {
         it('should return Effect that succeeds with Session', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -117,9 +118,13 @@ describe('SessionManager Effect-based Operations', () => {
             expect(session.stateMutex.getSnapshot().state).toBe('busy');
         });
         it('should return Effect that fails with ConfigError when preset not found', async () => {
-            // Setup mocks - both return null/undefined
-            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue(undefined);
+            // Setup mocks - getPresetByIdEffect returns Left, getDefaultPreset returns undefined
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: 'invalid-preset',
+            })));
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue(undefined);
             // Create session with non-existent preset - should return Effect
             const effect = sessionManager.createSessionWithPresetEffect('/test/worktree', 'invalid-preset');
             // Execute the Effect and expect it to fail with ConfigError
@@ -135,7 +140,7 @@ describe('SessionManager Effect-based Operations', () => {
         });
         it('should return Effect that fails with ProcessError when spawn fails', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'invalid-command',
@@ -160,7 +165,7 @@ describe('SessionManager Effect-based Operations', () => {
         });
         it('should return existing session without creating new Effect', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -181,7 +186,7 @@ describe('SessionManager Effect-based Operations', () => {
     describe('createSessionWithDevcontainer returning Effect', () => {
         it('should return Effect that succeeds with Session', async () => {
             // Setup mock preset
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -244,9 +249,13 @@ describe('SessionManager Effect-based Operations', () => {
             }
         });
         it('should return Effect that fails with ConfigError when preset not found', async () => {
-            // Setup mocks - both return null/undefined
-            vi.mocked(configurationManager.getPresetById).mockReturnValue(undefined);
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue(undefined);
+            // Setup mocks - getPresetByIdEffect returns Left, getDefaultPreset returns undefined
+            vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: 'invalid-preset',
+            })));
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue(undefined);
             // Mock exec to succeed (devcontainer up)
             const { exec } = await import('child_process');
             const mockExec = vi.mocked(exec);
@@ -276,7 +285,7 @@ describe('SessionManager Effect-based Operations', () => {
     describe('terminateSession returning Effect', () => {
         it('should return Effect that succeeds when session exists', async () => {
             // Setup mock preset and create a session first
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',
@@ -305,7 +314,7 @@ describe('SessionManager Effect-based Operations', () => {
         });
         it('should return Effect that succeeds even when process kill fails', async () => {
             // Setup mock preset and create a session
-            vi.mocked(configurationManager.getDefaultPreset).mockReturnValue({
+            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
                 name: 'Main',
                 command: 'claude',

package/dist/services/sessionManager.js

@@ -3,11 +3,12 @@ import { EventEmitter } from 'events';
 import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { promisify } from 'util';
-import { configurationManager } from './configurationManager.js';
+import { configReader } from './config/configReader.js';
+import { setWorktreeLastOpened } from './worktreeService.js';
 import { executeStatusHook } from '../utils/hookExecutor.js';
 import { createStateDetector } from './stateDetector/index.js';
 import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
-import { Effect } from 'effect';
+import { Effect, Either } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
 import { logger } from '../utils/logger.js';
@@ -33,7 +34,7 @@ export class SessionManager extends EventEmitter {
         const detectedState = session.stateDetector.detectState(session.terminal, stateData.state);
         // If auto-approval is enabled and state is waiting_input, convert to pending_auto_approval
         if (detectedState === 'waiting_input' &&
-            configurationManager.isAutoApprovalEnabled() &&
+            configReader.isAutoApprovalEnabled() &&
             !stateData.autoApprovalFailed) {
             return 'pending_auto_approval';
         }
@@ -188,7 +189,7 @@ export class SessionManager extends EventEmitter {
             logLevel: 'off',
         });
     }
-    async createSessionInternal(worktreePath, ptyProcess, commandConfig, options = {}) {
+    async createSessionInternal(worktreePath, ptyProcess, options = {}) {
         const id = this.createSessionId();
         const terminal = this.createTerminal();
         const detectionStrategy = options.detectionStrategy ?? 'claude';
@@ -204,7 +205,6 @@ export class SessionManager extends EventEmitter {
             terminal,
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
-            commandConfig,
             detectionStrategy,
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             stateMutex: new Mutex(createInitialSessionStateData()),
@@ -214,7 +214,7 @@ export class SessionManager extends EventEmitter {
         this.setupBackgroundHandler(session);
         this.sessions.set(worktreePath, session);
         // Record the timestamp when this worktree was opened
-        configurationManager.setWorktreeLastOpened(worktreePath, Date.now());
+        setWorktreeLastOpened(worktreePath, Date.now());
         this.emit('sessionCreated', session);
         return session;
     }
@@ -244,12 +244,12 @@ export class SessionManager extends EventEmitter {
                 if (existing) {
                     return existing;
                 }
-                // Get preset configuration
+                // Get preset configuration using Either-based lookup
                 let preset = presetId
-                    ? configurationManager.getPresetById(presetId)
+                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
                     : null;
                 if (!preset) {
-                    preset = configurationManager.getDefaultPreset();
+                    preset = configReader.getDefaultPreset();
                 }
                 // Validate preset exists
                 if (!preset) {
@@ -263,14 +263,9 @@ export class SessionManager extends EventEmitter {
                 }
                 const command = preset.command;
                 const args = preset.args || [];
-                const commandConfig = {
-                    command: preset.command,
-                    args: preset.args,
-                    fallbackArgs: preset.fallbackArgs,
-                };
                 // Spawn the process - fallback will be handled by setupExitHandler
                 const ptyProcess = await this.spawn(command, args, worktreePath);
-                return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+                return this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                 });
@@ -329,8 +324,6 @@ export class SessionManager extends EventEmitter {
             if (e.exitCode === 1 && !e.signal && session.isPrimaryCommand) {
                 try {
                     let fallbackProcess;
-                    // Use fallback args if available, otherwise use empty args
-                    const fallbackArgs = session.commandConfig?.fallbackArgs || [];
                     // Check if we're in a devcontainer session
                     if (session.devcontainerConfig) {
                         // Parse the exec command to extract arguments
@@ -338,17 +331,12 @@ export class SessionManager extends EventEmitter {
                         const devcontainerCmd = execParts[0] || 'devcontainer';
                         const execArgs = execParts.slice(1);
                         // Build fallback command for devcontainer
-                        const fallbackFullArgs = [
-                            ...execArgs,
-                            '--',
-                            session.commandConfig?.command || 'claude',
-                            ...fallbackArgs,
-                        ];
+                        const fallbackFullArgs = [...execArgs, '--', 'claude'];
                         fallbackProcess = await this.spawn(devcontainerCmd, fallbackFullArgs, session.worktreePath);
                     }
                     else {
                         // Regular fallback without devcontainer
-                        fallbackProcess = await this.spawn(session.commandConfig?.command || 'claude', fallbackArgs, session.worktreePath);
+                        fallbackProcess = await this.spawn('claude', [], session.worktreePath);
                     }
                     // Replace the process
                     session.process = fallbackProcess;
@@ -466,7 +454,7 @@ export class SessionManager extends EventEmitter {
             session.isActive = active;
             // If becoming active, record the timestamp when this worktree was opened
             if (active) {
-                configurationManager.setWorktreeLastOpened(worktreePath, Date.now());
+                setWorktreeLastOpened(worktreePath, Date.now());
                 // Emit a restore event with the output history if available
                 if (session.outputHistory.length > 0) {
                     this.emit('sessionRestore', session);
@@ -620,12 +608,12 @@ export class SessionManager extends EventEmitter {
                         message: `Failed to start devcontainer: ${error instanceof Error ? error.message : String(error)}`,
                     });
                 }
-                // Get preset configuration
+                // Get preset configuration using Either-based lookup
                 let preset = presetId
-                    ? configurationManager.getPresetById(presetId)
+                    ? Either.getOrElse(configReader.getPresetByIdEffect(presetId), () => null)
                     : null;
                 if (!preset) {
-                    preset = configurationManager.getDefaultPreset();
+                    preset = configReader.getDefaultPreset();
                 }
                 // Validate preset exists
                 if (!preset) {
@@ -650,12 +638,7 @@ export class SessionManager extends EventEmitter {
                 ];
                 // Spawn the process within devcontainer
                 const ptyProcess = await this.spawn(devcontainerCmd, fullArgs, worktreePath);
-                const commandConfig = {
-                    command: preset.command,
-                    args: preset.args,
-                    fallbackArgs: preset.fallbackArgs,
-                };
-                return this.createSessionInternal(worktreePath, ptyProcess, commandConfig, {
+                return this.createSessionInternal(worktreePath, ptyProcess, {
                     isPrimaryCommand: true,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,