ccmanager 3.11.1 → 3.11.3

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';
@@ -327,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/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/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({

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

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