ccmanager 3.12.6 → 4.0.1

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,

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

@@ -1,317 +1,155 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { Effect } from 'effect';
-import { WorktreeService, setWorktreeLastOpened } from './worktreeService.js';
-import { execSync } from 'child_process';
-// We need to keep a reference to the original Map to clear it between tests
-// Module-level state needs to be reset for isolated tests
-// 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(),
+import { describe, it, expect } from 'vitest';
+import { prepareSessionItems } from '../utils/worktreeUtils.js';
+const makeWorktree = (path, branch) => ({
+    path,
+    branch,
+    isMainWorktree: path.endsWith('/main'),
+    hasSession: false,
+});
+const makeSession = (id, worktreePath, number, lastAccessedAt, name) => ({
+    id,
+    worktreePath,
+    sessionNumber: number,
+    sessionName: name,
+    lastAccessedAt,
+    stateMutex: {
+        getSnapshot: () => ({
+            state: 'idle',
+            backgroundTaskCount: 0,
+            teamMemberCount: 0,
+        }),
     },
-}));
-// Mock configReader (still needed for getWorktreeHooks in createWorktreeEffect)
-vi.mock('./config/configReader.js', () => ({
-    configReader: {
-        getWorktreeConfig: vi.fn(() => ({
-            autoDirectory: false,
-            copySessionData: true,
+});
+describe('prepareSessionItems - sortByLastSession', () => {
+    it('should not sort worktrees when sortByLastSession is false', () => {
+        const worktrees = [
+            makeWorktree('/repo', 'main'),
+            makeWorktree('/repo/feature-a', 'feature-a'),
+            makeWorktree('/repo/feature-b', 'feature-b'),
+        ];
+        const sessions = [
+            makeSession('s1', '/repo', 1, 1000),
+            makeSession('s2', '/repo/feature-a', 1, 3000),
+        ];
+        const items = prepareSessionItems(worktrees, sessions, {
             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);
-// Helper to clear worktree last opened state by setting all known paths to undefined time
-// Since we can't clear the Map directly, we'll set timestamps to 0 for cleanup
-const clearWorktreeTimestamps = () => {
-    // This is a workaround since we can't access the internal Map
-    // Tests should use unique paths or set their own timestamps
-};
-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');
-    });
-    afterEach(() => {
-        clearWorktreeTimestamps();
+        expect(items[0]?.worktree.path).toBe('/repo');
+        expect(items[1]?.worktree.path).toBe('/repo/feature-a');
+        expect(items[2]?.worktree.path).toBe('/repo/feature-b');
     });
-    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
-            setWorktreeLastOpened('/test/repo', 2000);
-            setWorktreeLastOpened('/test/repo/feature-a', 1000);
-            setWorktreeLastOpened('/test/repo/feature-b', 3000);
-            // 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 - use unique paths to avoid state pollution
-            const gitOutput = `worktree /test/repo-no-ts/main
-branch refs/heads/main
-
-worktree /test/repo-no-ts/feature-a
-branch refs/heads/feature-a
-
-worktree /test/repo-no-ts/feature-b
-branch refs/heads/feature-b
-
-worktree /test/repo-no-ts/feature-c
-branch refs/heads/feature-c
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            // Setup timestamps - only feature-a and feature-b have timestamps
-            // main and feature-c have no timestamps set
-            setWorktreeLastOpened('/test/repo-no-ts/feature-a', 1000);
-            setWorktreeLastOpened('/test/repo-no-ts/feature-b', 2000);
-            // Execute
-            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
-            // Verify sorted order
-            expect(result).toHaveLength(4);
-            expect(result[0]?.path).toBe('/test/repo-no-ts/feature-b'); // 2000
-            expect(result[1]?.path).toBe('/test/repo-no-ts/feature-a'); // 1000
-            // main and feature-c at the end with timestamp 0 (original order preserved)
-            expect(result[2]?.path).toBe('/test/repo-no-ts/main'); // undefined -> 0
-            expect(result[3]?.path).toBe('/test/repo-no-ts/feature-c'); // undefined -> 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 sort worktrees by most recent session lastAccessedAt', () => {
+        const worktrees = [
+            makeWorktree('/repo', 'main'),
+            makeWorktree('/repo/feature-a', 'feature-a'),
+            makeWorktree('/repo/feature-b', 'feature-b'),
+        ];
+        const sessions = [
+            makeSession('s1', '/repo', 1, 2000),
+            makeSession('s2', '/repo/feature-a', 1, 1000),
+            makeSession('s3', '/repo/feature-b', 1, 3000),
+        ];
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: true,
         });
-        it('should handle single worktree', async () => {
-            // Setup mock git output with single worktree - unique path
-            const gitOutput = `worktree /test/repo-single
-branch refs/heads/main
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            setWorktreeLastOpened('/test/repo-single', 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-single');
-        });
-        it('should maintain stable sort for worktrees with same timestamp', async () => {
-            // Setup mock git output - unique paths
-            const gitOutput = `worktree /test/repo-stable/feature-a
-branch refs/heads/feature-a
-
-worktree /test/repo-stable/feature-b
-branch refs/heads/feature-b
-
-worktree /test/repo-stable/feature-c
-branch refs/heads/feature-c
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            // All have the same timestamp
-            setWorktreeLastOpened('/test/repo-stable/feature-a', 1000);
-            setWorktreeLastOpened('/test/repo-stable/feature-b', 1000);
-            setWorktreeLastOpened('/test/repo-stable/feature-c', 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-stable/feature-a');
-            expect(result[1]?.path).toBe('/test/repo-stable/feature-b');
-            expect(result[2]?.path).toBe('/test/repo-stable/feature-c');
+        expect(items[0]?.worktree.path).toBe('/repo/feature-b'); // 3000
+        expect(items[1]?.worktree.path).toBe('/repo'); // 2000
+        expect(items[2]?.worktree.path).toBe('/repo/feature-a'); // 1000
+    });
+    it('should use the max lastAccessedAt across multiple sessions in one worktree', () => {
+        const worktrees = [
+            makeWorktree('/repo/wt-a', 'a'),
+            makeWorktree('/repo/wt-b', 'b'),
+        ];
+        const sessions = [
+            makeSession('s1', '/repo/wt-a', 1, 1000),
+            makeSession('s2', '/repo/wt-a', 2, 5000),
+            makeSession('s3', '/repo/wt-b', 1, 3000),
+        ];
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: true,
         });
-        it('should sort correctly with mixed timestamps including zero', async () => {
-            // Setup mock git output - unique paths
-            const gitOutput = `worktree /test/repo-zero/zero-timestamp
-branch refs/heads/zero-timestamp
-
-worktree /test/repo-zero/recent
-branch refs/heads/recent
-
-worktree /test/repo-zero/older
-branch refs/heads/older
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            // Setup timestamps including explicit zero
-            setWorktreeLastOpened('/test/repo-zero/zero-timestamp', 0);
-            setWorktreeLastOpened('/test/repo-zero/recent', 3000);
-            setWorktreeLastOpened('/test/repo-zero/older', 1000);
-            // Execute
-            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
-            // Verify sorted order
-            expect(result).toHaveLength(3);
-            expect(result[0]?.path).toBe('/test/repo-zero/recent'); // 3000
-            expect(result[1]?.path).toBe('/test/repo-zero/older'); // 1000
-            expect(result[2]?.path).toBe('/test/repo-zero/zero-timestamp'); // 0
+        // wt-a has max 5000, wt-b has 3000
+        expect(items[0]?.worktree.path).toBe('/repo/wt-a');
+        expect(items[1]?.worktree.path).toBe('/repo/wt-a');
+        expect(items[2]?.worktree.path).toBe('/repo/wt-b');
+    });
+    it('should place worktrees without sessions at the end', () => {
+        const worktrees = [
+            makeWorktree('/repo/no-session', 'no-session'),
+            makeWorktree('/repo/has-session', 'has-session'),
+        ];
+        const sessions = [makeSession('s1', '/repo/has-session', 1, 1000)];
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: true,
         });
-        it('should preserve worktree properties after sorting', async () => {
-            // Setup mock git output - unique paths
-            const gitOutput = `worktree /test/repo-props
-branch refs/heads/main
-bare
-
-worktree /test/repo-props/feature-a
-branch refs/heads/feature-a
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            setWorktreeLastOpened('/test/repo-props', 1000);
-            setWorktreeLastOpened('/test/repo-props/feature-a', 2000);
-            // 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-props/feature-a');
-            expect(result[0]?.branch).toBe('feature-a');
-            expect(result[0]?.isMainWorktree).toBe(false);
-            expect(result[1]?.path).toBe('/test/repo-props');
-            expect(result[1]?.branch).toBe('main');
-            expect(result[1]?.isMainWorktree).toBe(true);
+        expect(items[0]?.worktree.path).toBe('/repo/has-session');
+        expect(items[1]?.worktree.path).toBe('/repo/no-session');
+    });
+    it('should sort sessions within a worktree by lastAccessedAt', () => {
+        const worktrees = [makeWorktree('/repo/wt', 'wt')];
+        const sessions = [
+            makeSession('s1', '/repo/wt', 1, 1000),
+            makeSession('s2', '/repo/wt', 2, 3000),
+            makeSession('s3', '/repo/wt', 3, 2000),
+        ];
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: true,
         });
-        it('should handle very large timestamps', async () => {
-            // Setup mock git output - unique paths
-            const gitOutput = `worktree /test/repo-large/old
-branch refs/heads/old
-
-worktree /test/repo-large/new
-branch refs/heads/new
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            // Use actual Date.now() values
-            const now = Date.now();
-            const yesterday = now - 24 * 60 * 60 * 1000;
-            setWorktreeLastOpened('/test/repo-large/old', yesterday);
-            setWorktreeLastOpened('/test/repo-large/new', now);
-            // Execute
-            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
-            // Verify sorted order
-            expect(result).toHaveLength(2);
-            expect(result[0]?.path).toBe('/test/repo-large/new');
-            expect(result[1]?.path).toBe('/test/repo-large/old');
+        expect(items).toHaveLength(3);
+        expect(items[0]?.session?.id).toBe('s2'); // 3000
+        expect(items[1]?.session?.id).toBe('s3'); // 2000
+        expect(items[2]?.session?.id).toBe('s1'); // 1000
+    });
+    it('should handle empty worktree list', () => {
+        const items = prepareSessionItems([], [], { sortByLastSession: true });
+        expect(items).toHaveLength(0);
+    });
+    it('should preserve worktree properties after sorting', () => {
+        const worktrees = [
+            makeWorktree('/repo', 'main'),
+            makeWorktree('/repo/feature', 'feature'),
+        ];
+        const sessions = [
+            makeSession('s1', '/repo/feature', 1, 2000),
+            makeSession('s2', '/repo', 1, 1000),
+        ];
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: true,
         });
+        expect(items[0]?.worktree.path).toBe('/repo/feature');
+        expect(items[0]?.worktree.branch).toBe('feature');
+        expect(items[0]?.worktree.isMainWorktree).toBe(false);
+        expect(items[1]?.worktree.path).toBe('/repo');
+        expect(items[1]?.worktree.branch).toBe('main');
     });
-    describe('getWorktreesEffect error handling with sorting', () => {
-        it('should sort correctly when sortByLastSession is true', async () => {
-            // Setup mock git output - unique paths
-            const gitOutput = `worktree /test/repo-sort
-branch refs/heads/main
-
-worktree /test/repo-sort/feature-a
-branch refs/heads/feature-a
-
-worktree /test/repo-sort/feature-b
-branch refs/heads/feature-b
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            // Set timestamps to verify sorting works
-            setWorktreeLastOpened('/test/repo-sort', 1000);
-            setWorktreeLastOpened('/test/repo-sort/feature-a', 3000);
-            setWorktreeLastOpened('/test/repo-sort/feature-b', 2000);
-            // Execute with sorting
-            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: true }));
-            // Verify sorting happened correctly (implicitly means getWorktreeLastOpenedTime was called)
-            expect(result).toHaveLength(3);
-            expect(result[0]?.path).toBe('/test/repo-sort/feature-a'); // 3000
-            expect(result[1]?.path).toBe('/test/repo-sort/feature-b'); // 2000
-            expect(result[2]?.path).toBe('/test/repo-sort'); // 1000
+    it('should maintain stable order for worktrees with same timestamp', () => {
+        const worktrees = [
+            makeWorktree('/repo/a', 'a'),
+            makeWorktree('/repo/b', 'b'),
+            makeWorktree('/repo/c', 'c'),
+        ];
+        const sessions = [
+            makeSession('s1', '/repo/a', 1, 1000),
+            makeSession('s2', '/repo/b', 1, 1000),
+            makeSession('s3', '/repo/c', 1, 1000),
+        ];
+        const items = prepareSessionItems(worktrees, sessions, {
+            sortByLastSession: true,
         });
-        it('should not sort when sortByLastSession is false', async () => {
-            // Setup mock git output - unique paths
-            const gitOutput = `worktree /test/repo-nosort
-branch refs/heads/main
-
-worktree /test/repo-nosort/feature-a
-branch refs/heads/feature-a
-
-worktree /test/repo-nosort/feature-b
-branch refs/heads/feature-b
-`;
-            mockedExecSync.mockReturnValue(gitOutput);
-            // Set timestamps that would cause reordering if sorting was applied
-            setWorktreeLastOpened('/test/repo-nosort', 1000);
-            setWorktreeLastOpened('/test/repo-nosort/feature-a', 3000);
-            setWorktreeLastOpened('/test/repo-nosort/feature-b', 2000);
-            // Execute without sorting
-            const result = await Effect.runPromise(service.getWorktreesEffect({ sortByLastSession: false }));
-            // Verify original order is preserved
-            expect(result).toHaveLength(3);
-            expect(result[0]?.path).toBe('/test/repo-nosort');
-            expect(result[1]?.path).toBe('/test/repo-nosort/feature-a');
-            expect(result[2]?.path).toBe('/test/repo-nosort/feature-b');
+        expect(items[0]?.worktree.path).toBe('/repo/a');
+        expect(items[1]?.worktree.path).toBe('/repo/b');
+        expect(items[2]?.worktree.path).toBe('/repo/c');
+    });
+    it('should not sort when no sessions exist', () => {
+        const worktrees = [
+            makeWorktree('/repo', 'main'),
+            makeWorktree('/repo/feature', 'feature'),
+        ];
+        const items = prepareSessionItems(worktrees, [], {
+            sortByLastSession: true,
         });
+        expect(items[0]?.worktree.path).toBe('/repo');
+        expect(items[1]?.worktree.path).toBe('/repo/feature');
     });
 });

package/dist/types/index.d.ts

@@ -18,6 +18,9 @@ export interface Worktree {
 export interface Session {
     id: string;
     worktreePath: string;
+    sessionNumber: number;
+    sessionName?: string;
+    lastAccessedAt: number;
     process: IPty;
     output: string[];
     outputHistory: Buffer[];
@@ -44,12 +47,42 @@ export interface AutoApprovalResponse {
     needsPermission: boolean;
     reason?: string;
 }
+export type MenuAction = {
+    type: 'selectWorktree';
+    worktree: Worktree;
+    session?: Session;
+} | {
+    type: 'newWorktree';
+} | {
+    type: 'newSession';
+    worktreePath: string;
+} | {
+    type: 'renameSession';
+    session: Session;
+} | {
+    type: 'killSession';
+    sessionId: string;
+} | {
+    type: 'sessionActions';
+    session: Session;
+    worktreePath: string;
+} | {
+    type: 'deleteWorktree';
+} | {
+    type: 'mergeWorktree';
+} | {
+    type: 'configuration';
+    scope: ConfigScope;
+} | {
+    type: 'exit';
+};
 export interface SessionManager {
     sessions: Map<string, Session>;
-    getSession(worktreePath: string): Session | undefined;
-    destroySession(worktreePath: string): void;
+    getSessionById(id: string): Session | undefined;
+    getSessionsForWorktree(worktreePath: string): Session[];
+    destroySession(sessionId: string): void;
     getAllSessions(): Session[];
-    cancelAutoApproval(worktreePath: string, reason?: string): void;
+    cancelAutoApproval(sessionId: string, reason?: string): void;
 }
 export interface ShortcutKey {
     ctrl?: boolean;
@@ -210,9 +243,7 @@ export declare class AmbiguousBranchError extends Error {
     constructor(branchName: string, matches: RemoteBranchMatch[]);
 }
 export interface IWorktreeService {
-    getWorktreesEffect(options?: {
-        sortByLastSession?: boolean;
-    }): import('effect').Effect.Effect<Worktree[], import('../types/errors.js').GitError, never>;
+    getWorktreesEffect(): 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 | import('../types/errors.js').ProcessError, never>;
     deleteWorktreeEffect(worktreePath: string, options?: {

package/dist/utils/hookExecutor.test.js

@@ -376,6 +376,8 @@ describe('hookExecutor Integration Tests', () => {
             const mockSession = {
                 id: 'test-session-123',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
+                sessionNumber: 1,
+                lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
                 output: [],
@@ -430,6 +432,8 @@ describe('hookExecutor Integration Tests', () => {
             const mockSession = {
                 id: 'test-session-456',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
+                sessionNumber: 1,
+                lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
                 output: [],
@@ -482,6 +486,8 @@ describe('hookExecutor Integration Tests', () => {
             const mockSession = {
                 id: 'test-session-789',
                 worktreePath: tmpDir, // Use tmpDir as the worktree path
+                sessionNumber: 1,
+                lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
                 output: [],
@@ -536,6 +542,8 @@ describe('hookExecutor Integration Tests', () => {
             const mockSession = {
                 id: 'test-session-failure',
                 worktreePath: tmpDir,
+                sessionNumber: 1,
+                lastAccessedAt: Date.now(),
                 process: {},
                 terminal: {},
                 output: [],