ccmanager 3.12.6 → 4.0.0

package/dist/constants/statusIcons.d.ts

@@ -17,8 +17,11 @@ export declare const getBackgroundTaskTag: (count: number) => string;
 export declare const getTeamMemberTag: (count: number) => string;
 export declare const MENU_ICONS: {
     readonly NEW_WORKTREE: "⊕";
+    readonly NEW_SESSION: "⊕";
+    readonly RENAME_SESSION: "✎";
     readonly MERGE_WORKTREE: "⇄";
     readonly DELETE_WORKTREE: "✕";
+    readonly KILL_SESSION: "✕";
     readonly CONFIGURE_SHORTCUTS: "⌨";
     readonly EXIT: "⏻";
 };

package/dist/constants/statusIcons.js

@@ -29,8 +29,11 @@ export const getTeamMemberTag = (count) => {
 };
 export const MENU_ICONS = {
     NEW_WORKTREE: '⊕',
+    NEW_SESSION: '⊕',
+    RENAME_SESSION: '✎',
     MERGE_WORKTREE: '⇄',
     DELETE_WORKTREE: '✕',
+    KILL_SESSION: '✕',
     CONFIGURE_SHORTCUTS: '⌨',
     EXIT: '⏻',
 };

package/dist/services/globalSessionOrchestrator.test.js

@@ -10,14 +10,20 @@ vi.mock('./sessionManager.js', () => {
         destroy() {
             this.sessions.clear();
         }
-        getSession(worktreePath) {
-            return this.sessions.get(worktreePath);
+        getSessionById(id) {
+            return this.sessions.get(id);
         }
-        setSessionActive(_worktreePath, _active) {
+        getSessionsForWorktree(worktreePath) {
+            return Array.from(this.sessions.values()).filter((s) => s.worktreePath === worktreePath);
+        }
+        setSessionActive(_sessionId, _active) {
             // Mock implementation
         }
-        destroySession(worktreePath) {
-            this.sessions.delete(worktreePath);
+        destroySession(sessionId) {
+            this.sessions.delete(sessionId);
+        }
+        cancelAutoApproval(_sessionId, _reason) {
+            // Mock implementation
         }
         on() {
             // Mock implementation

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

@@ -48,9 +48,6 @@ vi.mock('./config/configReader.js', () => ({
         }),
         getHooks: vi.fn().mockReturnValue({}),
         getStatusHooks: vi.fn().mockReturnValue({}),
-        setWorktreeLastOpened: vi.fn(),
-        getWorktreeLastOpenedTime: vi.fn(),
-        getWorktreeLastOpened: vi.fn(() => ({})),
         isAutoApprovalEnabled: vi.fn(() => true),
         setAutoApprovalEnabled: vi.fn(),
     },
@@ -158,7 +155,7 @@ describe('SessionManager - Auto Approval Recovery', () => {
         }));
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
-        sessionManager.cancelAutoApproval(session.worktreePath, 'User pressed a key');
+        sessionManager.cancelAutoApproval(session.id, 'User pressed a key');
         // Wait for async mutex update to complete (use vi.waitFor for proper async handling)
         await vi.waitFor(() => {
             const stateData = session.stateMutex.getSnapshot();

package/dist/services/sessionManager.d.ts

@@ -34,7 +34,6 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      */
     private updateSessionState;
     constructor();
-    private createSessionId;
     private createTerminal;
     private createSessionInternal;
     /**
@@ -67,16 +66,17 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private setupExitHandler;
     private setupBackgroundHandler;
     private cleanupSession;
-    getSession(worktreePath: string): Session | undefined;
-    setSessionActive(worktreePath: string, active: boolean): void;
-    cancelAutoApproval(worktreePath: string, reason?: string): void;
+    getSessionById(id: string): Session | undefined;
+    getSessionsForWorktree(worktreePath: string): Session[];
+    setSessionActive(sessionId: string, active: boolean): void;
+    cancelAutoApproval(sessionId: string, reason?: string): void;
     toggleAutoApprovalForWorktree(worktreePath: string): boolean;
     isAutoApprovalDisabledForWorktree(worktreePath: string): boolean;
-    destroySession(worktreePath: string): void;
+    destroySession(sessionId: string): void;
     /**
      * Terminate session and cleanup resources using Effect-based error handling
      *
-     * @param {string} worktreePath - Path to the worktree
+     * @param {string} sessionId - Session identifier
      * @returns {Effect.Effect<void, ProcessError, never>} Effect that may fail with ProcessError if session does not exist or cleanup fails
      *
      * @example
@@ -90,7 +90,7 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
      * );
      * ```
      */
-    terminateSessionEffect(worktreePath: string): Effect.Effect<void, ProcessError, never>;
+    terminateSessionEffect(sessionId: string): Effect.Effect<void, ProcessError, never>;
     getAllSessions(): Session[];
     /**
      * Create session with devcontainer integration using Effect-based error handling

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

@@ -19,9 +19,9 @@ vi.mock('./config/configReader.js', () => ({
     configReader: {
         getDefaultPreset: vi.fn(),
         getPresetByIdEffect: vi.fn(),
-        setWorktreeLastOpened: vi.fn(),
-        getWorktreeLastOpenedTime: vi.fn(),
-        getWorktreeLastOpened: vi.fn(() => ({})),
+        isAutoApprovalEnabled: vi.fn(() => false),
+        setAutoApprovalEnabled: vi.fn(),
+        getStatusHooks: vi.fn(() => ({})),
     },
 }));
 // Mock Terminal
@@ -135,7 +135,7 @@ describe('SessionManager Effect-based Operations', () => {
                 }
             }
         });
-        it('should return existing session without creating new Effect', async () => {
+        it('should create a new session each time for multi-session support', async () => {
             // Setup mock preset
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -144,15 +144,16 @@ describe('SessionManager Effect-based Operations', () => {
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session twice
+            // Create session twice - multi-session API creates a new session each time
             const effect1 = sessionManager.createSessionWithPresetEffect('/test/worktree');
             const session1 = await Effect.runPromise(effect1);
             const effect2 = sessionManager.createSessionWithPresetEffect('/test/worktree');
             const session2 = await Effect.runPromise(effect2);
-            // Should return the same session
-            expect(session1).toBe(session2);
-            // Spawn should only be called once
-            expect(spawn).toHaveBeenCalledTimes(1);
+            // Should return different sessions for multi-session support
+            expect(session1).not.toBe(session2);
+            expect(session1.worktreePath).toBe(session2.worktreePath);
+            // Spawn should be called once per session
+            expect(spawn).toHaveBeenCalledTimes(2);
         });
     });
     describe('createSessionWithDevcontainer returning Effect', () => {
@@ -264,18 +265,18 @@ describe('SessionManager Effect-based Operations', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create session
-            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
             // Terminate session - should return Effect
-            const effect = sessionManager.terminateSessionEffect('/test/worktree');
+            const effect = sessionManager.terminateSessionEffect(session.id);
             // Execute the Effect and verify it succeeds
             await Effect.runPromise(effect);
             // Verify session was destroyed
-            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
+            expect(sessionManager.getSessionsForWorktree('/test/worktree')).toHaveLength(0);
             expect(mockPty.kill).toHaveBeenCalled();
         });
         it('should return Effect that fails with ProcessError when session does not exist', async () => {
             // Terminate non-existent session - should return Effect
-            const effect = sessionManager.terminateSessionEffect('/nonexistent/worktree');
+            const effect = sessionManager.terminateSessionEffect('nonexistent-session-id');
             // Execute the Effect and expect it to fail with ProcessError
             const result = await Effect.runPromise(Effect.either(effect));
             expect(Either.isLeft(result)).toBe(true);
@@ -293,17 +294,17 @@ describe('SessionManager Effect-based Operations', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create session
-            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
             // Mock kill to throw error
             mockPty.kill.mockImplementation(() => {
                 throw new Error('Process already terminated');
             });
             // Terminate session - should still succeed
-            const effect = sessionManager.terminateSessionEffect('/test/worktree');
+            const effect = sessionManager.terminateSessionEffect(session.id);
             // Should not throw, gracefully handle kill failure
             await Effect.runPromise(effect);
             // Session should still be removed from map
-            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
+            expect(sessionManager.getSessionsForWorktree('/test/worktree')).toHaveLength(0);
         });
     });
 });

package/dist/services/sessionManager.js

@@ -4,7 +4,6 @@ import pkg from '@xterm/headless';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 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, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
@@ -190,9 +189,6 @@ export class SessionManager extends EventEmitter {
         super();
         this.sessions = new Map();
     }
-    createSessionId() {
-        return `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    }
     createTerminal() {
         return new Terminal({
             cols: process.stdout.columns || 80,
@@ -202,13 +198,17 @@ export class SessionManager extends EventEmitter {
         });
     }
     async createSessionInternal(worktreePath, ptyProcess, options = {}) {
-        const id = this.createSessionId();
+        const existingSessions = this.getSessionsForWorktree(worktreePath);
+        const maxNumber = existingSessions.reduce((max, s) => Math.max(max, s.sessionNumber), 0);
         const terminal = this.createTerminal();
         const detectionStrategy = options.detectionStrategy ?? 'claude';
         const stateDetector = createStateDetector(detectionStrategy);
         const session = {
-            id,
+            id: `session-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
             worktreePath,
+            sessionNumber: maxNumber + 1,
+            sessionName: undefined,
+            lastAccessedAt: Date.now(),
             process: ptyProcess,
             output: [],
             outputHistory: [],
@@ -224,9 +224,7 @@ export class SessionManager extends EventEmitter {
         };
         // Set up persistent background data handler for state detection
         this.setupBackgroundHandler(session);
-        this.sessions.set(worktreePath, session);
-        // Record the timestamp when this worktree was opened
-        setWorktreeLastOpened(worktreePath, Date.now());
+        this.sessions.set(session.id, session);
         this.emit('sessionCreated', session);
         return session;
     }
@@ -251,11 +249,6 @@ export class SessionManager extends EventEmitter {
     createSessionWithPresetEffect(worktreePath, presetId, initialPrompt) {
         return Effect.tryPromise({
             try: async () => {
-                // Check if session already exists
-                const existing = this.sessions.get(worktreePath);
-                if (existing) {
-                    return existing;
-                }
                 const preset = this.resolvePreset(presetId);
                 const command = preset.command;
                 const launch = preparePresetLaunch(preset, initialPrompt);
@@ -470,19 +463,21 @@ export class SessionManager extends EventEmitter {
         }
         // Clear any pending state and update state to idle before destroying
         void this.updateSessionState(session, 'idle');
-        this.destroySession(session.worktreePath);
+        this.destroySession(session.id);
         this.emit('sessionExit', session);
     }
-    getSession(worktreePath) {
-        return this.sessions.get(worktreePath);
+    getSessionById(id) {
+        return this.sessions.get(id);
     }
-    setSessionActive(worktreePath, active) {
-        const session = this.sessions.get(worktreePath);
+    getSessionsForWorktree(worktreePath) {
+        return Array.from(this.sessions.values()).filter(s => s.worktreePath === worktreePath);
+    }
+    setSessionActive(sessionId, active) {
+        const session = this.sessions.get(sessionId);
         if (session) {
             session.isActive = active;
-            // If becoming active, record the timestamp when this worktree was opened
             if (active) {
-                setWorktreeLastOpened(worktreePath, Date.now());
+                session.lastAccessedAt = Date.now();
                 // Emit a restore event with the output history if available
                 if (session.outputHistory.length > 0) {
                     this.emit('sessionRestore', session);
@@ -490,8 +485,8 @@ export class SessionManager extends EventEmitter {
             }
         }
     }
-    cancelAutoApproval(worktreePath, reason = 'User input received') {
-        const session = this.sessions.get(worktreePath);
+    cancelAutoApproval(sessionId, reason = 'User input received') {
+        const session = this.sessions.get(sessionId);
         if (!session) {
             return;
         }
@@ -526,15 +521,18 @@ export class SessionManager extends EventEmitter {
         }
         else {
             this.autoApprovalDisabledWorktrees.add(worktreePath);
-            this.cancelAutoApproval(worktreePath, 'Auto-approval disabled for worktree');
+            // Cancel auto-approval for all sessions in this worktree
+            for (const session of this.getSessionsForWorktree(worktreePath)) {
+                this.cancelAutoApproval(session.id, 'Auto-approval disabled for worktree');
+            }
             return true;
         }
     }
     isAutoApprovalDisabledForWorktree(worktreePath) {
         return this.autoApprovalDisabledWorktrees.has(worktreePath);
     }
-    destroySession(worktreePath) {
-        const session = this.sessions.get(worktreePath);
+    destroySession(sessionId) {
+        const session = this.sessions.get(sessionId);
         if (session) {
             const stateData = session.stateMutex.getSnapshot();
             if (stateData.autoApprovalAbortController) {
@@ -551,20 +549,20 @@ export class SessionManager extends EventEmitter {
                 // Process might already be dead
             }
             // Clean up any pending timer
-            const timer = this.busyTimers.get(worktreePath);
+            const timer = this.busyTimers.get(sessionId);
             if (timer) {
                 clearTimeout(timer);
-                this.busyTimers.delete(worktreePath);
+                this.busyTimers.delete(sessionId);
             }
-            this.sessions.delete(worktreePath);
-            this.waitingWithBottomBorder.delete(session.id);
+            this.sessions.delete(sessionId);
+            this.waitingWithBottomBorder.delete(sessionId);
             this.emit('sessionDestroyed', session);
         }
     }
     /**
      * Terminate session and cleanup resources using Effect-based error handling
      *
-     * @param {string} worktreePath - Path to the worktree
+     * @param {string} sessionId - Session identifier
      * @returns {Effect.Effect<void, ProcessError, never>} Effect that may fail with ProcessError if session does not exist or cleanup fails
      *
      * @example
@@ -578,16 +576,20 @@ export class SessionManager extends EventEmitter {
      * );
      * ```
      */
-    terminateSessionEffect(worktreePath) {
+    terminateSessionEffect(sessionId) {
         return Effect.try({
             try: () => {
-                const session = this.sessions.get(worktreePath);
+                const session = this.sessions.get(sessionId);
                 if (!session) {
                     throw new ProcessError({
                         command: 'terminateSession',
-                        message: `Session not found for worktree: ${worktreePath}`,
+                        message: `Session not found: ${sessionId}`,
                     });
                 }
+                const stateData = session.stateMutex.getSnapshot();
+                if (stateData.autoApprovalAbortController) {
+                    this.cancelAutoApprovalVerification(session, 'Session terminated');
+                }
                 // Clear the state check interval
                 if (session.stateCheckInterval) {
                     clearInterval(session.stateCheckInterval);
@@ -600,14 +602,13 @@ export class SessionManager extends EventEmitter {
                     // Process might already be dead, this is acceptable
                 }
                 // Clean up any pending timer
-                const timer = this.busyTimers.get(worktreePath);
+                const timer = this.busyTimers.get(sessionId);
                 if (timer) {
                     clearTimeout(timer);
-                    this.busyTimers.delete(worktreePath);
+                    this.busyTimers.delete(sessionId);
                 }
-                // Remove from sessions map and cleanup
-                this.sessions.delete(worktreePath);
-                this.waitingWithBottomBorder.delete(session.id);
+                this.sessions.delete(sessionId);
+                this.waitingWithBottomBorder.delete(sessionId);
                 this.emit('sessionDestroyed', session);
             },
             catch: (error) => {
@@ -620,7 +621,7 @@ export class SessionManager extends EventEmitter {
                     command: 'terminateSession',
                     message: error instanceof Error
                         ? error.message
-                        : `Failed to terminate session for ${worktreePath}`,
+                        : `Failed to terminate session: ${sessionId}`,
                 });
             },
         });
@@ -635,11 +636,6 @@ export class SessionManager extends EventEmitter {
     createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt) {
         return Effect.tryPromise({
             try: async () => {
-                // Check if session already exists
-                const existing = this.sessions.get(worktreePath);
-                if (existing) {
-                    return existing;
-                }
                 // Execute devcontainer up command first
                 try {
                     await execAsync(devcontainerConfig.upCommand, { cwd: worktreePath });
@@ -687,9 +683,8 @@ export class SessionManager extends EventEmitter {
         });
     }
     destroy() {
-        // Clean up all sessions
-        for (const worktreePath of this.sessions.keys()) {
-            this.destroySession(worktreePath);
+        for (const sessionId of Array.from(this.sessions.keys())) {
+            this.destroySession(sessionId);
         }
     }
     static getSessionCounts(sessions) {

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

@@ -36,9 +36,6 @@ vi.mock('./config/configReader.js', () => ({
         }),
         getHooks: vi.fn().mockReturnValue({}),
         getStatusHooks: vi.fn().mockReturnValue({}),
-        setWorktreeLastOpened: vi.fn(),
-        getWorktreeLastOpenedTime: vi.fn(),
-        getWorktreeLastOpened: vi.fn(() => ({})),
         isAutoApprovalEnabled: vi.fn(() => false),
         setAutoApprovalEnabled: vi.fn(),
     },
@@ -195,10 +192,10 @@ describe('SessionManager - State Persistence', () => {
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
         // Destroy the session
-        sessionManager.destroySession('/test/path');
+        sessionManager.destroySession(session.id);
         // Check that pending state is cleared
-        const destroyedSession = sessionManager.getSession('/test/path');
-        expect(destroyedSession).toBeUndefined();
+        const remainingSessions = sessionManager.getSessionsForWorktree('/test/path');
+        expect(remainingSessions).toHaveLength(0);
     });
     it('should not transition state before minimum duration in current state has elapsed', async () => {
         const { Effect } = await import('effect');

package/dist/services/sessionManager.test.js

@@ -25,9 +25,6 @@ vi.mock('./config/configReader.js', () => ({
         getStatusHooks: vi.fn(() => ({})),
         getDefaultPreset: vi.fn(),
         getPresetByIdEffect: vi.fn(),
-        setWorktreeLastOpened: vi.fn(),
-        getWorktreeLastOpenedTime: vi.fn(),
-        getWorktreeLastOpened: vi.fn(() => ({})),
         isAutoApprovalEnabled: vi.fn(() => false),
         setAutoApprovalEnabled: vi.fn(),
     },
@@ -57,9 +54,6 @@ vi.mock('./worktreeService.js', () => ({
     WorktreeService: vi.fn(function () {
         return {};
     }),
-    setWorktreeLastOpened: vi.fn(),
-    getWorktreeLastOpened: vi.fn(() => ({})),
-    getWorktreeLastOpenedTime: vi.fn(),
 }));
 // Create a mock IPty class
 class MockPty extends EventEmitter {
@@ -202,7 +196,7 @@ describe('SessionManager', () => {
             expect(spawn).toHaveBeenCalledTimes(1);
             expect(spawn).toHaveBeenCalledWith('claude', ['--bad-flag', '--teammate-mode', 'in-process'], expect.any(Object));
         });
-        it('should return existing session if already created', async () => {
+        it('should create a new session each time for multi-session support', async () => {
             // Setup mock preset
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -211,13 +205,14 @@ describe('SessionManager', () => {
             });
             // Setup spawn mock
             vi.mocked(spawn).mockReturnValue(mockPty);
-            // Create session twice
+            // Create session twice - multi-session API creates a new session each time
             const session1 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
             const session2 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            // Should return the same session
-            expect(session1).toBe(session2);
-            // Spawn should only be called once
-            expect(spawn).toHaveBeenCalledTimes(1);
+            // Should return different sessions for multi-session support
+            expect(session1).not.toBe(session2);
+            expect(session1.worktreePath).toBe(session2.worktreePath);
+            // Spawn should be called once per session
+            expect(spawn).toHaveBeenCalledTimes(2);
         });
         it('should throw error when spawn fails with fallback args', async () => {
             // Setup mock preset with fallback
@@ -360,11 +355,11 @@ describe('SessionManager', () => {
             });
             vi.mocked(spawn).mockReturnValue(mockPty);
             // Create and destroy session
-            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
-            sessionManager.destroySession('/test/worktree');
+            const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree'));
+            sessionManager.destroySession(session.id);
             // Verify cleanup
             expect(mockPty.kill).toHaveBeenCalled();
-            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
+            expect(sessionManager.getSessionsForWorktree('/test/worktree')).toHaveLength(0);
         });
         it('should handle session exit event', async () => {
             // Setup
@@ -388,7 +383,7 @@ describe('SessionManager', () => {
             // Wait for exit event
             await new Promise(resolve => setTimeout(resolve, 700));
             expect(exitedSession).toBe(createdSession);
-            expect(sessionManager.getSession('/test/worktree')).toBeUndefined();
+            expect(sessionManager.getSessionsForWorktree('/test/worktree')).toHaveLength(0);
         });
     });
     describe('createSessionWithDevcontainerEffect', () => {
@@ -480,7 +475,7 @@ describe('SessionManager', () => {
             };
             await expect(Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig))).rejects.toThrow('Failed to start devcontainer: Container startup failed');
         });
-        it('should return existing session if already created', async () => {
+        it('should create a new session each time for multi-session support', async () => {
             // Setup mock preset
             vi.mocked(configReader.getDefaultPreset).mockReturnValue({
                 id: '1',
@@ -493,13 +488,14 @@ describe('SessionManager', () => {
                 upCommand: 'devcontainer up',
                 execCommand: 'devcontainer exec',
             };
-            // Create session twice
+            // Create session twice - multi-session API creates a new session each time
             const session1 = await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig));
             const session2 = await Effect.runPromise(sessionManager.createSessionWithDevcontainerEffect('/test/worktree', devcontainerConfig));
-            // Should return the same session
-            expect(session1).toBe(session2);
-            // spawn should only be called once
-            expect(spawn).toHaveBeenCalledTimes(1);
+            // Should return different sessions for multi-session support
+            expect(session1).not.toBe(session2);
+            expect(session1.worktreePath).toBe(session2.worktreePath);
+            // spawn should be called once per session
+            expect(spawn).toHaveBeenCalledTimes(2);
         });
         it('should handle complex exec commands with multiple arguments', async () => {
             // Setup mock preset
@@ -589,8 +585,9 @@ describe('SessionManager', () => {
                 execCommand: 'devcontainer exec --workspace-folder .',
             }, 'custom-preset'));
             // Should call createSessionWithPreset internally
-            const session = sessionManager.getSession('/test/worktree');
-            expect(session).toBeDefined();
+            const sessions = sessionManager.getSessionsForWorktree('/test/worktree');
+            expect(sessions).toHaveLength(1);
+            const session = sessions[0];
             expect(session?.devcontainerConfig).toEqual({
                 upCommand: 'devcontainer up --workspace-folder .',
                 execCommand: 'devcontainer exec --workspace-folder .',

package/dist/services/worktreeService.d.ts

@@ -1,18 +1,6 @@
 import { Effect } from 'effect';
 import { Worktree, MergeConfig } from '../types/index.js';
 import { GitError, FileSystemError, ProcessError } from '../types/errors.js';
-/**
- * Get all worktree last opened timestamps
- */
-export declare function getWorktreeLastOpened(): Record<string, number>;
-/**
- * Set the last opened timestamp for a worktree
- */
-export declare function setWorktreeLastOpened(worktreePath: string, timestamp: number): void;
-/**
- * Get the last opened timestamp for a specific worktree
- */
-export declare function getWorktreeLastOpenedTime(worktreePath: string): number | undefined;
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
  *
@@ -279,9 +267,7 @@ export declare class WorktreeService {
      *
      * @throws {GitError} When git worktree list command fails
      */
-    getWorktreesEffect(options?: {
-        sortByLastSession?: boolean;
-    }): Effect.Effect<Worktree[], GitError, never>;
+    getWorktreesEffect(): Effect.Effect<Worktree[], GitError, never>;
     /**
      * Effect-based createWorktree operation
      * May fail with GitError or FileSystemError

package/dist/services/worktreeService.js

@@ -9,26 +9,6 @@ import { getClaudeProjectsDir, pathToClaudeProjectName, } from '../utils/claudeD
 import { executeWorktreePostCreationHook, executeWorktreePreCreationHook, } from '../utils/hookExecutor.js';
 import { configReader } from './config/configReader.js';
 const CLAUDE_DIR = '.claude';
-// Module-level state for worktree last opened tracking (runtime state, not persisted)
-const worktreeLastOpened = new Map();
-/**
- * Get all worktree last opened timestamps
- */
-export function getWorktreeLastOpened() {
-    return Object.fromEntries(worktreeLastOpened);
-}
-/**
- * Set the last opened timestamp for a worktree
- */
-export function setWorktreeLastOpened(worktreePath, timestamp) {
-    worktreeLastOpened.set(worktreePath, timestamp);
-}
-/**
- * Get the last opened timestamp for a specific worktree
- */
-export function getWorktreeLastOpenedTime(worktreePath) {
-    return worktreeLastOpened.get(worktreePath);
-}
 /**
  * WorktreeService - Git worktree management with Effect-based error handling
  *
@@ -604,10 +584,9 @@ export class WorktreeService {
      *
      * @throws {GitError} When git worktree list command fails
      */
-    getWorktreesEffect(options) {
+    getWorktreesEffect() {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const self = this;
-        const sortByLastSession = options?.sortByLastSession ?? false;
         return Effect.catchAll(Effect.try({
             try: () => {
                 const output = execSync('git worktree list --porcelain', {
@@ -662,23 +641,6 @@ export class WorktreeService {
                 if (mainWorktree && mainWorktree.path.includes('.git/modules')) {
                     mainWorktree.path = self.gitRootPath;
                 }
-                // Sort worktrees by last session if requested
-                if (sortByLastSession) {
-                    worktrees.sort((a, b) => {
-                        // Get last opened timestamps for both worktrees
-                        const timeA = getWorktreeLastOpenedTime(a.path);
-                        const timeB = getWorktreeLastOpenedTime(b.path);
-                        // If both timestamps are undefined, preserve original order
-                        if (timeA === undefined && timeB === undefined) {
-                            return 0;
-                        }
-                        // If only one is undefined, treat it as older (0)
-                        const compareTimeA = timeA || 0;
-                        const compareTimeB = timeB || 0;
-                        // Sort in descending order (most recent first)
-                        return compareTimeB - compareTimeA;
-                    });
-                }
                 return worktrees;
             },
             catch: (error) => error,