ccmanager 3.11.2 → 3.12.0

package/dist/constants/statePersistence.d.ts

@@ -1,2 +1,3 @@
 export declare const STATE_PERSISTENCE_DURATION_MS = 200;
 export declare const STATE_CHECK_INTERVAL_MS = 100;
+export declare const STATE_MINIMUM_DURATION_MS = 500;

package/dist/constants/statePersistence.js

@@ -2,3 +2,5 @@
 export const STATE_PERSISTENCE_DURATION_MS = 200;
 // Check interval for state detection in milliseconds
 export const STATE_CHECK_INTERVAL_MS = 100;
+// Minimum duration in current state before allowing transition to a new state
+export const STATE_MINIMUM_DURATION_MS = 500;

package/dist/hooks/useGitStatus.d.ts

@@ -1,13 +1,15 @@
 import { Worktree } from '../types/index.js';
 /**
- * Custom hook for polling git status of worktrees with Effect-based execution
+ * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
- * Fetches git status for each worktree at regular intervals using Effect.runPromiseExit
- * and updates worktree state with results. Handles cancellation via AbortController.
+ * Fetches git status and last commit date for each worktree at regular intervals
+ * using Effect.runPromiseExit and updates worktree state with results.
+ * Both are fetched together so they appear at the same time.
+ * Handles cancellation via AbortController.
  *
  * @param worktrees - Array of worktrees to monitor
  * @param defaultBranch - Default branch for comparisons (null disables polling)
  * @param updateInterval - Polling interval in milliseconds (default: 5000)
- * @returns Array of worktrees with updated gitStatus and gitStatusError fields
+ * @returns Array of worktrees with updated gitStatus, gitStatusError, and lastCommitDate fields
  */
 export declare function useGitStatus(worktrees: Worktree[], defaultBranch: string | null, updateInterval?: number): Worktree[];

package/dist/hooks/useGitStatus.js

@@ -1,16 +1,18 @@
 import { useEffect, useState } from 'react';
 import { Effect, Exit, Cause, Option } from 'effect';
-import { getGitStatusLimited } from '../utils/gitStatus.js';
+import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
 /**
- * Custom hook for polling git status of worktrees with Effect-based execution
+ * Custom hook for polling git status and commit dates of worktrees with Effect-based execution
  *
- * Fetches git status for each worktree at regular intervals using Effect.runPromiseExit
- * and updates worktree state with results. Handles cancellation via AbortController.
+ * Fetches git status and last commit date for each worktree at regular intervals
+ * using Effect.runPromiseExit and updates worktree state with results.
+ * Both are fetched together so they appear at the same time.
+ * Handles cancellation via AbortController.
  *
  * @param worktrees - Array of worktrees to monitor
  * @param defaultBranch - Default branch for comparisons (null disables polling)
  * @param updateInterval - Polling interval in milliseconds (default: 5000)
- * @returns Array of worktrees with updated gitStatus and gitStatusError fields
+ * @returns Array of worktrees with updated gitStatus, gitStatusError, and lastCommitDate fields
  */
 export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
     const [worktreesWithStatus, setWorktreesWithStatus] = useState(worktrees);
@@ -22,12 +24,17 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
         const activeRequests = new Map();
         let isCleanedUp = false;
         const fetchStatus = async (worktree, abortController) => {
-            // Execute the Effect to get git status with cancellation support
-            const exit = await Effect.runPromiseExit(getGitStatusLimited(worktree.path), {
-                signal: abortController.signal,
-            });
-            // Update worktree state based on exit result
-            handleStatusExit(exit, worktree.path, setWorktreesWithStatus);
+            // Fetch git status and last commit date in parallel
+            const [statusExit, dateExit] = await Promise.all([
+                Effect.runPromiseExit(getGitStatusLimited(worktree.path), {
+                    signal: abortController.signal,
+                }),
+                Effect.runPromiseExit(getLastCommitDateLimited(worktree.path), {
+                    signal: abortController.signal,
+                }),
+            ]);
+            // Update worktree state with both results at once
+            handleStatusExit(statusExit, dateExit, worktree.path, setWorktreesWithStatus);
         };
         const scheduleUpdate = (worktree) => {
             const abortController = new AbortController();
@@ -62,35 +69,42 @@ export function useGitStatus(worktrees, defaultBranch, updateInterval = 5000) {
     return worktreesWithStatus;
 }
 /**
- * Handle the Exit result from Effect.runPromiseExit and update worktree state
+ * Handle the Exit results from Effect.runPromiseExit and update worktree state
  *
- * Uses pattern matching on Exit to distinguish between success, failure, and interruption.
- * Success updates gitStatus, failure updates gitStatusError, interruption is ignored.
+ * Updates both gitStatus and lastCommitDate in a single state update so they
+ * appear at the same time in the UI.
  *
- * @param exit - Exit result from Effect execution
+ * @param statusExit - Exit result from git status Effect
+ * @param dateExit - Exit result from commit date Effect
  * @param worktreePath - Path of the worktree being updated
  * @param setWorktreesWithStatus - State setter function
  */
-function handleStatusExit(exit, worktreePath, setWorktreesWithStatus) {
-    if (Exit.isSuccess(exit)) {
-        // Success: update gitStatus and clear error
-        const gitStatus = exit.value;
-        setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktreePath
-            ? { ...wt, gitStatus, gitStatusError: undefined }
-            : wt));
+function handleStatusExit(statusExit, dateExit, worktreePath, setWorktreesWithStatus) {
+    // Build the update object from both results
+    const update = {};
+    let hasUpdate = false;
+    if (Exit.isSuccess(statusExit)) {
+        update.gitStatus = statusExit.value;
+        update.gitStatusError = undefined;
+        hasUpdate = true;
     }
-    else if (Exit.isFailure(exit)) {
-        // Failure: extract error and update gitStatusError
-        const failure = Cause.failureOption(exit.cause);
+    else if (Exit.isFailure(statusExit)) {
+        const failure = Cause.failureOption(statusExit.cause);
         if (Option.isSome(failure)) {
             const gitError = failure.value;
-            const errorMessage = formatGitError(gitError);
-            setWorktreesWithStatus(prev => prev.map(wt => wt.path === worktreePath
-                ? { ...wt, gitStatus: undefined, gitStatusError: errorMessage }
-                : wt));
+            update.gitStatus = undefined;
+            update.gitStatusError = formatGitError(gitError);
+            hasUpdate = true;
         }
     }
-    // Interruption: no state update - the request was cancelled
+    if (Exit.isSuccess(dateExit)) {
+        update.lastCommitDate = dateExit.value;
+        hasUpdate = true;
+    }
+    // Silently ignore commit date errors (e.g., empty repo)
+    if (hasUpdate) {
+        setWorktreesWithStatus(prev => prev.map(wt => (wt.path === worktreePath ? { ...wt, ...update } : wt)));
+    }
 }
 /**
  * Format GitError into a user-friendly error message

package/dist/hooks/useGitStatus.test.js

@@ -4,14 +4,16 @@ import { render, cleanup } from 'ink-testing-library';
 import { Text } from 'ink';
 import { Effect, Exit } from 'effect';
 import { useGitStatus } from './useGitStatus.js';
-import { getGitStatusLimited } from '../utils/gitStatus.js';
+import { getGitStatusLimited, getLastCommitDateLimited, } from '../utils/gitStatus.js';
 import { GitError } from '../types/errors.js';
 // Mock the gitStatus module
 vi.mock('../utils/gitStatus.js', () => ({
     getGitStatusLimited: vi.fn(),
+    getLastCommitDateLimited: vi.fn(),
 }));
 describe('useGitStatus', () => {
     const mockGetGitStatus = getGitStatusLimited;
+    const mockGetLastCommitDate = getLastCommitDateLimited;
     const createWorktree = (path) => ({
         path,
         branch: 'main',
@@ -28,6 +30,9 @@ describe('useGitStatus', () => {
     beforeEach(() => {
         vi.useFakeTimers();
         mockGetGitStatus.mockClear();
+        mockGetLastCommitDate.mockClear();
+        // Default: return a date for all worktrees
+        mockGetLastCommitDate.mockReturnValue(Effect.succeed(new Date('2025-01-01T00:00:00Z')));
     });
     afterEach(() => {
         vi.useRealTimers();
@@ -123,6 +128,13 @@ describe('useGitStatus', () => {
                 resolveEffect = resume;
             });
         });
+        // Also make commit date async so Promise.all waits for both
+        let resolveDateEffect = null;
+        mockGetLastCommitDate.mockImplementation(() => {
+            return Effect.async(resume => {
+                resolveDateEffect = resume;
+            });
+        });
         const TestComponent = () => {
             useGitStatus(worktrees, 'main', 100);
             return React.createElement(Text, null, 'test');
@@ -136,8 +148,9 @@ describe('useGitStatus', () => {
         await vi.advanceTimersByTimeAsync(250);
         // Should not have started a second fetch yet
         expect(mockGetGitStatus).toHaveBeenCalledTimes(1);
-        // Complete the first fetch
+        // Complete the first fetch (both status and date)
         resolveEffect(Exit.succeed(createGitStatus(1, 0)));
+        resolveDateEffect(Exit.succeed(new Date('2025-01-01T00:00:00Z')));
         // Wait for the promise to resolve
         await vi.waitFor(() => {
             expect(fetchCount).toBe(1);
@@ -162,6 +175,12 @@ describe('useGitStatus', () => {
                 });
             });
         });
+        // Also make commit date async so it doesn't resolve before status
+        mockGetLastCommitDate.mockImplementation(() => {
+            return Effect.async(_resume => {
+                return Effect.sync(() => { });
+            });
+        });
         const TestComponent = ({ worktrees }) => {
             useGitStatus(worktrees, 'main', 100);
             return React.createElement(Text, null, 'test');

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

@@ -1,7 +1,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 { STATE_PERSISTENCE_DURATION_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect, Either } from 'effect';
 const detectStateMock = vi.fn();
 // Create a deferred promise pattern for controllable mock
@@ -107,24 +107,8 @@ describe('SessionManager - Auto Approval Recovery', () => {
             mockPtyInstances.set(path, mockPty);
             return mockPty;
         });
-        // Detection sequence: first prompt (no auto-approval), back to busy, second prompt (should auto-approve)
-        const detectionStates = [
-            'waiting_input',
-            'waiting_input',
-            'waiting_input',
-            'busy',
-            'busy',
-            'busy',
-            'waiting_input',
-            'waiting_input',
-            'waiting_input',
-        ];
-        let callIndex = 0;
-        detectStateMock.mockImplementation(() => {
-            const state = detectionStates[Math.min(callIndex, detectionStates.length - 1)];
-            callIndex++;
-            return state;
-        });
+        // Start with waiting_input; tests will change the mock return value between phases
+        detectStateMock.mockReturnValue('waiting_input');
         const sessionManagerModule = await import('./sessionManager.js');
         SessionManager = sessionManagerModule.SessionManager;
         sessionManager = new SessionManager();
@@ -141,16 +125,19 @@ describe('SessionManager - Auto Approval Recovery', () => {
             ...data,
             autoApprovalFailed: true,
         }));
-        // First waiting_input cycle (auto-approval suppressed) (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        // Phase 1: waiting_input (auto-approval suppressed due to prior failure)
+        detectStateMock.mockReturnValue('waiting_input');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         expect(session.stateMutex.getSnapshot().state).toBe('waiting_input');
         expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(true);
-        // Transition back to busy should reset the failure flag (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3);
+        // Phase 2: busy - should reset the failure flag
+        detectStateMock.mockReturnValue('busy');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(session.stateMutex.getSnapshot().autoApprovalFailed).toBe(false);
-        // Next waiting_input should trigger pending_auto_approval (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // Phase 3: waiting_input again - should trigger pending_auto_approval
+        detectStateMock.mockReturnValue('waiting_input');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         // State should now be pending_auto_approval (waiting for verification)
         expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();
@@ -192,8 +179,9 @@ describe('SessionManager - Auto Approval Recovery', () => {
         expect(mockPty).toBeDefined();
         const handler = vi.fn();
         sessionManager.on('sessionStateChanged', handler);
-        // Advance to pending_auto_approval state (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 3 + STATE_PERSISTENCE_DURATION_MS);
+        // Phase 1: waiting_input → pending_auto_approval
+        detectStateMock.mockReturnValue('waiting_input');
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_PERSISTENCE_DURATION_MS);
         // State should be pending_auto_approval (waiting for verification)
         expect(session.stateMutex.getSnapshot().state).toBe('pending_auto_approval');
         expect(verifyNeedsPermissionMock).toHaveBeenCalled();

package/dist/services/sessionManager.js

@@ -7,7 +7,7 @@ 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 { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 import { Effect, Either } from 'effect';
 import { ProcessError, ConfigError } from '../types/errors.js';
 import { autoApprovalVerifier } from './autoApprovalVerifier.js';
@@ -177,6 +177,7 @@ export class SessionManager extends EventEmitter {
             state: newState,
             pendingState: undefined,
             pendingStateStart: undefined,
+            stateConfirmedAt: Date.now(),
             ...additionalUpdates,
         }));
         if (oldState !== newState) {
@@ -393,8 +394,11 @@ export class SessionManager extends EventEmitter {
                 else if (stateData.pendingState !== undefined &&
                     stateData.pendingStateStart !== undefined) {
                     // Check if the pending state has persisted long enough
+                    // and that the current state has been active for the minimum duration
                     const duration = now - stateData.pendingStateStart;
-                    if (duration >= STATE_PERSISTENCE_DURATION_MS) {
+                    const timeInCurrentState = now - stateData.stateConfirmedAt;
+                    if (duration >= STATE_PERSISTENCE_DURATION_MS &&
+                        timeInCurrentState >= STATE_MINIMUM_DURATION_MS) {
                         // Cancel auto-approval verification if state is changing away from pending_auto_approval
                         if (stateData.autoApprovalAbortController &&
                             detectedState !== 'pending_auto_approval') {
@@ -417,10 +421,13 @@ export class SessionManager extends EventEmitter {
             }
             else {
                 // Detected state matches current state, clear any pending state
+                // and update stateConfirmedAt so the minimum duration guard
+                // tracks "last time current state was seen" rather than "first confirmed"
                 void session.stateMutex.update(data => ({
                     ...data,
                     pendingState: undefined,
                     pendingStateStart: undefined,
+                    stateConfirmedAt: now,
                 }));
             }
             // Handle auto-approval if state is pending_auto_approval and no verification is in progress.

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

@@ -3,7 +3,7 @@ import { Either } from 'effect';
 import { SessionManager } from './sessionManager.js';
 import { spawn } from './bunTerminal.js';
 import { EventEmitter } from 'events';
-import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, } from '../constants/statePersistence.js';
+import { STATE_PERSISTENCE_DURATION_MS, STATE_CHECK_INTERVAL_MS, STATE_MINIMUM_DURATION_MS, } from '../constants/statePersistence.js';
 vi.mock('./bunTerminal.js', () => ({
     spawn: vi.fn(function () {
         return null;
@@ -97,7 +97,7 @@ describe('SessionManager - State Persistence', () => {
         expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingStateStart).toBeDefined();
     });
-    it('should change state after persistence duration is met', async () => {
+    it('should change state after both persistence and minimum duration are met', async () => {
         const { Effect } = await import('effect');
         const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
         const eventEmitter = eventEmitters.get('/test/path');
@@ -111,8 +111,8 @@ describe('SessionManager - State Persistence', () => {
         await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS * 2);
         expect(session.stateMutex.getSnapshot().state).toBe('busy');
         expect(stateChangeHandler).not.toHaveBeenCalled();
-        // Advance time to exceed persistence duration
-        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
+        // Advance time past both persistence and minimum duration
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS);
         // State should now be changed
         expect(session.stateMutex.getSnapshot().state).toBe('idle');
         expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
@@ -201,6 +201,72 @@ describe('SessionManager - State Persistence', () => {
         const destroyedSession = sessionManager.getSession('/test/path');
         expect(destroyedSession).toBeUndefined();
     });
+    it('should not transition state before minimum duration in current state has elapsed', async () => {
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time enough for persistence duration but less than minimum duration
+        // STATE_PERSISTENCE_DURATION_MS (200ms) < STATE_MINIMUM_DURATION_MS (500ms)
+        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS + STATE_CHECK_INTERVAL_MS * 2);
+        // State should still be busy because minimum duration hasn't elapsed
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+    });
+    it('should transition state after both persistence and minimum duration are met', async () => {
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Simulate output that would trigger idle state
+        eventEmitter.emit('data', 'Some output without busy indicators');
+        // Advance time past STATE_MINIMUM_DURATION_MS (which is longer than STATE_PERSISTENCE_DURATION_MS)
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS + STATE_CHECK_INTERVAL_MS);
+        // State should now be idle since both durations are satisfied
+        expect(session.stateMutex.getSnapshot().state).toBe('idle');
+        expect(stateChangeHandler).toHaveBeenCalledWith(session);
+    });
+    it('should not transition during brief screen redraw even after long time in current state', async () => {
+        const { Effect } = await import('effect');
+        const session = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path'));
+        const eventEmitter = eventEmitters.get('/test/path');
+        const stateChangeHandler = vi.fn();
+        sessionManager.on('sessionStateChanged', stateChangeHandler);
+        // Initial state should be busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Keep busy state active for a long time (simulating normal operation)
+        // Each check re-detects "busy" and updates stateConfirmedAt
+        eventEmitter.emit('data', 'ESC to interrupt');
+        await vi.advanceTimersByTimeAsync(2000); // 2 seconds of confirmed busy
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        // Now simulate a brief screen redraw: busy indicators disappear temporarily
+        eventEmitter.emit('data', '\x1b[2J\x1b[H'); // Clear screen
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS); // 100ms
+        // Pending state should be set to idle
+        expect(session.stateMutex.getSnapshot().pendingState).toBe('idle');
+        // Advance past persistence duration (200ms) but NOT past minimum duration (500ms)
+        // Since stateConfirmedAt was updated at ~2000ms, and now is ~2200ms,
+        // timeInCurrentState = ~200ms which is < 500ms
+        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
+        // State should still be busy because minimum duration since last busy detection hasn't elapsed
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+        // Simulate busy indicators coming back (screen redraw complete)
+        eventEmitter.emit('data', 'ESC to interrupt');
+        await vi.advanceTimersByTimeAsync(STATE_CHECK_INTERVAL_MS);
+        // State should still be busy and pending should be cleared
+        expect(session.stateMutex.getSnapshot().state).toBe('busy');
+        expect(session.stateMutex.getSnapshot().pendingState).toBeUndefined();
+        expect(stateChangeHandler).not.toHaveBeenCalled();
+    });
     it('should handle multiple sessions with independent state persistence', async () => {
         const { Effect } = await import('effect');
         const session1 = await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/path1'));
@@ -222,8 +288,8 @@ describe('SessionManager - State Persistence', () => {
         expect(session1.stateMutex.getSnapshot().pendingState).toBe('idle');
         expect(session2.stateMutex.getSnapshot().state).toBe('busy');
         expect(session2.stateMutex.getSnapshot().pendingState).toBe('waiting_input');
-        // Advance time to confirm both (use async to process mutex updates)
-        await vi.advanceTimersByTimeAsync(STATE_PERSISTENCE_DURATION_MS);
+        // Advance time to confirm both - need to exceed STATE_MINIMUM_DURATION_MS (use async to process mutex updates)
+        await vi.advanceTimersByTimeAsync(STATE_MINIMUM_DURATION_MS);
         // Both should now be in their new states
         expect(session1.stateMutex.getSnapshot().state).toBe('idle');
         expect(session1.stateMutex.getSnapshot().pendingState).toBeUndefined();

package/dist/services/stateDetector/claude.d.ts

@@ -1,6 +1,17 @@
 import { SessionState, Terminal } from '../../types/index.js';
 import { BaseStateDetector } from './base.js';
 export declare class ClaudeStateDetector extends BaseStateDetector {
+    /**
+     * Extract content above the prompt box.
+     * The prompt box is delimited by ─ border lines:
+     *   content above prompt box
+     *   ─────────────── (top border)
+     *   ❯              (prompt line)
+     *   ─────────────── (bottom border)
+     *
+     * If no prompt box is found, returns all content as fallback.
+     */
+    private getContentAbovePromptBox;
     detectState(terminal: Terminal, currentState: SessionState): SessionState;
     detectBackgroundTask(terminal: Terminal): number;
     detectTeamMembers(terminal: Terminal): number;

package/dist/services/stateDetector/claude.js

@@ -1,30 +1,70 @@
 import { BaseStateDetector } from './base.js';
+// Spinner characters used by Claude Code during active processing
+const SPINNER_CHARS = '✱✲✳✴✵✶✷✸✹✺✻✼✽✾✿❀❁❂❃❇❈❉❊❋✢✣✤✥✦✧✨⊛⊕⊙◉◎◍⁂⁕※⍟☼★☆';
+// Matches spinner activity labels like "✽ Tempering…" or "✳ Simplifying recompute_tangents…"
+const SPINNER_ACTIVITY_PATTERN = new RegExp(`^[${SPINNER_CHARS}] \\S+ing.*\u2026`, 'm');
 export class ClaudeStateDetector extends BaseStateDetector {
+    /**
+     * Extract content above the prompt box.
+     * The prompt box is delimited by ─ border lines:
+     *   content above prompt box
+     *   ─────────────── (top border)
+     *   ❯              (prompt line)
+     *   ─────────────── (bottom border)
+     *
+     * If no prompt box is found, returns all content as fallback.
+     */
+    getContentAbovePromptBox(terminal, maxLines) {
+        const lines = this.getTerminalLines(terminal, maxLines);
+        let borderCount = 0;
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const trimmed = lines[i].trim();
+            if (trimmed.length > 0 && /^─+$/.test(trimmed)) {
+                borderCount++;
+                if (borderCount === 2) {
+                    return lines.slice(0, i).join('\n');
+                }
+            }
+        }
+        // No prompt box found, return all content
+        return lines.join('\n');
+    }
     detectState(terminal, currentState) {
         // Check for search prompt (⌕ Search…) within 200 lines - always idle
         const extendedContent = this.getTerminalContent(terminal, 200);
         if (extendedContent.includes('⌕ Search…')) {
             return 'idle';
         }
-        // Existing logic with 30 lines
-        const content = this.getTerminalContent(terminal, 30);
-        const lowerContent = content.toLowerCase();
+        // Full content (including prompt box) for waiting_input detection
+        const fullContent = this.getTerminalContent(terminal, 30);
+        const fullLowerContent = fullContent.toLowerCase();
         // Check for ctrl+r toggle prompt - maintain current state
-        if (lowerContent.includes('ctrl+r to toggle')) {
+        if (fullLowerContent.includes('ctrl+r to toggle')) {
             return currentState;
         }
         // Check for "Do you want" or "Would you like" pattern with options
         // Handles both simple ("Do you want...\nYes") and complex (numbered options) formats
-        if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(lowerContent)) {
+        if (/(?:do you want|would you like).+\n+[\s\S]*?(?:yes|❯)/.test(fullLowerContent)) {
+            return 'waiting_input';
+        }
+        // Check for selection prompt with ❯ cursor indicator and numbered options
+        if (/❯\s+\d+\./.test(fullContent)) {
             return 'waiting_input';
         }
         // Check for "esc to cancel" - indicates waiting for user input
-        if (lowerContent.includes('esc to cancel')) {
+        if (fullLowerContent.includes('esc to cancel')) {
             return 'waiting_input';
         }
+        // Content above the prompt box only for busy detection
+        const abovePromptBox = this.getContentAbovePromptBox(terminal, 30);
+        const aboveLowerContent = abovePromptBox.toLowerCase();
         // Check for busy state
-        if (lowerContent.includes('esc to interrupt') ||
-            lowerContent.includes('ctrl+c to interrupt')) {
+        if (aboveLowerContent.includes('esc to interrupt') ||
+            aboveLowerContent.includes('ctrl+c to interrupt')) {
+            return 'busy';
+        }
+        // Check for spinner activity label (e.g., "✽ Tempering…", "✳ Simplifying…")
+        if (SPINNER_ACTIVITY_PATTERN.test(abovePromptBox)) {
             return 'busy';
         }
         // Otherwise idle

package/dist/services/stateDetector/claude.test.js

@@ -8,19 +8,22 @@ describe('ClaudeStateDetector', () => {
         detector = new ClaudeStateDetector();
     });
     describe('detectState', () => {
-        it('should detect busy when "ESC to interrupt" is present', () => {
+        it('should detect busy when "ESC to interrupt" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Processing...',
                 'Press ESC to interrupt',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('busy');
         });
-        it('should detect busy when "esc to interrupt" is present (case insensitive)', () => {
-            // Arrange
+        it('should detect busy when "esc to interrupt" is present (no prompt box fallback)', () => {
+            // Arrange - no prompt box borders, falls back to all content
             terminal = createMockTerminal([
                 'Running command...',
                 'press esc to interrupt the process',
@@ -30,11 +33,14 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('busy');
         });
-        it('should detect busy when "ctrl+c to interrupt" is present (web search)', () => {
+        it('should detect busy when "ctrl+c to interrupt" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Googling. (ctrl+c to interrupt',
                 'Searching for relevant information...',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
@@ -93,7 +99,7 @@ describe('ClaudeStateDetector', () => {
                 expect(state).toBe('busy');
             }
         });
-        it('should detect waiting_input when "Do you want" with options prompt is present', () => {
+        it('should detect waiting_input when "Do you want" with options is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Some previous output',
@@ -101,13 +107,16 @@ describe('ClaudeStateDetector', () => {
                 '❯ 1. Yes',
                 '2. Yes, allow all edits during this session (shift+tab)',
                 '3. No, and tell Claude what to do differently (esc)',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when "Do you want" with options prompt is present (case insensitive)', () => {
+        it('should detect waiting_input when "Do you want" is present (no prompt box fallback)', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Some output',
@@ -127,6 +136,9 @@ describe('ClaudeStateDetector', () => {
                 'Do you want to continue?',
                 '❯ 1. Yes',
                 '2. No',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
@@ -190,18 +202,48 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when "esc to cancel" is present', () => {
+        it('should detect waiting_input when plan submit prompt with ❯ cursor is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Ready to submit your answers?',
+                '',
+                '❯ 1. Submit answers',
+                '  2. Cancel',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input for generic ❯ numbered selection prompt', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                'Select an option:',
+                '',
+                '❯ 1. Option A',
+                '  2. Option B',
+                '  3. Option C',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect waiting_input when "esc to cancel" is above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Enter your message:',
                 'Press esc to cancel',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should detect waiting_input when "esc to cancel" is present (case insensitive)', () => {
+        it('should detect waiting_input when "esc to cancel" is present (no prompt box fallback)', () => {
             // Arrange
             terminal = createMockTerminal(['Waiting for input', 'ESC TO CANCEL']);
             // Act
@@ -209,12 +251,15 @@ describe('ClaudeStateDetector', () => {
             // Assert
             expect(state).toBe('waiting_input');
         });
-        it('should prioritize "esc to cancel" over "esc to interrupt" when both present', () => {
+        it('should prioritize "esc to cancel" over "esc to interrupt" when both above prompt box', () => {
             // Arrange
             terminal = createMockTerminal([
                 'Press esc to interrupt',
                 'Some input prompt',
                 'Press esc to cancel',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
             ]);
             // Act
             const state = detector.detectState(terminal, 'idle');
@@ -273,6 +318,87 @@ describe('ClaudeStateDetector', () => {
             // Assert - Should detect waiting_input from viewport
             expect(state).toBe('waiting_input');
         });
+        it('should detect busy when spinner activity label "✽ Tempering…" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                '✽ Tempering…',
+                '──────────────────────────────',
+                '❯',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy when spinner activity label "✳ Simplifying…" is present', () => {
+            // Arrange
+            terminal = createMockTerminal([
+                '✳ Simplifying recompute_tangents… (2m 18s · ↓ 4.8k tokens)',
+                '  ⎿  ◻ task list items...',
+                '──────────────────────────────',
+                '❯',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('busy');
+        });
+        it('should detect busy with various spinner characters', () => {
+            const spinnerChars = [
+                '✱',
+                '✲',
+                '✳',
+                '✴',
+                '✵',
+                '✶',
+                '✷',
+                '✸',
+                '✹',
+                '✺',
+                '✻',
+                '✼',
+                '✽',
+                '✾',
+                '✿',
+                '❀',
+                '❁',
+                '❂',
+                '❃',
+                '❇',
+                '❈',
+                '❉',
+                '❊',
+                '❋',
+                '✢',
+                '✣',
+                '✤',
+                '✥',
+                '✦',
+                '✧',
+            ];
+            for (const char of spinnerChars) {
+                terminal = createMockTerminal([`${char} Kneading…`, '❯']);
+                const state = detector.detectState(terminal, 'idle');
+                expect(state).toBe('busy');
+            }
+        });
+        it('should not detect busy for spinner-like line without ing… suffix', () => {
+            // Arrange - no "ing…" at end
+            terminal = createMockTerminal(['✽ Some random text', '❯']);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert
+            expect(state).toBe('idle');
+        });
+        it('should detect idle when "⌕ Search…" is present even with spinner activity', () => {
+            // Arrange
+            terminal = createMockTerminal(['⌕ Search…', '✽ Tempering…']);
+            // Act
+            const state = detector.detectState(terminal, 'busy');
+            // Assert - Search prompt takes precedence
+            expect(state).toBe('idle');
+        });
         it('should detect idle when "⌕ Search…" is present', () => {
             // Arrange - Search prompt should always be idle
             terminal = createMockTerminal(['⌕ Search…', 'Some content']);
@@ -297,6 +423,59 @@ describe('ClaudeStateDetector', () => {
             // Assert - Should be idle because search prompt takes precedence
             expect(state).toBe('idle');
         });
+        it('should ignore "esc to interrupt" inside prompt box', () => {
+            // Arrange - "esc to interrupt" is inside the prompt box, not above it
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                'esc to interrupt',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - should be idle because "esc to interrupt" is inside prompt box
+            expect(state).toBe('idle');
+        });
+        it('should detect "esc to cancel" inside prompt box as waiting_input', () => {
+            // Arrange - waiting_input detection uses full content including prompt box
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                'esc to cancel',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - waiting_input is not restricted to above prompt box
+            expect(state).toBe('waiting_input');
+        });
+        it('should detect "Do you want" inside prompt box as waiting_input', () => {
+            // Arrange - waiting_input detection uses full content including prompt box
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                'Do you want to proceed?',
+                '❯ 1. Yes',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - waiting_input is not restricted to above prompt box
+            expect(state).toBe('waiting_input');
+        });
+        it('should ignore spinner activity label inside prompt box', () => {
+            // Arrange - spinner label is inside the prompt box
+            terminal = createMockTerminal([
+                'Some idle output',
+                '──────────────────────────────',
+                '✽ Tempering…',
+                '──────────────────────────────',
+            ]);
+            // Act
+            const state = detector.detectState(terminal, 'idle');
+            // Assert - should be idle because spinner is inside prompt box
+            expect(state).toBe('idle');
+        });
     });
     describe('detectBackgroundTask', () => {
         it('should return count 1 when "1 background task" is in status bar', () => {

package/dist/services/stateDetector/codex.js

@@ -8,6 +8,10 @@ export class CodexStateDetector extends BaseStateDetector {
             /confirm with .+ enter/i.test(content)) {
             return 'waiting_input';
         }
+        // Check for plan/question prompts
+        if (lowerContent.includes('| enter to submit answer')) {
+            return 'waiting_input';
+        }
         // Check for waiting prompts
         if (lowerContent.includes('allow command?') ||
             lowerContent.includes('[y/n]') ||

package/dist/services/stateDetector/codex.test.js

@@ -135,6 +135,34 @@ describe('CodexStateDetector', () => {
         // Assert
         expect(state).toBe('waiting_input');
     });
+    it('should detect waiting_input state for plan question prompt with "| enter to submit answer"', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            '  Question 1/3 (3 unanswered)',
+            '  › 1. 既知CLIのみ (Recommended)',
+            '    2. 全preset対応',
+            '    3. 既知CLI優先+未知は末尾引数',
+            '    4. None of the above',
+            '',
+            '  tab to add notes | enter to submit answer | ←/→ to navigate questions | esc to interrupt',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
+    it('should prioritize plan question prompt over busy state with esc interrupt', () => {
+        // Arrange
+        terminal = createMockTerminal([
+            '  Question 1/3',
+            '  › 1. Option A',
+            '  tab to add notes | enter to submit answer | esc to interrupt',
+        ]);
+        // Act
+        const state = detector.detectState(terminal, 'idle');
+        // Assert
+        expect(state).toBe('waiting_input');
+    });
     it('should prioritize "Confirm with ... Enter" over busy state', () => {
         // Arrange
         terminal = createMockTerminal(['Esc to interrupt', 'Confirm with Y Enter']);

package/dist/services/worktreeService.js

@@ -662,21 +662,6 @@ export class WorktreeService {
                 if (mainWorktree && mainWorktree.path.includes('.git/modules')) {
                     mainWorktree.path = self.gitRootPath;
                 }
-                // Fetch last commit date for each worktree
-                for (const wt of worktrees) {
-                    try {
-                        const dateStr = execSync('git log -1 --format=%aI', {
-                            cwd: wt.path,
-                            encoding: 'utf8',
-                        }).trim();
-                        if (dateStr) {
-                            wt.lastCommitDate = new Date(dateStr);
-                        }
-                    }
-                    catch {
-                        // Ignore errors (e.g., empty repo)
-                    }
-                }
                 // Sort worktrees by last session if requested
                 if (sortByLastSession) {
                     worktrees.sort((a, b) => {

package/dist/utils/gitStatus.d.ts

@@ -41,6 +41,14 @@ export interface GitStatus {
  */
 export declare const getGitStatus: (worktreePath: string) => Effect.Effect<GitStatus, GitError>;
 export declare const getGitStatusLimited: (worktreePath: string) => Effect.Effect<GitStatus, GitError, never>;
+/**
+ * Get the last commit date for a worktree
+ *
+ * @param worktreePath - Absolute path to the worktree directory
+ * @returns Effect containing the commit date or GitError
+ */
+export declare const getLastCommitDate: (worktreePath: string) => Effect.Effect<Date, GitError>;
+export declare const getLastCommitDateLimited: (worktreePath: string) => Effect.Effect<Date, GitError, never>;
 export declare function formatGitFileChanges(status: GitStatus): string;
 export declare function formatGitAheadBehind(status: GitStatus): string;
 export declare function formatGitStatus(status: GitStatus): string;

package/dist/utils/gitStatus.js

@@ -62,6 +62,24 @@ export const getGitStatus = (worktreePath) => Effect.gen(function* () {
     };
 });
 export const getGitStatusLimited = createEffectConcurrencyLimited((worktreePath) => getGitStatus(worktreePath), 10);
+/**
+ * Get the last commit date for a worktree
+ *
+ * @param worktreePath - Absolute path to the worktree directory
+ * @returns Effect containing the commit date or GitError
+ */
+export const getLastCommitDate = (worktreePath) => Effect.flatMap(runGit(['log', '-1', '--format=%aI'], worktreePath), result => {
+    const dateStr = result.stdout.trim();
+    if (dateStr) {
+        return Effect.succeed(new Date(dateStr));
+    }
+    return Effect.fail(new GitError({
+        command: 'git log -1 --format=%aI',
+        exitCode: 0,
+        stderr: 'No commits found',
+    }));
+});
+export const getLastCommitDateLimited = createEffectConcurrencyLimited((worktreePath) => getLastCommitDate(worktreePath), 10);
 export function formatGitFileChanges(status) {
     const parts = [];
     const colors = {

package/dist/utils/mutex.d.ts

@@ -44,6 +44,7 @@ export interface SessionStateData {
     state: import('../types/index.js').SessionState;
     pendingState: import('../types/index.js').SessionState | undefined;
     pendingStateStart: number | undefined;
+    stateConfirmedAt: number;
     autoApprovalFailed: boolean;
     autoApprovalReason: string | undefined;
     autoApprovalAbortController: AbortController | undefined;

package/dist/utils/mutex.js

@@ -82,6 +82,7 @@ export function createInitialSessionStateData() {
         state: 'busy',
         pendingState: undefined,
         pendingStateStart: undefined,
+        stateConfirmedAt: Date.now(),
         autoApprovalFailed: false,
         autoApprovalReason: undefined,
         autoApprovalAbortController: undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.11.2",
+	"version": "3.12.0",
 	"description": "TUI application for managing multiple Claude Code sessions across Git worktrees",
 	"license": "MIT",
 	"author": "Kodai Kabasawa",
@@ -41,11 +41,11 @@
 		"bin"
 	],
 	"optionalDependencies": {
-		"@kodaikabasawa/ccmanager-darwin-arm64": "3.11.2",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.11.2",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.11.2",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.11.2",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.11.2"
+		"@kodaikabasawa/ccmanager-darwin-arm64": "3.12.0",
+		"@kodaikabasawa/ccmanager-darwin-x64": "3.12.0",
+		"@kodaikabasawa/ccmanager-linux-arm64": "3.12.0",
+		"@kodaikabasawa/ccmanager-linux-x64": "3.12.0",
+		"@kodaikabasawa/ccmanager-win32-x64": "3.12.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",