ccmanager 4.3.2 → 4.4.0

package/dist/services/sessionRestorer.test.js

@@ -0,0 +1,163 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Effect, Either } from 'effect';
+import { mkdtempSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { ProcessError, ValidationError } from '../types/errors.js';
+const storedRecords = [];
+const forgetMock = vi.fn((...ids) => {
+    for (const id of ids) {
+        const index = storedRecords.findIndex(record => record.id === id);
+        if (index !== -1) {
+            storedRecords.splice(index, 1);
+        }
+    }
+});
+vi.mock('./sessionRestoreStore.js', () => ({
+    sessionRestoreStore: {
+        list: () => [...storedRecords],
+        forget: (...ids) => forgetMock(...ids),
+    },
+}));
+class MockSessionManager {
+    createSessionWithPresetEffect = vi.fn((_worktreePath, _presetId) => Effect.succeed({ id: 'new-session' }));
+    createSessionWithDevcontainerEffect = vi.fn((_worktreePath, _devcontainerConfig, _presetId) => Effect.succeed({ id: 'new-session' }));
+    renameSession = vi.fn((_id, _name) => { });
+}
+const managersByProject = new Map();
+const getManagerForProjectMock = vi.fn((projectPath) => {
+    let manager = managersByProject.get(projectPath);
+    if (!manager) {
+        manager = new MockSessionManager();
+        managersByProject.set(projectPath, manager);
+    }
+    return manager;
+});
+vi.mock('./globalSessionOrchestrator.js', () => ({
+    globalSessionOrchestrator: {
+        getManagerForProject: (projectPath) => getManagerForProjectMock(projectPath),
+    },
+}));
+vi.mock('./config/configReader.js', () => ({
+    configReader: {
+        getPresetByIdEffect: (id) => id === 'preset-1'
+            ? Either.right({ id: 'preset-1', name: 'Main' })
+            : Either.left(new ValidationError({
+                field: 'presetId',
+                constraint: 'Preset not found',
+                receivedValue: id,
+            })),
+        getDefaultPreset: () => ({ id: 'default', name: 'Default' }),
+    },
+}));
+const { listRestorableSessions, restoreSessions, discardRestorableSessions, describeRecordPreset, } = await import('./sessionRestorer.js');
+describe('sessionRestorer', () => {
+    let existingWorktree;
+    const record = (overrides = {}) => ({
+        id: 'session-1',
+        projectPath: '/repo',
+        worktreePath: existingWorktree,
+        presetId: 'preset-1',
+        // A process id that is not running, so the record counts as restorable.
+        ownerPid: 999999,
+        createdAt: 1,
+        ...overrides,
+    });
+    beforeEach(() => {
+        const directory = mkdtempSync(path.join(tmpdir(), 'ccmanager-restore-'));
+        existingWorktree = path.join(directory, 'feature');
+        mkdirSync(existingWorktree);
+        storedRecords.length = 0;
+        forgetMock.mockClear();
+        managersByProject.clear();
+        getManagerForProjectMock.mockClear();
+    });
+    describe('listRestorableSessions', () => {
+        it('offers a recorded session whose worktree still exists', () => {
+            storedRecords.push(record());
+            expect(listRestorableSessions().map(r => r.id)).toEqual(['session-1']);
+        });
+        it('skips a session whose worktree has been deleted', () => {
+            storedRecords.push(record({ worktreePath: '/gone/worktree' }));
+            expect(listRestorableSessions()).toEqual([]);
+        });
+        it('skips a session still owned by a running ccmanager', () => {
+            storedRecords.push(record({ ownerPid: process.pid }));
+            expect(listRestorableSessions()).toEqual([]);
+        });
+        it('only offers the requested project when a project path is given', () => {
+            storedRecords.push(record({ id: 'mine', projectPath: '/repo' }));
+            storedRecords.push(record({ id: 'other', projectPath: '/elsewhere' }));
+            expect(listRestorableSessions({ projectPath: '/repo' }).map(r => r.id)).toEqual(['mine']);
+        });
+        it('returns oldest first so sessions come back in the order they were opened', () => {
+            storedRecords.push(record({ id: 'second', createdAt: 20 }));
+            storedRecords.push(record({ id: 'first', createdAt: 10 }));
+            expect(listRestorableSessions().map(r => r.id)).toEqual([
+                'first',
+                'second',
+            ]);
+        });
+    });
+    describe('restoreSessions', () => {
+        it('launches the recorded preset in the recorded worktree', async () => {
+            const target = record();
+            const outcome = await restoreSessions([target], { multiProject: false });
+            const manager = managersByProject.get(undefined);
+            expect(manager.createSessionWithPresetEffect).toHaveBeenCalledWith(existingWorktree, 'preset-1');
+            expect(outcome).toEqual({ restored: 1, failures: [] });
+        });
+        it('drops the old record so the same session is not offered twice', async () => {
+            storedRecords.push(record());
+            await restoreSessions([record()], { multiProject: false });
+            expect(forgetMock).toHaveBeenCalledWith('session-1');
+            expect(storedRecords).toEqual([]);
+        });
+        it('restores the session name the user had given', async () => {
+            await restoreSessions([record({ sessionName: 'review' })], {
+                multiProject: false,
+            });
+            const manager = managersByProject.get(undefined);
+            expect(manager.renameSession).toHaveBeenCalledWith('new-session', 'review');
+        });
+        it('uses the manager of the recorded project in multi-project mode', async () => {
+            await restoreSessions([record()], { multiProject: true });
+            expect(getManagerForProjectMock).toHaveBeenCalledWith('/repo');
+        });
+        it('relaunches through the devcontainer when the session used one', async () => {
+            const devcontainerConfig = {
+                upCommand: 'devcontainer up',
+                execCommand: 'devcontainer exec',
+            };
+            await restoreSessions([record({ devcontainerConfig })], {
+                multiProject: false,
+            });
+            const manager = managersByProject.get(undefined);
+            expect(manager.createSessionWithDevcontainerEffect).toHaveBeenCalledWith(existingWorktree, devcontainerConfig, 'preset-1');
+        });
+        it('reports a failed session and carries on with the rest', async () => {
+            const failing = record({ id: 'failing' });
+            const succeeding = record({ id: 'succeeding' });
+            const manager = getManagerForProjectMock(undefined);
+            manager.createSessionWithPresetEffect.mockImplementationOnce(() => Effect.fail(new ProcessError({ command: 'claude', message: 'spawn failed' })));
+            const outcome = await restoreSessions([failing, succeeding], {
+                multiProject: false,
+            });
+            expect(outcome.restored).toBe(1);
+            expect(outcome.failures).toHaveLength(1);
+            expect(outcome.failures[0]?.record.id).toBe('failing');
+            expect(outcome.failures[0]?.message).toContain('spawn failed');
+        });
+    });
+    it('describes a record by its current preset name, falling back to the default', () => {
+        expect(describeRecordPreset(record())).toBe('Main');
+        expect(describeRecordPreset(record({ presetId: 'removed' }))).toBe('Default');
+        expect(describeRecordPreset(record({ presetId: undefined }))).toBe('Default');
+    });
+    it('forgets the sessions the user declined to restore', () => {
+        storedRecords.push(record({ id: 'a' }), record({ id: 'b' }));
+        discardRestorableSessions([record({ id: 'a' }), record({ id: 'b' })]);
+        expect(forgetMock).toHaveBeenCalledWith('a', 'b');
+        expect(storedRecords).toEqual([]);
+    });
+});

package/dist/types/index.d.ts

@@ -40,6 +40,7 @@ export interface Session {
     stateCheckInterval: NodeJS.Timeout | undefined;
     isPrimaryCommand: boolean;
     presetName: string | undefined;
+    presetId: string | undefined;
     detectionStrategy: StateDetectionStrategy | undefined;
     devcontainerConfig: DevcontainerConfig | undefined;
     /**

package/dist/utils/configDir.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Path of ccmanager's configuration/state directory. Does not touch the
+ * filesystem.
+ */
+export declare function getConfigDir(): string;
+/**
+ * Path of ccmanager's configuration/state directory, creating it first if it
+ * does not exist yet.
+ */
+export declare function ensureConfigDir(): string;

package/dist/utils/configDir.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Single source of truth for the location of ccmanager's own
+ * configuration/state directory (`~/.config/ccmanager`, or the Windows
+ * equivalent under APPDATA). Every module that needs to read or write a file
+ * belonging to ccmanager itself resolves the directory through here so the
+ * location is defined in exactly one place.
+ */
+import { homedir } from 'os';
+import path from 'path';
+import { existsSync, mkdirSync } from 'fs';
+/**
+ * Path of ccmanager's configuration/state directory. Does not touch the
+ * filesystem.
+ */
+export function getConfigDir() {
+    const homeDir = homedir();
+    return process.platform === 'win32'
+        ? path.join(process.env['APPDATA'] || path.join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
+        : path.join(homeDir, '.config', 'ccmanager');
+}
+/**
+ * Path of ccmanager's configuration/state directory, creating it first if it
+ * does not exist yet.
+ */
+export function ensureConfigDir() {
+    const configDir = getConfigDir();
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    return configDir;
+}

package/dist/utils/errorMessage.d.ts

@@ -0,0 +1,7 @@
+import { type AppError } from '../types/errors.js';
+/**
+ * Human-readable one-line rendering of an application error, for display in the
+ * TUI and for log lines. Each error type carries different fields, so the text
+ * is composed per type via the `_tag` discriminator.
+ */
+export declare function formatErrorMessage(error: AppError): string;

package/dist/utils/errorMessage.js

@@ -0,0 +1,19 @@
+/**
+ * Human-readable one-line rendering of an application error, for display in the
+ * TUI and for log lines. Each error type carries different fields, so the text
+ * is composed per type via the `_tag` discriminator.
+ */
+export function formatErrorMessage(error) {
+    switch (error._tag) {
+        case 'ProcessError':
+            return `Process error: ${error.message}`;
+        case 'ConfigError':
+            return `Configuration error (${error.reason}): ${error.details}`;
+        case 'GitError':
+            return `Git command failed: ${error.command} (exit ${error.exitCode})\n${error.stderr}`;
+        case 'FileSystemError':
+            return `File ${error.operation} failed for ${error.path}: ${error.cause}`;
+        case 'ValidationError':
+            return `Validation failed for ${error.field}: ${error.constraint}`;
+    }
+}

package/dist/utils/filterByQuery.test.js

@@ -8,6 +8,7 @@ const makeItem = (searchableName, path) => ({
         hasSession: false,
     },
     baseLabel: searchableName,
+    status: '',
     searchableName,
     fileChanges: '',
     aheadBehind: '',
@@ -15,6 +16,7 @@ const makeItem = (searchableName, path) => ({
     lastCommitDate: '',
     lengths: {
         base: 0,
+        status: 0,
         fileChanges: 0,
         aheadBehind: 0,
         parentBranch: 0,

package/dist/utils/gitUtils.d.ts

@@ -15,3 +15,4 @@ export declare function hasUncommittedChanges(worktreePath: string): boolean;
  * @returns The absolute path to the git repository root, or null if not in a git repo
  */
 export declare function getGitRepositoryRoot(cwd: string): string | null;
+export declare function getCurrentRepositoryRoot(): string;

package/dist/utils/gitUtils.js

@@ -62,3 +62,18 @@ export function getGitRepositoryRoot(cwd) {
         return null;
     }
 }
+/**
+ * Repository root of the directory ccmanager was started in.
+ *
+ * Cached after the first call: it cannot change while the process runs, and
+ * both the code that records sessions for restore and the code that looks them
+ * up need the exact same value to agree on which project a session belongs to.
+ */
+let currentRepositoryRoot;
+export function getCurrentRepositoryRoot() {
+    if (currentRepositoryRoot === undefined) {
+        const cwd = process.cwd();
+        currentRepositoryRoot = getGitRepositoryRoot(cwd) ?? path.resolve(cwd);
+    }
+    return currentRepositoryRoot;
+}

package/dist/utils/hookExecutor.test.js

@@ -393,6 +393,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -453,6 +454,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -511,6 +513,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),
@@ -571,6 +574,7 @@ describe('hookExecutor Integration Tests', () => {
                 stateCheckInterval: undefined,
                 isPrimaryCommand: true,
                 presetName: undefined,
+                presetId: undefined,
                 detectionStrategy: 'claude',
                 devcontainerConfig: undefined,
                 lastActivity: new Date(),

package/dist/utils/worktreeUtils.d.ts

@@ -6,6 +6,7 @@ export interface SessionItem {
     worktree: Worktree;
     session?: Session;
     baseLabel: string;
+    status: string;
     searchableName: string;
     fileChanges: string;
     aheadBehind: string;
@@ -14,6 +15,7 @@ export interface SessionItem {
     error?: string;
     lengths: {
         base: number;
+        status: number;
         fileChanges: number;
         aheadBehind: number;
         parentBranch: number;
@@ -66,18 +68,37 @@ export declare function prepareSessionItems(worktrees: Worktree[], sessions: Ses
     sortByLastSession?: boolean;
 }): SessionItem[];
 /**
- * Calculates column positions based on content widths.
+ * Column start positions for one rendered list, plus how the session state tag
+ * (e.g. "[○ Idle]") is placed.
  */
-export declare function calculateColumnPositions(items: SessionItem[]): {
+export interface ColumnPositions {
     fileChanges: number;
     aheadBehind: number;
     parentBranch: number;
+    status: number;
     lastCommitDate: number;
-};
+    /**
+     * true: the state tag gets its own column at `status`, so every row's tag
+     * starts at the same horizontal position, directly left of the commit date.
+     * false: the state tag is appended right after the branch name (the layout
+     * used before this column existed), because the aligned layout would not fit
+     * the terminal width given to calculateColumnPositions.
+     */
+    alignStatus: boolean;
+}
+/**
+ * Calculates column positions based on content widths.
+ *
+ * `availableWidth` is the number of terminal columns the label may occupy
+ * (i.e. terminal width minus whatever prefix the caller prepends). When the
+ * aligned-status layout would not fit in it, the layout falls back to appending
+ * the state tag to the name, which is narrower. Omit it to always align.
+ */
+export declare function calculateColumnPositions(items: SessionItem[], availableWidth?: number): ColumnPositions;
 /**
  * Assembles the final worktree label with proper column alignment
  */
-export declare function assembleSessionLabel(item: SessionItem, columns: ReturnType<typeof calculateColumnPositions>): string;
+export declare function assembleSessionLabel(item: SessionItem, columns: ColumnPositions): string;
 /**
  * Whether a worktree may be deleted by CCManager.
  *

package/dist/utils/worktreeUtils.js

@@ -206,7 +206,7 @@ function gitStatusColumns(wt, fullBranchName) {
 function buildSessionItem(wt, session, sessionSuffix) {
     const stateData = session?.stateMutex.getSnapshot();
     const status = stateData
-        ? ` [${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`
+        ? `[${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`
         : '';
     const fullBranchName = wt.branch
         ? wt.branch.replace('refs/heads/', '')
@@ -214,7 +214,7 @@ function buildSessionItem(wt, session, sessionSuffix) {
     const branchName = truncateString(fullBranchName, MAX_BRANCH_NAME_LENGTH);
     const isMain = wt.isMainWorktree ? ' (main)' : '';
     const { displaySuffix: dirSuffix, rawName: rawDirName } = formatWorktreeDirectorySuffix(wt, fullBranchName);
-    const baseLabel = `${branchName}${dirSuffix}${isMain}${sessionSuffix}${status}`;
+    const baseLabel = `${branchName}${dirSuffix}${isMain}${sessionSuffix}`;
     // Use the full (untruncated) branch name so search still matches the tail
     // of long branch names; status icons are excluded so they don't match.
     const rawDirForSearch = rawDirName ? ` @ ${rawDirName}` : '';
@@ -227,6 +227,7 @@ function buildSessionItem(wt, session, sessionSuffix) {
         worktree: wt,
         session,
         baseLabel,
+        status,
         searchableName,
         fileChanges,
         aheadBehind,
@@ -235,6 +236,7 @@ function buildSessionItem(wt, session, sessionSuffix) {
         error,
         lengths: {
             base: stripAnsi(baseLabel).length,
+            status: stripAnsi(status).length,
             fileChanges: stripAnsi(fileChanges).length,
             aheadBehind: stripAnsi(aheadBehind).length,
             parentBranch: stripAnsi(parentBranch).length,
@@ -277,35 +279,59 @@ export function prepareSessionItems(worktrees, sessions, options) {
     }
     return items;
 }
+/**
+ * Visible width of the name portion when the state tag is appended to it
+ * instead of getting its own column.
+ */
+function inlineBaseLength(item) {
+    return (item.lengths.base + (item.lengths.status ? item.lengths.status + 1 : 0));
+}
 /**
  * Calculates column positions based on content widths.
+ *
+ * `availableWidth` is the number of terminal columns the label may occupy
+ * (i.e. terminal width minus whatever prefix the caller prepends). When the
+ * aligned-status layout would not fit in it, the layout falls back to appending
+ * the state tag to the name, which is narrower. Omit it to always align.
  */
-export function calculateColumnPositions(items) {
+export function calculateColumnPositions(items, availableWidth) {
     // Calculate maximum widths from pre-calculated lengths
     let maxBranchLength = 0;
+    let maxInlineBranchLength = 0;
+    let maxStatusLength = 0;
     let maxFileChangesLength = 0;
     let maxAheadBehindLength = 0;
     let maxParentBranchLength = 0;
+    let maxLastCommitDateLength = 0;
     items.forEach(item => {
         // Skip items with errors for alignment calculation
         if (item.error)
             return;
         maxBranchLength = Math.max(maxBranchLength, item.lengths.base);
+        maxInlineBranchLength = Math.max(maxInlineBranchLength, inlineBaseLength(item));
+        maxStatusLength = Math.max(maxStatusLength, item.lengths.status);
         maxFileChangesLength = Math.max(maxFileChangesLength, item.lengths.fileChanges);
         maxAheadBehindLength = Math.max(maxAheadBehindLength, item.lengths.aheadBehind);
         maxParentBranchLength = Math.max(maxParentBranchLength, item.lengths.parentBranch);
+        maxLastCommitDateLength = Math.max(maxLastCommitDateLength, item.lengths.lastCommitDate);
     });
-    // 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,
+    // Simple column positioning. `branchWidth` is how much room the name portion
+    // gets, `statusWidth` is 0 when the state tag rides along with the name.
+    const layout = (branchWidth, statusWidth) => {
+        const fileChanges = branchWidth + MIN_COLUMN_PADDING;
+        const aheadBehind = fileChanges + maxFileChangesLength + MIN_COLUMN_PADDING + 2;
+        const parentBranch = aheadBehind + maxAheadBehindLength + MIN_COLUMN_PADDING + 2;
+        const status = parentBranch + maxParentBranchLength + MIN_COLUMN_PADDING + 2;
+        const lastCommitDate = status + (statusWidth ? statusWidth + MIN_COLUMN_PADDING : 0);
+        return { fileChanges, aheadBehind, parentBranch, status, lastCommitDate };
     };
+    const aligned = layout(maxBranchLength, maxStatusLength);
+    const fits = availableWidth === undefined ||
+        aligned.lastCommitDate + maxLastCommitDateLength <= availableWidth;
+    if (fits) {
+        return { ...aligned, alignStatus: true };
+    }
+    return { ...layout(maxInlineBranchLength, 0), alignStatus: false };
 }
 // Pad string to column position
 function padTo(str, visibleLength, column) {
@@ -315,12 +341,18 @@ function padTo(str, visibleLength, column) {
  * Assembles the final worktree label with proper column alignment
  */
 export function assembleSessionLabel(item, columns) {
-    // If there's an error, just show the base label with error appended
+    const inlineStatus = item.status
+        ? `${item.baseLabel} ${item.status}`
+        : item.baseLabel;
+    // If there's an error, just show the base label with error appended.
+    // Error rows carry no columns at all, so the state tag stays next to the name.
     if (item.error) {
-        return `${item.baseLabel} ${item.error}`;
+        return `${inlineStatus} ${item.error}`;
     }
-    let label = item.baseLabel;
-    let currentLength = item.lengths.base;
+    let label = columns.alignStatus ? item.baseLabel : inlineStatus;
+    let currentLength = columns.alignStatus
+        ? item.lengths.base
+        : inlineBaseLength(item);
     if (item.fileChanges) {
         label = padTo(label, currentLength, columns.fileChanges) + item.fileChanges;
         currentLength = columns.fileChanges + item.lengths.fileChanges;
@@ -334,6 +366,10 @@ export function assembleSessionLabel(item, columns) {
             padTo(label, currentLength, columns.parentBranch) + item.parentBranch;
         currentLength = columns.parentBranch + item.lengths.parentBranch;
     }
+    if (columns.alignStatus && item.status) {
+        label = padTo(label, currentLength, columns.status) + item.status;
+        currentLength = columns.status + item.lengths.status;
+    }
     if (item.lastCommitDate) {
         label =
             padTo(label, currentLength, columns.lastCommitDate) + item.lastCommitDate;

package/dist/utils/worktreeUtils.test.js

@@ -139,6 +139,7 @@ describe('prepareSessionItems', () => {
         stateCheckInterval: undefined,
         isPrimaryCommand: true,
         presetName: undefined,
+        presetId: undefined,
         detectionStrategy: 'claude',
         devcontainerConfig: undefined,
         stateMutex: new Mutex({
@@ -152,9 +153,12 @@ describe('prepareSessionItems', () => {
         expect(items).toHaveLength(1);
         expect(items[0]?.baseLabel).toBe('feature/test-branch');
     });
-    it('should include session status in label', () => {
+    it('should expose the session status separately from the name', () => {
         const items = prepareSessionItems([mockWorktree], [mockSession]);
-        expect(items[0]?.baseLabel).toContain('[○ Idle]');
+        // The status tag is its own field so it can be rendered as an aligned
+        // column; it must not be baked into the name portion.
+        expect(items[0]?.status).toBe('[○ Idle]');
+        expect(items[0]?.baseLabel).toBe('feature/test-branch');
     });
     it('should mark main worktree', () => {
         const mainWorktree = { ...mockWorktree, isMainWorktree: true };
@@ -249,8 +253,9 @@ describe('prepareSessionItems', () => {
                     sessionName: 'lab',
                 },
             ]);
-            // Order must be: branch, dir suffix, (no main), session suffix, status.
-            expect(items[0]?.baseLabel).toMatch(/^feature\/foo @ foo-api: lab \[.*Idle.*\]$/);
+            // Order must be: branch, dir suffix, (no main), session suffix.
+            expect(items[0]?.baseLabel).toBe('feature/foo @ foo-api: lab');
+            expect(items[0]?.status).toMatch(/^\[.*Idle.*\]$/);
         });
         it('does not break column alignment when a dir suffix is appended', () => {
             const items = prepareSessionItems([
@@ -277,6 +282,7 @@ describe('column alignment', () => {
         {
             worktree: {},
             baseLabel: 'feature/test-branch',
+            status: '',
             searchableName: 'feature/test-branch',
             fileChanges: '\x1b[32m+10\x1b[0m \x1b[31m-5\x1b[0m',
             aheadBehind: '\x1b[33m↑2 ↓3\x1b[0m',
@@ -284,6 +290,7 @@ describe('column alignment', () => {
             lastCommitDate: '',
             lengths: {
                 base: 19, // 'feature/test-branch'.length
+                status: 0,
                 fileChanges: 6, // '+10 -5'.length
                 aheadBehind: 5, // '↑2 ↓3'.length
                 parentBranch: 0,
@@ -293,6 +300,7 @@ describe('column alignment', () => {
         {
             worktree: {},
             baseLabel: 'main',
+            status: '',
             searchableName: 'main',
             fileChanges: '\x1b[32m+2\x1b[0m \x1b[31m-1\x1b[0m',
             aheadBehind: '\x1b[33m↑1\x1b[0m',
@@ -300,6 +308,7 @@ describe('column alignment', () => {
             lastCommitDate: '',
             lengths: {
                 base: 4, // 'main'.length
+                status: 0,
                 fileChanges: 5, // '+2 -1'.length
                 aheadBehind: 2, // '↑1'.length
                 parentBranch: 0,
@@ -344,3 +353,52 @@ describe('isDeletableWorktree', () => {
         expect(isDeletableWorktree({ path: '/repo/worktrees/feature', isMainWorktree: false }, '/repo')).toBe(true);
     });
 });
+describe('session status column', () => {
+    const makeItem = (baseLabel, status, lastCommitDate) => ({
+        worktree: {},
+        baseLabel,
+        status,
+        searchableName: baseLabel,
+        fileChanges: '',
+        aheadBehind: '',
+        parentBranch: '',
+        lastCommitDate,
+        lengths: {
+            base: baseLabel.length,
+            status: status.length,
+            fileChanges: 0,
+            aheadBehind: 0,
+            parentBranch: 0,
+            lastCommitDate: lastCommitDate.length,
+        },
+    });
+    const items = [
+        makeItem('feature/a-very-long-branch-name', '[○ Idle]', '1d ago'),
+        makeItem('main', '[● Busy]', '3w ago'),
+    ];
+    it('starts every status tag at the same column, just left of the date', () => {
+        const columns = calculateColumnPositions(items, 120);
+        expect(columns.alignStatus).toBe(true);
+        const labels = items.map(item => assembleSessionLabel(item, columns));
+        for (const [index, label] of labels.entries()) {
+            expect(label.indexOf(items[index].status)).toBe(columns.status);
+            expect(label.indexOf(items[index].lastCommitDate)).toBe(columns.lastCommitDate);
+        }
+        // The gap between the tag and the date is only the column padding.
+        expect(columns.lastCommitDate - columns.status).toBe('[○ Idle]'.length + 2);
+    });
+    it('falls back to appending the status to the name when too narrow', () => {
+        const columns = calculateColumnPositions(items, 40);
+        expect(columns.alignStatus).toBe(false);
+        expect(assembleSessionLabel(items[0], columns)).toContain('feature/a-very-long-branch-name [○ Idle]');
+        expect(assembleSessionLabel(items[1], columns)).toContain('main [● Busy]');
+    });
+    it('keeps the status next to the name on rows showing a git error', () => {
+        const errored = {
+            ...makeItem('main', '[○ Idle]', ''),
+            error: '[git error]',
+        };
+        const columns = calculateColumnPositions([...items, errored], 120);
+        expect(assembleSessionLabel(errored, columns)).toBe('main [○ Idle] [git error]');
+    });
+});

package/package.json

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