ccmanager 3.11.0 → 3.11.2

package/dist/components/App.js

@@ -14,7 +14,8 @@ import RemoteBranchSelector from './RemoteBranchSelector.js';
 import LoadingSpinner from './LoadingSpinner.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
-import { worktreeNameGenerator } from '../services/worktreeNameGenerator.js';
+import { worktreeNameGenerator, generateFallbackBranchName, } from '../services/worktreeNameGenerator.js';
+import { logger } from '../utils/logger.js';
 import { AmbiguousBranchError, } from '../types/index.js';
 import { configReader } from '../services/config/configReader.js';
 import { ENV_VARS } from '../constants/env.js';
@@ -53,26 +54,24 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         }
     };
     // Helper function to create session with Effect-based error handling
-    const createSessionWithEffect = async (worktreePath, presetId, initialPrompt) => {
+    const createSessionWithEffect = useCallback(async (worktreePath, presetId, initialPrompt) => {
         const sessionEffect = devcontainerConfig
             ? sessionManager.createSessionWithDevcontainerEffect(worktreePath, devcontainerConfig, presetId, initialPrompt)
             : sessionManager.createSessionWithPresetEffect(worktreePath, presetId, initialPrompt);
         // Execute the Effect and handle both success and failure cases
         const result = await Effect.runPromise(Effect.either(sessionEffect));
         if (result._tag === 'Left') {
-            // Handle error using pattern matching on _tag
             const errorMessage = formatErrorMessage(result.left);
             return {
                 success: false,
                 errorMessage: `Failed to create session: ${errorMessage}`,
             };
         }
-        // Success case - extract session from Right
         return {
             success: true,
             session: result.right,
         };
-    };
+    }, [sessionManager, devcontainerConfig]);
     // Helper function to clear terminal screen
     const clearScreen = () => {
         if (process.stdout.isTTY) {
@@ -115,7 +114,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             session = result.session;
         }
         navigateToSession(session);
-    }, [sessionManager, navigateWithClear, navigateToSession]);
+    }, [
+        sessionManager,
+        navigateWithClear,
+        navigateToSession,
+        createSessionWithEffect,
+    ]);
     useEffect(() => {
         // Listen for session exits to return to menu automatically
         const handleSessionExit = (session) => {
@@ -324,11 +328,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             const existingBranches = allBranches._tag === 'Right' ? allBranches.right : [];
             const generatedBranch = await Effect.runPromise(Effect.either(worktreeNameGenerator.generateBranchNameEffect(request.initialPrompt, request.baseBranch, existingBranches)));
             if (generatedBranch._tag === 'Left') {
-                setError(formatErrorMessage(generatedBranch.left));
-                setView('new-worktree');
-                return;
+                logger.warn(`Branch name generation failed, using fallback: ${formatErrorMessage(generatedBranch.left)}`);
+                branch = generateFallbackBranchName(existingBranches);
+            }
+            else {
+                branch = generatedBranch.right;
             }
-            branch = generatedBranch.right;
             if (request.autoDirectoryPattern) {
                 targetPath = generateWorktreeDirectory(request.projectPath, branch, request.autoDirectoryPattern);
             }

package/dist/components/Dashboard.js

@@ -11,7 +11,7 @@ import { WorktreeService } from '../services/worktreeService.js';
 import { STATUS_ICONS, STATUS_LABELS, MENU_ICONS, getStatusDisplay, } from '../constants/statusIcons.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
-import { truncateString, calculateColumnPositions, assembleWorktreeLabel, } from '../utils/worktreeUtils.js';
+import { truncateString, calculateColumnPositions, assembleWorktreeLabel, formatRelativeDate, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
 import TextInputWrapper from './TextInputWrapper.js';
 const MAX_BRANCH_NAME_LENGTH = 70;
@@ -241,12 +241,18 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, error, onDis
                     fileChanges,
                     aheadBehind,
                     parentBranch,
+                    lastCommitDate: wt.lastCommitDate
+                        ? `\x1b[90m${formatRelativeDate(wt.lastCommitDate)}\x1b[0m`
+                        : '',
                     error: itemError,
                     lengths: {
                         base: stripAnsi(baseLabel).length,
                         fileChanges: stripAnsi(fileChanges).length,
                         aheadBehind: stripAnsi(aheadBehind).length,
                         parentBranch: stripAnsi(parentBranch).length,
+                        lastCommitDate: wt.lastCommitDate
+                            ? formatRelativeDate(wt.lastCommitDate).length
+                            : 0,
                     },
                 };
             });

package/dist/components/DeleteWorktree.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect } from 'react';
+import path from 'path';
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
 import { Effect } from 'effect';
@@ -20,8 +21,18 @@ const DeleteWorktree = ({ projectPath, onComplete, onCancel, }) => {
             try {
                 const allWorktrees = await Effect.runPromise(worktreeService.getWorktreesEffect());
                 if (!cancelled) {
-                    // Filter out main worktree - we shouldn't delete it
-                    const deletableWorktrees = allWorktrees.filter(wt => !wt.isMainWorktree);
+                    // Filter out main worktree and current working directory worktree
+                    const resolvedCwd = path.resolve(process.cwd());
+                    const deletableWorktrees = allWorktrees.filter(wt => {
+                        if (wt.isMainWorktree)
+                            return false;
+                        const resolvedPath = path.resolve(wt.path);
+                        if (resolvedCwd === resolvedPath ||
+                            resolvedCwd.startsWith(resolvedPath + path.sep)) {
+                            return false;
+                        }
+                        return true;
+                    });
                     setWorktrees(deletableWorktrees);
                     setIsLoading(false);
                 }

package/dist/components/Menu.js

@@ -144,7 +144,8 @@ const Menu = ({ sessionManager, worktreeService, onSelectWorktree, onSelectRecen
                 sessionManager.isAutoApprovalDisabledForWorktree(item.worktree.path);
             const label = baseLabel + (aaDisabled ? ' [Auto Approval Off]' : '');
             // Only show numbers for worktrees (0-9) when not in search mode
-            const numberPrefix = !isSearchMode && index < 10 ? `${index} ❯ ` : '❯ ';
+            // Use fixed-width prefix to prevent flicker at scroll boundary
+            const numberPrefix = !isSearchMode && index < 10 ? `${index} ❯ ` : '  ❯ ';
             return {
                 type: 'worktree',
                 label: numberPrefix + label,

package/dist/components/TextInputWrapper.d.ts

@@ -5,9 +5,6 @@ interface TextInputWrapperProps {
     onSubmit?: (value: string) => void;
     placeholder?: string;
     focus?: boolean;
-    mask?: string;
-    showCursor?: boolean;
-    highlightPastedText?: boolean;
 }
 declare const TextInputWrapper: React.FC<TextInputWrapperProps>;
 export default TextInputWrapper;

package/dist/components/TextInputWrapper.js

@@ -1,15 +1,124 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import TextInput from 'ink-text-input';
+import { useReducer, useEffect, useRef, useMemo, } from 'react';
+import { Text, useInput } from 'ink';
+import chalk from 'chalk';
 import stripAnsi from 'strip-ansi';
-const TextInputWrapper = ({ value, onChange, ...props }) => {
-    const handleChange = (newValue) => {
-        // First strip all ANSI escape sequences
-        let cleanedValue = stripAnsi(newValue);
-        // Then specifically remove bracketed paste mode markers that might remain
-        // These sometimes appear as literal text after ANSI stripping
-        cleanedValue = cleanedValue.replace(/\[200~/g, '').replace(/\[201~/g, '');
-        onChange(cleanedValue);
-    };
-    return _jsx(TextInput, { value: value, onChange: handleChange, ...props });
+const reducer = (state, action) => {
+    switch (action.type) {
+        case 'move-cursor-left': {
+            return {
+                ...state,
+                cursorOffset: Math.max(0, state.cursorOffset - 1),
+            };
+        }
+        case 'move-cursor-right': {
+            return {
+                ...state,
+                cursorOffset: Math.min(state.value.length, state.cursorOffset + 1),
+            };
+        }
+        case 'insert': {
+            return {
+                value: state.value.slice(0, state.cursorOffset) +
+                    action.text +
+                    state.value.slice(state.cursorOffset),
+                cursorOffset: state.cursorOffset + action.text.length,
+            };
+        }
+        case 'delete': {
+            if (state.cursorOffset === 0)
+                return state;
+            const newOffset = state.cursorOffset - 1;
+            return {
+                value: state.value.slice(0, newOffset) + state.value.slice(newOffset + 1),
+                cursorOffset: newOffset,
+            };
+        }
+        case 'set': {
+            return {
+                value: action.value,
+                cursorOffset: action.value.length,
+            };
+        }
+    }
+};
+function cleanInput(input) {
+    let cleaned = stripAnsi(input);
+    cleaned = cleaned.replace(/\[200~/g, '').replace(/\[201~/g, '');
+    return cleaned;
+}
+const cursor = chalk.inverse(' ');
+const TextInputWrapper = ({ value, onChange, onSubmit, placeholder = '', focus = true, }) => {
+    const [state, dispatch] = useReducer(reducer, {
+        value,
+        cursorOffset: value.length,
+    });
+    const lastReportedValue = useRef(value);
+    // Sync external value changes into internal state
+    useEffect(() => {
+        if (value !== lastReportedValue.current) {
+            lastReportedValue.current = value;
+            dispatch({ type: 'set', value });
+        }
+    }, [value]);
+    // Report internal state changes to parent
+    useEffect(() => {
+        if (state.value !== lastReportedValue.current) {
+            lastReportedValue.current = state.value;
+            onChange(state.value);
+        }
+    }, [state.value, onChange]);
+    useInput((input, key) => {
+        if (key.upArrow ||
+            key.downArrow ||
+            (key.ctrl && input === 'c') ||
+            key.tab ||
+            (key.shift && key.tab)) {
+            return;
+        }
+        if (key.return) {
+            onSubmit?.(state.value);
+            return;
+        }
+        if (key.leftArrow) {
+            dispatch({ type: 'move-cursor-left' });
+        }
+        else if (key.rightArrow) {
+            dispatch({ type: 'move-cursor-right' });
+        }
+        else if (key.backspace || key.delete) {
+            dispatch({ type: 'delete' });
+        }
+        else {
+            const cleaned = cleanInput(input);
+            if (cleaned) {
+                dispatch({ type: 'insert', text: cleaned });
+            }
+        }
+    }, { isActive: focus });
+    const renderedPlaceholder = useMemo(() => {
+        if (!focus) {
+            return placeholder ? chalk.dim(placeholder) : '';
+        }
+        return placeholder.length > 0
+            ? chalk.inverse(placeholder[0]) + chalk.dim(placeholder.slice(1))
+            : cursor;
+    }, [focus, placeholder]);
+    const renderedValue = useMemo(() => {
+        if (!focus) {
+            return state.value;
+        }
+        let result = state.value.length > 0 ? '' : cursor;
+        let index = 0;
+        for (const char of state.value) {
+            result += index === state.cursorOffset ? chalk.inverse(char) : char;
+            index++;
+        }
+        if (state.value.length > 0 && state.cursorOffset === state.value.length) {
+            result += cursor;
+        }
+        return result;
+    }, [focus, state.value, state.cursorOffset]);
+    return (_jsx(Text, { children: state.value.length > 0 ? renderedValue : renderedPlaceholder }));
 };
 export default TextInputWrapper;

package/dist/services/sessionManager.test.js

@@ -164,18 +164,6 @@ describe('SessionManager', () => {
             expect(spawn).toHaveBeenCalledWith('opencode', ['run', '--prompt', 'implement prompt flow'], expect.any(Object));
             expect(mockPty.write).not.toHaveBeenCalled();
         });
-        it('writes the initial prompt to stdin for unknown commands', async () => {
-            vi.mocked(configReader.getDefaultPreset).mockReturnValue({
-                id: '1',
-                name: 'Custom',
-                command: 'custom-agent',
-                args: ['--interactive'],
-            });
-            vi.mocked(spawn).mockReturnValue(mockPty);
-            await Effect.runPromise(sessionManager.createSessionWithPresetEffect('/test/worktree', undefined, 'implement prompt flow'));
-            expect(spawn).toHaveBeenCalledWith('custom-agent', ['--interactive'], expect.any(Object));
-            expect(mockPty.write).toHaveBeenCalledWith('implement prompt flow\r');
-        });
         it('should fall back to default preset if specified preset not found', async () => {
             // Setup mocks
             vi.mocked(configReader.getPresetByIdEffect).mockReturnValue(Either.left(new ValidationError({

package/dist/services/worktreeNameGenerator.d.ts

@@ -2,6 +2,7 @@ import { Effect } from 'effect';
 import { ProcessError } from '../types/errors.js';
 export declare const extractBranchNameFromOutput: (stdout: string) => string;
 export declare const deduplicateBranchName: (name: string, existingBranches: string[]) => string;
+export declare const generateFallbackBranchName: (existingBranches?: string[]) => string;
 export declare class WorktreeNameGenerator {
     generateBranchNameEffect(userPrompt: string, baseBranch: string, existingBranches?: string[]): Effect.Effect<string, ProcessError, never>;
 }

package/dist/services/worktreeNameGenerator.js

@@ -1,3 +1,4 @@
+import { randomBytes } from 'crypto';
 import { Effect } from 'effect';
 import { execFile } from 'child_process';
 import { ProcessError } from '../types/errors.js';
@@ -121,6 +122,15 @@ export const deduplicateBranchName = (name, existingBranches) => {
         }
     }
 };
+export const generateFallbackBranchName = (existingBranches) => {
+    const date = new Date();
+    const dateStr = `${date.getFullYear()}${String(date.getMonth() + 1).padStart(2, '0')}${String(date.getDate()).padStart(2, '0')}`;
+    const randomSuffix = randomBytes(3).toString('hex');
+    const name = `${dateStr}-${randomSuffix}`;
+    return existingBranches
+        ? deduplicateBranchName(name, existingBranches)
+        : name;
+};
 export class WorktreeNameGenerator {
     generateBranchNameEffect(userPrompt, baseBranch, existingBranches) {
         return Effect.tryPromise({
@@ -141,7 +151,15 @@ export class WorktreeNameGenerator {
                         reject(new Error('Timed out while generating a branch name with `claude -p`'));
                     });
                 }, DEFAULT_TIMEOUT_MS);
-                child = execFile('claude', ['-p', '--output-format', 'json', '--json-schema', JSON_SCHEMA], {
+                child = execFile('claude', [
+                    '-p',
+                    '--model',
+                    'haiku',
+                    '--output-format',
+                    'json',
+                    '--json-schema',
+                    JSON_SCHEMA,
+                ], {
                     encoding: 'utf8',
                     maxBuffer: 1024 * 1024,
                 }, (error, stdout) => {

package/dist/services/worktreeNameGenerator.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { deduplicateBranchName, extractBranchNameFromOutput, worktreeNameGenerator as generator, } from './worktreeNameGenerator.js';
+import { deduplicateBranchName, extractBranchNameFromOutput, generateFallbackBranchName, worktreeNameGenerator as generator, } from './worktreeNameGenerator.js';
 describe('WorktreeNameGenerator output parsing', () => {
     it('normalizes direct json branchName responses', async () => {
         const value = extractBranchNameFromOutput('{"branchName":"feature/add prompt"}');
@@ -33,3 +33,15 @@ describe('deduplicateBranchName', () => {
         expect(deduplicateBranchName('Feature/New', ['feature/new'])).toBe('Feature/New-2');
     });
 });
+describe('generateFallbackBranchName', () => {
+    it('returns a name matching YYYYMMDD-hex pattern', () => {
+        const name = generateFallbackBranchName();
+        expect(name).toMatch(/^\d{8}-[0-9a-f]{6}$/);
+    });
+    it('deduplicates against existing branches', () => {
+        const first = generateFallbackBranchName();
+        const name = generateFallbackBranchName([first]);
+        // Either it's different (random collision unlikely) or it has a -2 suffix
+        expect(name).not.toBe(first);
+    });
+});

package/dist/services/worktreeService.js

@@ -662,6 +662,21 @@ 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) => {
@@ -900,6 +915,17 @@ export class WorktreeService {
                     stderr: 'Cannot delete the main worktree',
                 }));
             }
+            // Prevent deleting the worktree that contains the current working directory
+            const resolvedWorktreePath = path.resolve(worktreePath);
+            const resolvedCwd = path.resolve(process.cwd());
+            if (resolvedCwd === resolvedWorktreePath ||
+                resolvedCwd.startsWith(resolvedWorktreePath + path.sep)) {
+                return yield* Effect.fail(new GitError({
+                    command: 'git worktree remove',
+                    exitCode: 1,
+                    stderr: `Cannot delete the worktree at "${worktreePath}" because it is the current working directory`,
+                }));
+            }
             // Remove the worktree
             yield* Effect.try({
                 try: () => {

package/dist/services/worktreeService.test.js

@@ -757,6 +757,36 @@ branch refs/heads/main
                 expect.fail('Should have returned Left with GitError');
             }
         });
+        it('should return Effect that fails with GitError when trying to delete worktree matching cwd', async () => {
+            const cwdPath = process.cwd();
+            mockedExecSync.mockImplementation((cmd, _options) => {
+                if (typeof cmd === 'string') {
+                    if (cmd === 'git rev-parse --git-common-dir') {
+                        return '/fake/path/.git\n';
+                    }
+                    if (cmd === 'git worktree list --porcelain') {
+                        return `worktree /fake/path
+HEAD abcd1234
+branch refs/heads/main
+
+worktree ${cwdPath}
+HEAD efgh5678
+branch refs/heads/feature
+`;
+                    }
+                }
+                throw new Error('Command not mocked: ' + cmd);
+            });
+            const effect = service.deleteWorktreeEffect(cwdPath);
+            const result = await Effect.runPromise(Effect.either(effect));
+            if (result._tag === 'Left') {
+                expect(result.left).toBeInstanceOf(GitError);
+                expect(result.left.stderr).toContain('because it is the current working directory');
+            }
+            else {
+                expect.fail('Should have returned Left with GitError');
+            }
+        });
     });
     describe('Effect-based mergeWorktree', () => {
         it('should return Effect with void on successful merge', async () => {

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ export interface Worktree {
     hasSession: boolean;
     gitStatus?: GitStatus;
     gitStatusError?: string;
+    lastCommitDate?: Date;
 }
 export interface Session {
     id: string;

package/dist/utils/presetPrompt.js

@@ -13,14 +13,16 @@ const PROMPT_FLAG = {
     'github-copilot': '-i',
     kimi: '-p',
 };
+const DEFAULT_DETECTION_STRATEGY = 'claude';
 export const getPromptInjectionMethod = (preset) => {
-    if (preset.detectionStrategy && PROMPT_FLAG[preset.detectionStrategy]) {
+    const strategy = preset.detectionStrategy ?? DEFAULT_DETECTION_STRATEGY;
+    if (PROMPT_FLAG[strategy]) {
         return 'flag';
     }
-    if (preset.detectionStrategy === 'claude' ||
-        preset.detectionStrategy === 'codex' ||
-        preset.detectionStrategy === 'cursor' ||
-        preset.detectionStrategy === 'cline') {
+    if (strategy === 'claude' ||
+        strategy === 'codex' ||
+        strategy === 'cursor' ||
+        strategy === 'cline') {
         return 'final-arg';
     }
     return 'stdin';

package/dist/utils/presetPrompt.test.js

@@ -49,13 +49,6 @@ describe('presetPrompt', () => {
             method: 'flag',
         });
     });
-    it('falls back to stdin for unknown commands', () => {
-        expect(preparePresetLaunch({ command: 'custom-agent', args: ['--interactive'] }, 'hello')).toEqual({
-            args: ['--interactive'],
-            method: 'stdin',
-            stdinPayload: 'hello\r',
-        });
-    });
     describe('describePromptInjection', () => {
         it('describes final-arg for claude', () => {
             expect(describePromptInjection({
@@ -105,9 +98,6 @@ describe('presetPrompt', () => {
                 detectionStrategy: 'kimi',
             })).toContain('-p');
         });
-        it('describes stdin for unknown strategy', () => {
-            expect(describePromptInjection({ command: 'custom-agent' })).toContain('standard input');
-        });
     });
     describe('getPromptInjectionMethod', () => {
         it('returns final-arg for claude', () => {
@@ -158,10 +148,8 @@ describe('presetPrompt', () => {
                 detectionStrategy: 'kimi',
             })).toBe('flag');
         });
-        it('returns stdin when detectionStrategy is not set', () => {
-            expect(getPromptInjectionMethod({ command: 'claude' })).toBe('stdin');
-            expect(getPromptInjectionMethod({ command: 'opencode' })).toBe('stdin');
-            expect(getPromptInjectionMethod({ command: 'custom-agent' })).toBe('stdin');
+        it('falls back to claude strategy when detectionStrategy is not set', () => {
+            expect(getPromptInjectionMethod({ command: 'claude' })).toBe('final-arg');
         });
     });
 });

package/dist/utils/worktreeUtils.d.ts

@@ -9,14 +9,20 @@ export interface WorktreeItem {
     fileChanges: string;
     aheadBehind: string;
     parentBranch: string;
+    lastCommitDate: string;
     error?: string;
     lengths: {
         base: number;
         fileChanges: number;
         aheadBehind: number;
         parentBranch: number;
+        lastCommitDate: number;
     };
 }
+/**
+ * Format a date as a relative time string (e.g., "2h ago", "3d ago").
+ */
+export declare function formatRelativeDate(date: Date): string;
 export declare function truncateString(str: string, maxLength: number): string;
 export declare function generateWorktreeDirectory(projectPath: string, branchName: string, pattern?: string): string;
 export declare function extractBranchParts(branchName: string): {
@@ -34,6 +40,7 @@ export declare function calculateColumnPositions(items: WorktreeItem[]): {
     fileChanges: number;
     aheadBehind: number;
     parentBranch: number;
+    lastCommitDate: number;
 };
 /**
  * Assembles the final worktree label with proper column alignment

package/dist/utils/worktreeUtils.js

@@ -6,6 +6,33 @@ import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from
 // Constants
 const MAX_BRANCH_NAME_LENGTH = 70; // Maximum characters for branch name display
 const MIN_COLUMN_PADDING = 2; // Minimum spaces between columns
+/**
+ * Format a date as a relative time string (e.g., "2h ago", "3d ago").
+ */
+export function formatRelativeDate(date) {
+    const now = Date.now();
+    const diffMs = now - date.getTime();
+    const diffSec = Math.floor(diffMs / 1000);
+    const diffMin = Math.floor(diffSec / 60);
+    const diffHour = Math.floor(diffMin / 60);
+    const diffDay = Math.floor(diffHour / 24);
+    const diffWeek = Math.floor(diffDay / 7);
+    const diffMonth = Math.floor(diffDay / 30);
+    const diffYear = Math.floor(diffDay / 365);
+    if (diffYear > 0)
+        return `${diffYear}y ago`;
+    if (diffMonth > 0)
+        return `${diffMonth}mo ago`;
+    if (diffWeek > 0)
+        return `${diffWeek}w ago`;
+    if (diffDay > 0)
+        return `${diffDay}d ago`;
+    if (diffHour > 0)
+        return `${diffHour}h ago`;
+    if (diffMin > 0)
+        return `${diffMin}m ago`;
+    return 'just now';
+}
 // Utility function to truncate strings with ellipsis
 export function truncateString(str, maxLength) {
     if (str.length <= maxLength)
@@ -107,6 +134,10 @@ export function prepareWorktreeItems(worktrees, sessions) {
             // Show fetching status in dim gray
             fileChanges = '\x1b[90m[fetching...]\x1b[0m';
         }
+        // Format last commit date as dim relative time
+        const lastCommitDate = wt.lastCommitDate
+            ? `\x1b[90m${formatRelativeDate(wt.lastCommitDate)}\x1b[0m`
+            : '';
         return {
             worktree: wt,
             session,
@@ -114,12 +145,14 @@ export function prepareWorktreeItems(worktrees, sessions) {
             fileChanges,
             aheadBehind,
             parentBranch,
+            lastCommitDate,
             error,
             lengths: {
                 base: stripAnsi(baseLabel).length,
                 fileChanges: stripAnsi(fileChanges).length,
                 aheadBehind: stripAnsi(aheadBehind).length,
                 parentBranch: stripAnsi(parentBranch).length,
+                lastCommitDate: stripAnsi(lastCommitDate).length,
             },
         };
     });
@@ -132,6 +165,7 @@ export function calculateColumnPositions(items) {
     let maxBranchLength = 0;
     let maxFileChangesLength = 0;
     let maxAheadBehindLength = 0;
+    let maxParentBranchLength = 0;
     items.forEach(item => {
         // Skip items with errors for alignment calculation
         if (item.error)
@@ -139,15 +173,18 @@ export function calculateColumnPositions(items) {
         maxBranchLength = Math.max(maxBranchLength, item.lengths.base);
         maxFileChangesLength = Math.max(maxFileChangesLength, item.lengths.fileChanges);
         maxAheadBehindLength = Math.max(maxAheadBehindLength, item.lengths.aheadBehind);
+        maxParentBranchLength = Math.max(maxParentBranchLength, item.lengths.parentBranch);
     });
     // Simple column positioning
     const fileChangesColumn = maxBranchLength + MIN_COLUMN_PADDING;
     const aheadBehindColumn = fileChangesColumn + maxFileChangesLength + MIN_COLUMN_PADDING + 2;
     const parentBranchColumn = aheadBehindColumn + maxAheadBehindLength + MIN_COLUMN_PADDING + 2;
+    const lastCommitDateColumn = parentBranchColumn + maxParentBranchLength + MIN_COLUMN_PADDING + 2;
     return {
         fileChanges: fileChangesColumn,
         aheadBehind: aheadBehindColumn,
         parentBranch: parentBranchColumn,
+        lastCommitDate: lastCommitDateColumn,
     };
 }
 // Pad string to column position
@@ -175,6 +212,11 @@ export function assembleWorktreeLabel(item, columns) {
     if (item.parentBranch) {
         label =
             padTo(label, currentLength, columns.parentBranch) + item.parentBranch;
+        currentLength = columns.parentBranch + item.lengths.parentBranch;
+    }
+    if (item.lastCommitDate) {
+        label =
+            padTo(label, currentLength, columns.lastCommitDate) + item.lastCommitDate;
     }
     return label;
 }

package/dist/utils/worktreeUtils.test.js

@@ -170,11 +170,13 @@ describe('column alignment', () => {
             fileChanges: '\x1b[32m+10\x1b[0m \x1b[31m-5\x1b[0m',
             aheadBehind: '\x1b[33m↑2 ↓3\x1b[0m',
             parentBranch: '',
+            lastCommitDate: '',
             lengths: {
                 base: 19, // 'feature/test-branch'.length
                 fileChanges: 6, // '+10 -5'.length
                 aheadBehind: 5, // '↑2 ↓3'.length
                 parentBranch: 0,
+                lastCommitDate: 0,
             },
         },
         {
@@ -183,11 +185,13 @@ describe('column alignment', () => {
             fileChanges: '\x1b[32m+2\x1b[0m \x1b[31m-1\x1b[0m',
             aheadBehind: '\x1b[33m↑1\x1b[0m',
             parentBranch: '',
+            lastCommitDate: '',
             lengths: {
                 base: 4, // 'main'.length
                 fileChanges: 5, // '+2 -1'.length
                 aheadBehind: 2, // '↑1'.length
                 parentBranch: 0,
+                lastCommitDate: 0,
             },
         },
     ];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccmanager",
-	"version": "3.11.0",
+	"version": "3.11.2",
 	"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.0",
-		"@kodaikabasawa/ccmanager-darwin-x64": "3.11.0",
-		"@kodaikabasawa/ccmanager-linux-arm64": "3.11.0",
-		"@kodaikabasawa/ccmanager-linux-x64": "3.11.0",
-		"@kodaikabasawa/ccmanager-win32-x64": "3.11.0"
+		"@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"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.28.0",