ccmanager 2.10.0 → 2.11.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kodai Kabasawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/dist/components/ConfigureWorktree.js

@@ -10,6 +10,7 @@ const ConfigureWorktree = ({ onComplete }) => {
     const [autoDirectory, setAutoDirectory] = useState(worktreeConfig.autoDirectory);
     const [pattern, setPattern] = useState(worktreeConfig.autoDirectoryPattern || '../{branch}');
     const [copySessionData, setCopySessionData] = useState(worktreeConfig.copySessionData ?? true);
+    const [sortByLastSession, setSortByLastSession] = useState(worktreeConfig.sortByLastSession ?? false);
     const [editMode, setEditMode] = useState('menu');
     const [tempPattern, setTempPattern] = useState(pattern);
     // Example values for preview
@@ -34,6 +35,10 @@ const ConfigureWorktree = ({ onComplete }) => {
             label: `Copy Session Data: ${copySessionData ? '✅ Enabled' : '❌ Disabled'}`,
             value: 'toggleCopy',
         },
+        {
+            label: `Sort by Last Session: ${sortByLastSession ? '✅ Enabled' : '❌ Disabled'}`,
+            value: 'toggleSort',
+        },
         {
             label: '💾 Save Changes',
             value: 'save',
@@ -55,12 +60,16 @@ const ConfigureWorktree = ({ onComplete }) => {
             case 'toggleCopy':
                 setCopySessionData(!copySessionData);
                 break;
+            case 'toggleSort':
+                setSortByLastSession(!sortByLastSession);
+                break;
             case 'save':
                 // Save the configuration
                 configurationManager.setWorktreeConfig({
                     autoDirectory,
                     autoDirectoryPattern: pattern,
                     copySessionData,
+                    sortByLastSession,
                 });
                 onComplete();
                 break;

package/dist/components/Menu.js

@@ -10,6 +10,7 @@ import { projectManager } from '../services/projectManager.js';
 import TextInputWrapper from './TextInputWrapper.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
+import { configurationManager } from '../services/configurationManager.js';
 const createSeparatorWithText = (text, totalWidth = 35) => {
     const textWithSpaces = ` ${text} `;
     const textLength = textWithSpaces.length;
@@ -34,6 +35,8 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
     const [items, setItems] = useState([]);
     const [recentProjects, setRecentProjects] = useState([]);
     const limit = 10;
+    // Get worktree configuration for sorting
+    const worktreeConfig = configurationManager.getWorktreeConfig();
     // Use the search mode hook
     const { isSearchMode, searchQuery, selectedIndex, setSearchQuery } = useSearchMode(items.length, {
         isDisabled: !!error || !!loadError,
@@ -42,7 +45,9 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
         let cancelled = false;
         // Load worktrees and default branch using Effect composition
         // Chain getWorktreesEffect and getDefaultBranchEffect using Effect.flatMap
-        const loadWorktreesAndBranch = Effect.flatMap(worktreeService.getWorktreesEffect(), worktrees => Effect.map(worktreeService.getDefaultBranchEffect(), defaultBranch => ({
+        const loadWorktreesAndBranch = Effect.flatMap(worktreeService.getWorktreesEffect({
+            sortByLastSession: worktreeConfig.sortByLastSession,
+        }), worktrees => Effect.map(worktreeService.getDefaultBranchEffect(), defaultBranch => ({
             worktrees,
             defaultBranch,
         })));
@@ -60,9 +65,6 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             .then(result => {
             if (!cancelled) {
                 if (result.success) {
-                    setBaseWorktrees(result.worktrees);
-                    setDefaultBranch(result.defaultBranch);
-                    setLoadError(null);
                     // Update sessions after worktrees are loaded
                     const allSessions = sessionManager.getAllSessions();
                     setSessions(allSessions);
@@ -70,6 +72,9 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                     result.worktrees.forEach(wt => {
                         wt.hasSession = allSessions.some(s => s.worktreePath === wt.path);
                     });
+                    setBaseWorktrees(result.worktrees);
+                    setDefaultBranch(result.defaultBranch);
+                    setLoadError(null);
                 }
                 else {
                     // Handle GitError with pattern matching
@@ -105,7 +110,12 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
             sessionManager.off('sessionDestroyed', handleSessionChange);
             sessionManager.off('sessionStateChanged', handleSessionChange);
         };
-    }, [sessionManager, worktreeService, multiProject]);
+    }, [
+        sessionManager,
+        worktreeService,
+        multiProject,
+        worktreeConfig.sortByLastSession,
+    ]);
     useEffect(() => {
         // Prepare worktree items and calculate layout
         const items = prepareWorktreeItems(worktrees, sessions);

package/dist/services/configurationManager.d.ts

@@ -6,6 +6,7 @@ export declare class ConfigurationManager {
     private legacyShortcutsPath;
     private configDir;
     private config;
+    private worktreeLastOpened;
     constructor();
     private loadConfig;
     private migrateLegacyShortcuts;
@@ -32,6 +33,9 @@ export declare class ConfigurationManager {
     setDefaultPreset(id: string): void;
     getSelectPresetOnStart(): boolean;
     setSelectPresetOnStart(enabled: boolean): void;
+    getWorktreeLastOpened(): Record<string, number>;
+    setWorktreeLastOpened(worktreePath: string, timestamp: number): void;
+    getWorktreeLastOpenedTime(worktreePath: string): number | undefined;
     /**
      * Load configuration from file with Effect-based error handling
      *

package/dist/services/configurationManager.js

@@ -30,6 +30,12 @@ export class ConfigurationManager {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "worktreeLastOpened", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
         // Determine config directory based on platform
         const homeDir = homedir();
         this.configDir =
@@ -79,11 +85,15 @@ export class ConfigurationManager {
             this.config.worktree = {
                 autoDirectory: false,
                 copySessionData: true,
+                sortByLastSession: false,
             };
         }
         if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'copySessionData')) {
             this.config.worktree.copySessionData = true;
         }
+        if (!Object.prototype.hasOwnProperty.call(this.config.worktree, 'sortByLastSession')) {
+            this.config.worktree.sortByLastSession = false;
+        }
         if (!this.config.command) {
             this.config.command = {
                 command: 'claude',
@@ -270,6 +280,15 @@ export class ConfigurationManager {
         presets.selectPresetOnStart = enabled;
         this.setCommandPresets(presets);
     }
+    getWorktreeLastOpened() {
+        return Object.fromEntries(this.worktreeLastOpened);
+    }
+    setWorktreeLastOpened(worktreePath, timestamp) {
+        this.worktreeLastOpened.set(worktreePath, timestamp);
+    }
+    getWorktreeLastOpenedTime(worktreePath) {
+        return this.worktreeLastOpened.get(worktreePath);
+    }
     // Effect-based methods for type-safe error handling
     /**
      * Load configuration from file with Effect-based error handling
@@ -478,11 +497,15 @@ export class ConfigurationManager {
             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.command) {
             config.command = {
                 command: 'claude',

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

@@ -16,6 +16,9 @@ vi.mock('./configurationManager.js', () => ({
     configurationManager: {
         getDefaultPreset: vi.fn(),
         getPresetById: vi.fn(),
+        setWorktreeLastOpened: vi.fn(),
+        getWorktreeLastOpenedTime: vi.fn(),
+        getWorktreeLastOpened: vi.fn(() => ({})),
     },
 }));
 // Mock Terminal

package/dist/services/sessionManager.js

@@ -85,6 +85,8 @@ 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
+        configurationManager.setWorktreeLastOpened(worktreePath, Date.now());
         this.emit('sessionCreated', session);
         return session;
     }
@@ -301,9 +303,13 @@ export class SessionManager extends EventEmitter {
         const session = this.sessions.get(worktreePath);
         if (session) {
             session.isActive = active;
-            // If becoming active, emit a restore event with the output history
-            if (active && session.outputHistory.length > 0) {
-                this.emit('sessionRestore', session);
+            // If becoming active, record the timestamp when this worktree was opened
+            if (active) {
+                configurationManager.setWorktreeLastOpened(worktreePath, Date.now());
+                // Emit a restore event with the output history if available
+                if (session.outputHistory.length > 0) {
+                    this.emit('sessionRestore', session);
+                }
             }
         }
     }

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

@@ -33,6 +33,9 @@ vi.mock('./configurationManager.js', () => ({
         }),
         getHooks: vi.fn().mockReturnValue({}),
         getStatusHooks: vi.fn().mockReturnValue({}),
+        setWorktreeLastOpened: vi.fn(),
+        getWorktreeLastOpenedTime: vi.fn(),
+        getWorktreeLastOpened: vi.fn(() => ({})),
     },
 }));
 describe('SessionManager - State Persistence', () => {

package/dist/services/sessionManager.test.js

@@ -19,6 +19,9 @@ vi.mock('./configurationManager.js', () => ({
         getStatusHooks: vi.fn(() => ({})),
         getDefaultPreset: vi.fn(),
         getPresetById: vi.fn(),
+        setWorktreeLastOpened: vi.fn(),
+        getWorktreeLastOpenedTime: vi.fn(),
+        getWorktreeLastOpened: vi.fn(() => ({})),
     },
 }));
 // Mock Terminal

package/dist/services/worktreeService.d.ts

@@ -267,7 +267,9 @@ export declare class WorktreeService {
      *
      * @throws {GitError} When git worktree list command fails
      */
-    getWorktreesEffect(): Effect.Effect<Worktree[], GitError, never>;
+    getWorktreesEffect(options?: {
+        sortByLastSession?: boolean;
+    }): Effect.Effect<Worktree[], GitError, never>;
     /**
      * Effect-based createWorktree operation
      * May fail with GitError or FileSystemError

package/dist/services/worktreeService.js

@@ -585,9 +585,10 @@ export class WorktreeService {
      *
      * @throws {GitError} When git worktree list command fails
      */
-    getWorktreesEffect() {
+    getWorktreesEffect(options) {
         // 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', {
@@ -636,6 +637,23 @@ export class WorktreeService {
                 if (worktrees.length > 0 && !worktrees.some(w => w.isMainWorktree)) {
                     worktrees[0].isMainWorktree = true;
                 }
+                // Sort worktrees by last session if requested
+                if (sortByLastSession) {
+                    worktrees.sort((a, b) => {
+                        // Get last opened timestamps for both worktrees
+                        const timeA = configurationManager.getWorktreeLastOpenedTime(a.path);
+                        const timeB = configurationManager.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,

package/dist/services/worktreeService.sort.test.d.ts

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

package/dist/services/worktreeService.sort.test.js

@@ -0,0 +1,321 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Effect } from 'effect';
+import { WorktreeService } from './worktreeService.js';
+import { execSync } from 'child_process';
+import { configurationManager } from './configurationManager.js';
+// Mock child_process module
+vi.mock('child_process');
+// Mock fs module
+vi.mock('fs');
+// Mock worktreeConfigManager
+vi.mock('./worktreeConfigManager.js', () => ({
+    worktreeConfigManager: {
+        initialize: vi.fn(),
+        isAvailable: vi.fn(() => true),
+        reset: vi.fn(),
+    },
+}));
+// Mock configurationManager
+vi.mock('./configurationManager.js', () => ({
+    configurationManager: {
+        getWorktreeLastOpenedTime: vi.fn(),
+        setWorktreeLastOpened: vi.fn(),
+        getWorktreeLastOpened: vi.fn(() => ({})),
+        getWorktreeConfig: vi.fn(() => ({
+            autoDirectory: false,
+            copySessionData: true,
+            sortByLastSession: false,
+        })),
+        getWorktreeHooks: vi.fn(() => ({})),
+    },
+}));
+// Mock HookExecutor
+vi.mock('../utils/hookExecutor.js', () => ({
+    executeWorktreePostCreationHook: vi.fn(),
+}));
+// Get the mocked functions with proper typing
+const mockedExecSync = vi.mocked(execSync);
+const mockedGetWorktreeLastOpenedTime = vi.mocked(configurationManager.getWorktreeLastOpenedTime);
+describe('WorktreeService - Sorting', () => {
+    let service;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock git rev-parse --git-common-dir to return a predictable path
+        mockedExecSync.mockImplementation((cmd, _options) => {
+            if (typeof cmd === 'string' && cmd === 'git rev-parse --git-common-dir') {
+                return '/test/repo/.git\n';
+            }
+            throw new Error('Command not mocked: ' + cmd);
+        });
+        // Create service instance
+        service = new WorktreeService('/test/repo');
+    });
+    describe('getWorktreesEffect with sortByLastSession', () => {
+        it('should not sort worktrees when sortByLastSession is false', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+
+worktree /test/repo/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo/feature-b
+branch refs/heads/feature-b
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: false }));
+            // Verify order is unchanged (as returned by git)
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo');
+            expect(result[1]?.path).toBe('/test/repo/feature-a');
+            expect(result[2]?.path).toBe('/test/repo/feature-b');
+        });
+        it('should not sort worktrees when sortByLastSession is undefined', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+
+worktree /test/repo/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo/feature-b
+branch refs/heads/feature-b
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Execute without options
+            const result = await Effect.runPromise(service.getWorktreesEffect());
+            // Verify order is unchanged (as returned by git)
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo');
+            expect(result[1]?.path).toBe('/test/repo/feature-a');
+            expect(result[2]?.path).toBe('/test/repo/feature-b');
+        });
+        it('should sort worktrees by last opened timestamp in descending order', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+
+worktree /test/repo/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo/feature-b
+branch refs/heads/feature-b
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Setup timestamps - feature-b was opened most recently, then main, then feature-a
+            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
+                if (path === '/test/repo')
+                    return 2000;
+                if (path === '/test/repo/feature-a')
+                    return 1000;
+                if (path === '/test/repo/feature-b')
+                    return 3000;
+                return undefined;
+            });
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify sorted order (most recent first)
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo/feature-b'); // 3000
+            expect(result[1]?.path).toBe('/test/repo'); // 2000
+            expect(result[2]?.path).toBe('/test/repo/feature-a'); // 1000
+        });
+        it('should place worktrees without timestamps at the end', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+
+worktree /test/repo/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo/feature-b
+branch refs/heads/feature-b
+
+worktree /test/repo/feature-c
+branch refs/heads/feature-c
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Setup timestamps - only feature-a and feature-b have timestamps
+            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
+                if (path === '/test/repo/feature-a')
+                    return 1000;
+                if (path === '/test/repo/feature-b')
+                    return 2000;
+                // main and feature-c have no timestamps (undefined)
+                return undefined;
+            });
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify sorted order
+            expect(result).toHaveLength(4);
+            expect(result[0]?.path).toBe('/test/repo/feature-b'); // 2000
+            expect(result[1]?.path).toBe('/test/repo/feature-a'); // 1000
+            // main and feature-c at the end with timestamp 0 (original order preserved)
+            expect(result[2]?.path).toBe('/test/repo'); // 0
+            expect(result[3]?.path).toBe('/test/repo/feature-c'); // 0
+        });
+        it('should handle empty worktree list', async () => {
+            // Setup empty git output
+            mockedExecSync.mockReturnValue('');
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify empty result
+            expect(result).toHaveLength(0);
+        });
+        it('should handle single worktree', async () => {
+            // Setup mock git output with single worktree
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            mockedGetWorktreeLastOpenedTime.mockReturnValue(1000);
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify single result
+            expect(result).toHaveLength(1);
+            expect(result[0]?.path).toBe('/test/repo');
+        });
+        it('should maintain stable sort for worktrees with same timestamp', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo/feature-b
+branch refs/heads/feature-b
+
+worktree /test/repo/feature-c
+branch refs/heads/feature-c
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // All have the same timestamp
+            mockedGetWorktreeLastOpenedTime.mockReturnValue(1000);
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify original order is maintained (stable sort)
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo/feature-a');
+            expect(result[1]?.path).toBe('/test/repo/feature-b');
+            expect(result[2]?.path).toBe('/test/repo/feature-c');
+        });
+        it('should sort correctly with mixed timestamps including zero', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo/zero-timestamp
+branch refs/heads/zero-timestamp
+
+worktree /test/repo/recent
+branch refs/heads/recent
+
+worktree /test/repo/older
+branch refs/heads/older
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Setup timestamps including explicit zero
+            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
+                if (path === '/test/repo/zero-timestamp')
+                    return 0;
+                if (path === '/test/repo/recent')
+                    return 3000;
+                if (path === '/test/repo/older')
+                    return 1000;
+                return undefined;
+            });
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify sorted order
+            expect(result).toHaveLength(3);
+            expect(result[0]?.path).toBe('/test/repo/recent'); // 3000
+            expect(result[1]?.path).toBe('/test/repo/older'); // 1000
+            expect(result[2]?.path).toBe('/test/repo/zero-timestamp'); // 0
+        });
+        it('should preserve worktree properties after sorting', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+bare
+
+worktree /test/repo/feature-a
+branch refs/heads/feature-a
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
+                if (path === '/test/repo')
+                    return 1000;
+                if (path === '/test/repo/feature-a')
+                    return 2000;
+                return undefined;
+            });
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify properties are preserved
+            expect(result).toHaveLength(2);
+            expect(result[0]?.path).toBe('/test/repo/feature-a');
+            expect(result[0]?.branch).toBe('feature-a');
+            expect(result[0]?.isMainWorktree).toBe(false);
+            expect(result[1]?.path).toBe('/test/repo');
+            expect(result[1]?.branch).toBe('main');
+            expect(result[1]?.isMainWorktree).toBe(true);
+        });
+        it('should handle very large timestamps', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo/old
+branch refs/heads/old
+
+worktree /test/repo/new
+branch refs/heads/new
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Use actual Date.now() values
+            const now = Date.now();
+            const yesterday = now - 24 * 60 * 60 * 1000;
+            mockedGetWorktreeLastOpenedTime.mockImplementation((path) => {
+                if (path === '/test/repo/old')
+                    return yesterday;
+                if (path === '/test/repo/new')
+                    return now;
+                return undefined;
+            });
+            // Execute
+            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify sorted order
+            expect(result).toHaveLength(2);
+            expect(result[0]?.path).toBe('/test/repo/new');
+            expect(result[1]?.path).toBe('/test/repo/old');
+        });
+    });
+    describe('getWorktreesEffect error handling with sorting', () => {
+        it('should not call getWorktreeLastOpenedTime when sortByLastSession is false', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            // Execute
+            await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: false }));
+            // Verify getWorktreeLastOpenedTime was not called
+            expect(mockedGetWorktreeLastOpenedTime).not.toHaveBeenCalled();
+        });
+        it('should call getWorktreeLastOpenedTime for each worktree when sorting', async () => {
+            // Setup mock git output
+            const gitOutput = `worktree /test/repo
+branch refs/heads/main
+
+worktree /test/repo/feature-a
+branch refs/heads/feature-a
+
+worktree /test/repo/feature-b
+branch refs/heads/feature-b
+`;
+            mockedExecSync.mockReturnValue(gitOutput);
+            mockedGetWorktreeLastOpenedTime.mockReturnValue(1000);
+            // Execute
+            await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
+            // Verify getWorktreeLastOpenedTime was called for each worktree
+            // Note: May be called multiple times during sort comparisons
+            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalled();
+            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalledWith('/test/repo');
+            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalledWith('/test/repo/feature-a');
+            expect(mockedGetWorktreeLastOpenedTime).toHaveBeenCalledWith('/test/repo/feature-b');
+        });
+    });
+});

package/dist/types/index.d.ts

@@ -67,6 +67,7 @@ export interface WorktreeConfig {
     autoDirectory: boolean;
     autoDirectoryPattern?: string;
     copySessionData?: boolean;
+    sortByLastSession?: boolean;
 }
 export interface CommandConfig {
     command: string;
@@ -143,7 +144,9 @@ export declare class AmbiguousBranchError extends Error {
     constructor(branchName: string, matches: RemoteBranchMatch[]);
 }
 export interface IWorktreeService {
-    getWorktreesEffect(): import('effect').Effect.Effect<Worktree[], import('../types/errors.js').GitError, never>;
+    getWorktreesEffect(options?: {
+        sortByLastSession?: boolean;
+    }): import('effect').Effect.Effect<Worktree[], import('../types/errors.js').GitError, never>;
     getGitRootPath(): string;
     createWorktreeEffect(worktreePath: string, branch: string, baseBranch: string, copySessionData?: boolean, copyClaudeDirectory?: boolean): import('effect').Effect.Effect<Worktree, import('../types/errors.js').GitError | import('../types/errors.js').FileSystemError, never>;
     deleteWorktreeEffect(worktreePath: string, options?: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "2.10.0",
+	"version": "2.11.1",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",