ccmanager 4.3.2 → 4.4.0

package/README.md

@@ -14,6 +14,7 @@ https://github.com/user-attachments/assets/15914a88-e288-4ac9-94d5-8127f2e19dbf
 - Switch between sessions seamlessly
 - Visual status indicators for session states (busy, waiting, idle)
 - Create, merge, and delete worktrees from within the app
+- **Restore sessions after a restart**: reopen the sessions that were running when CCManager last exited or crashed
 - **Copy Claude Code session data** between worktrees to maintain conversation context
 - **`.worktreeinclude` support**: carry gitignored project files (`.env`, local certs) into newly created worktrees
 - Configurable keyboard shortcuts
@@ -117,6 +118,22 @@ CCManager supports per-project configuration by placing a `.ccmanager.json` file
 
 For detailed configuration options and examples, see [docs/project-config.md](docs/project-config.md).
 
+### Configuring with an AI coding agent
+
+This repository doubles as a plugin marketplace providing the **`ccmanager-config`** skill, which teaches Claude Code or Codex the whole configuration schema and ships a validator for it:
+
+```bash
+# Claude Code
+claude plugin marketplace add kbwo/ccmanager
+claude plugin install ccmanager-config@ccmanager
+
+# Codex CLI
+codex plugin marketplace add kbwo/ccmanager
+codex plugin add ccmanager-config@ccmanager
+```
+
+Then just ask — "set this repo up to run codex in ccmanager", "notify me when a session is waiting for input", "why is my `.ccmanager.json` being ignored?". See [plugins/ccmanager-config/README.md](plugins/ccmanager-config/README.md).
+
 ## Supported AI Assistants
 
 CCManager supports multiple AI coding assistants with tailored state detection for each:
@@ -221,6 +238,31 @@ A new Git worktree contains only tracked files, so gitignored files a project ne
 
 For pattern syntax, the exact selection rule, and troubleshooting, see [docs/worktree-include.md](docs/worktree-include.md).
 
+## Restoring Sessions After a Restart
+
+Closing CCManager kills the AI assistant processes it started, so reopening it normally means finding each worktree again and starting each session by hand. To avoid that, CCManager keeps a record of the sessions it currently has open, and on the next start offers to launch them again:
+
+```
+Restore previous sessions
+
+Found 2 sessions from the last time ccmanager ran. Start them again?
+
+  feature-login — Main
+  fix-timeout (review) — Codex
+
+> Restore
+  Don't restore
+```
+
+- **What is restored**: each session's command preset is run again in its worktree, under the name you had given it. The previous terminal output and the conversation held inside the assistant are *not* restored — restoring means starting the same command again, not resuming where it left off. (To carry conversation context into a *new* worktree, see [Session Data Copying](#session-data-copying).)
+- **Survives a crash**: the record is written as sessions come and go, not on exit, so a crash, a `kill -9`, or a closed terminal leaves it intact.
+- **Only sessions that were still open**: a session you killed, or one whose command exited on its own, is dropped from the record and is not offered.
+- **Declining is remembered**: choosing "Don't restore" forgets those sessions, so the offer does not come back on the next start.
+- **Scope**: normally only the repository you are opening is considered. In [Multi-Project Mode](#multi-project-mode) the sessions of every recorded project are offered together at startup.
+- **Other running instances**: sessions belonging to another CCManager that is still open are left alone, so they are not started a second time.
+
+The record lives in `~/.config/ccmanager/sessions.json` (`%APPDATA%\ccmanager\sessions.json` on Windows).
+
 ## Status Change Hooks
 
 CCManager can execute custom commands when Claude Code session status changes. This enables powerful automation workflows like desktop notifications, logging, or integration with other tools.

package/dist/components/App.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useEffect, useCallback } from 'react';
 import { useApp, useInput, Box, Text } from 'ink';
 import { Effect } from 'effect';
@@ -15,10 +15,14 @@ import RemoteBranchSelector from './RemoteBranchSelector.js';
 import LoadingSpinner from './LoadingSpinner.js';
 import SessionRename from './SessionRename.js';
 import SessionActions from './SessionActions.js';
+import RestoreSessions from './RestoreSessions.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
 import { WorktreeService } from '../services/worktreeService.js';
 import { worktreeNameGenerator, generateFallbackBranchName, } from '../services/worktreeNameGenerator.js';
 import { logger } from '../utils/logger.js';
+import { formatErrorMessage } from '../utils/errorMessage.js';
+import { getCurrentRepositoryRoot } from '../utils/gitUtils.js';
+import { discardRestorableSessions, listRestorableSessions, restoreSessions, } from '../services/sessionRestorer.js';
 import { configReader } from '../services/config/configReader.js';
 import { ENV_VARS } from '../constants/env.js';
 import { MULTI_PROJECT_ERRORS } from '../constants/error.js';
@@ -26,9 +30,17 @@ import { projectManager } from '../services/projectManager.js';
 import { generateWorktreeDirectory, isDeletableWorktree, } from '../utils/worktreeUtils.js';
 const App = ({ devcontainerConfig, multiProject, version, }) => {
     const { exit } = useApp();
-    const [view, setView] = useState(multiProject ? 'project-list' : 'menu');
     const [sessionManager, setSessionManager] = useState(() => globalSessionOrchestrator.getManagerForProject());
     const [worktreeService, setWorktreeService] = useState(() => new WorktreeService());
+    // Sessions that were open when ccmanager last ran and can be started again.
+    // Single-project mode only considers the repository being opened;
+    // multi-project mode considers every recorded project at once.
+    const [restorableSessions, setRestorableSessions] = useState(() => listRestorableSessions(multiProject ? {} : { projectPath: getCurrentRepositoryRoot() }));
+    const [view, setView] = useState(() => restorableSessions.length > 0
+        ? 'restore-sessions'
+        : multiProject
+            ? 'project-list'
+            : 'menu');
     const [activeSession, setActiveSession] = useState(null);
     const [error, setError] = useState(null);
     const [worktreeHookError, setWorktreeHookError] = useState(null);
@@ -87,21 +99,6 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
         setWorktreeHookError(null);
         handleReturnToMenu();
     }, { isActive: view === 'worktree-hook-error' });
-    // Helper function to format error messages based on error type using _tag discrimination
-    const 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}`;
-        }
-    };
     const formatPostCreationHookWarning = (error) => `Post-creation hook failed: ${error.message}`;
     const formatPreCreationHookError = (error) => error._tag === 'ProcessError'
         ? `Pre-creation hook failed: ${error.message}`
@@ -155,6 +152,31 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             setView('session');
         }, 10);
     }, []);
+    // The view the app starts on once the restore offer is out of the way.
+    const initialView = multiProject ? 'project-list' : 'menu';
+    const handleRestorePreviousSessions = useCallback(() => {
+        const records = restorableSessions;
+        setRestorableSessions([]);
+        setView('restoring-sessions');
+        void (async () => {
+            const outcome = await restoreSessions(records, {
+                multiProject: !!multiProject,
+            });
+            if (outcome.failures.length > 0) {
+                setError(`Could not restore ${outcome.failures.length} of ${records.length} sessions: ${outcome.failures
+                    .map(failure => `${failure.record.worktreePath} (${failure.message})`)
+                    .join(', ')}`);
+            }
+            navigateWithClear(initialView, () => {
+                setMenuKey(prev => prev + 1);
+            });
+        })();
+    }, [restorableSessions, multiProject, initialView, navigateWithClear]);
+    const handleDiscardPreviousSessions = useCallback(() => {
+        discardRestorableSessions(restorableSessions);
+        setRestorableSessions([]);
+        navigateWithClear(initialView);
+    }, [restorableSessions, initialView, navigateWithClear]);
     const startSessionForWorktree = useCallback(async (worktree, options) => {
         // If a specific session is provided, navigate to it directly
         if (options?.session) {
@@ -619,6 +641,12 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
             setMenuKey(prev => prev + 1);
         });
     };
+    if (view === 'restore-sessions') {
+        return (_jsx(RestoreSessions, { sessions: restorableSessions, showProject: multiProject, onRestore: handleRestorePreviousSessions, onDiscard: handleDiscardPreviousSessions }));
+    }
+    if (view === 'restoring-sessions') {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(LoadingSpinner, { message: "Restoring previous sessions...", color: "cyan" }) }));
+    }
     if (view === 'project-list' && multiProject) {
         const projectsDir = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
         if (!projectsDir) {
@@ -667,10 +695,7 @@ const App = ({ devcontainerConfig, multiProject, version, }) => {
     }
     if (view === 'rename-session' && renameTarget) {
         return (_jsx(SessionRename, { currentName: renameTarget.name, onRename: name => {
-                const session = sessionManager.getSessionById(renameTarget.id);
-                if (session) {
-                    session.sessionName = name;
-                }
+                sessionManager.renameSession(renameTarget.id, name);
                 setRenameTarget(null);
                 handleReturnToMenu();
             }, onCancel: () => {

package/dist/components/App.test.js

@@ -37,6 +37,20 @@ const configReaderMock = {
 const projectManagerMock = {
     addRecentProject: vi.fn(),
 };
+const listRestorableSessionsMock = vi.fn((_options) => []);
+const restoreSessionsMock = vi.fn(async (_records, _options) => ({
+    restored: 0,
+    failures: [],
+}));
+const discardRestorableSessionsMock = vi.fn((_records) => { });
+const createSessionRecord = (overrides = {}) => ({
+    id: 'record-1',
+    projectPath: '/repo',
+    worktreePath: '/repo/worktrees/feature',
+    ownerPid: 4242,
+    createdAt: 1,
+    ...overrides,
+});
 const worktreeNameGeneratorMock = {
     generateBranchNameEffect: vi.fn(() => Effect.succeed('fix/trim-worktree-name')),
 };
@@ -68,6 +82,15 @@ vi.mock('../services/globalSessionOrchestrator.js', () => ({
 vi.mock('../services/projectManager.js', () => ({
     projectManager: projectManagerMock,
 }));
+vi.mock('../services/sessionRestorer.js', () => ({
+    listRestorableSessions: (options) => listRestorableSessionsMock(options),
+    restoreSessions: (records, options) => restoreSessionsMock(records, options),
+    discardRestorableSessions: (records) => discardRestorableSessionsMock(records),
+    describeRecordPreset: () => 'Main',
+}));
+vi.mock('../utils/gitUtils.js', () => ({
+    getCurrentRepositoryRoot: () => '/repo',
+}));
 vi.mock('../services/config/configReader.js', () => ({
     configReader: configReaderMock,
 }));
@@ -143,6 +166,11 @@ beforeEach(() => {
     configReaderMock.getSelectPresetOnStart.mockReset();
     configReaderMock.getSelectPresetOnStart.mockReturnValue(false);
     projectManagerMock.addRecentProject.mockReset();
+    listRestorableSessionsMock.mockReset();
+    listRestorableSessionsMock.mockReturnValue([]);
+    restoreSessionsMock.mockReset();
+    restoreSessionsMock.mockResolvedValue({ restored: 0, failures: [] });
+    discardRestorableSessionsMock.mockReset();
     worktreeNameGeneratorMock.generateBranchNameEffect.mockReset();
     worktreeNameGeneratorMock.generateBranchNameEffect.mockImplementation(() => Effect.succeed('fix/trim-worktree-name'));
 });
@@ -156,6 +184,64 @@ describe('App component view state', () => {
         expect(lastFrame()).toContain('Menu View');
         unmount();
     });
+    it('offers to restore the sessions recorded by the previous run', async () => {
+        listRestorableSessionsMock.mockReturnValue([
+            createSessionRecord({ sessionName: 'review' }),
+        ]);
+        const { lastFrame, unmount } = render(_jsx(App, { version: "test" }));
+        await flush(40);
+        expect(listRestorableSessionsMock).toHaveBeenCalledWith({
+            projectPath: '/repo',
+        });
+        expect(lastFrame()).toContain('Restore previous sessions');
+        expect(lastFrame()).toContain('feature');
+        expect(lastFrame()).toContain('review');
+        unmount();
+    });
+    it('restores the recorded sessions and then shows the menu', async () => {
+        const record = createSessionRecord();
+        listRestorableSessionsMock.mockReturnValue([record]);
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await flush(40);
+        stdin.write('\r');
+        await waitForCondition(() => restoreSessionsMock.mock.calls.length > 0);
+        expect(restoreSessionsMock).toHaveBeenCalledWith([record], {
+            multiProject: false,
+        });
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('forgets the recorded sessions when the restore offer is declined', async () => {
+        const record = createSessionRecord();
+        listRestorableSessionsMock.mockReturnValue([record]);
+        const { lastFrame, stdin, unmount } = render(_jsx(App, { version: "test" }));
+        await flush(40);
+        // Move from "Restore" to "Don't restore" before confirming.
+        stdin.write('\u001B[B');
+        await flush(10);
+        stdin.write('\r');
+        await waitForCondition(() => discardRestorableSessionsMock.mock.calls.length > 0);
+        expect(discardRestorableSessionsMock).toHaveBeenCalledWith([record]);
+        expect(restoreSessionsMock).not.toHaveBeenCalled();
+        await waitForCondition(() => lastFrame()?.includes('Menu View') ?? false);
+        unmount();
+    });
+    it('considers every recorded project in multi-project mode', async () => {
+        const original = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/tmp/projects';
+        listRestorableSessionsMock.mockReturnValue([createSessionRecord()]);
+        const { lastFrame, unmount } = render(_jsx(App, { multiProject: true, version: "test" }));
+        await flush(40);
+        expect(listRestorableSessionsMock).toHaveBeenCalledWith({});
+        expect(lastFrame()).toContain('Restore previous sessions');
+        unmount();
+        if (original === undefined) {
+            delete process.env[ENV_VARS.MULTI_PROJECT_ROOT];
+        }
+        else {
+            process.env[ENV_VARS.MULTI_PROJECT_ROOT] = original;
+        }
+    });
     it('renders the project list view first in multi-project mode', async () => {
         const original = process.env[ENV_VARS.MULTI_PROJECT_ROOT];
         process.env[ENV_VARS.MULTI_PROJECT_ROOT] = '/tmp/projects';

package/dist/components/Dashboard.js

@@ -11,6 +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 { useDynamicLimit } from '../hooks/useDynamicLimit.js';
+import { useAvailableLabelWidth } from '../hooks/useAvailableLabelWidth.js';
 import { useGitStatus } from '../hooks/useGitStatus.js';
 import { truncateString, calculateColumnPositions, assembleSessionLabel, formatRelativeDate, displaySuffix, } from '../utils/worktreeUtils.js';
 import { formatGitFileChanges, formatGitAheadBehind, formatParentBranch, } from '../utils/gitStatus.js';
@@ -84,6 +85,9 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
         isSearchMode,
         hasError: !!displayError,
     });
+    // Room a row label may occupy; decides whether the session state tag gets
+    // its own aligned column or is appended to the branch name instead.
+    const availableLabelWidth = useAvailableLabelWidth();
     // Git status polling for session worktrees
     const enrichedWorktrees = useGitStatus(baseSessionWorktrees, baseSessionWorktrees.length > 0 ? 'main' : null);
     // Discover projects on mount
@@ -216,7 +220,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                 const wt = enrichedWorktrees.find(w => w.path === entry.worktree.path) ||
                     entry.worktree;
                 const stateData = entry.session.stateMutex.getSnapshot();
-                const status = ` [${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`;
+                const status = `[${getStatusDisplay(stateData.state, stateData.backgroundTaskCount, stateData.teamMemberCount)}]`;
                 const fullBranchName = wt.branch
                     ? wt.branch.replace('refs/heads/', '')
                     : wt.path.split('/').pop() || 'detached';
@@ -225,7 +229,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                 const worktreeSessionCount = sessionEntries.filter(e => e.worktree.path === entry.worktree.path &&
                     e.projectPath === entry.projectPath).length;
                 const sessionSuffix = displaySuffix(entry.session, worktreeSessionCount > 1);
-                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${sessionSuffix}${status}`;
+                const baseLabel = `${entry.projectName} :: ${branchName}${isMain}${sessionSuffix}`;
                 let fileChanges = '';
                 let aheadBehind = '';
                 let parentBranch = '';
@@ -245,6 +249,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     worktree: wt,
                     session: entry.session,
                     baseLabel,
+                    status,
                     searchableName: `${entry.projectName} :: ${fullBranchName}${isMain}`,
                     fileChanges,
                     aheadBehind,
@@ -255,6 +260,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     error: itemError,
                     lengths: {
                         base: stripAnsi(baseLabel).length,
+                        status: stripAnsi(status).length,
                         fileChanges: stripAnsi(fileChanges).length,
                         aheadBehind: stripAnsi(aheadBehind).length,
                         parentBranch: stripAnsi(parentBranch).length,
@@ -264,7 +270,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
                     },
                 };
             });
-            const columns = calculateColumnPositions(sessionWorkItems);
+            const columns = calculateColumnPositions(sessionWorkItems, availableLabelWidth);
             if (!isSearchMode) {
                 menuItems.push({
                     type: 'common',
@@ -369,6 +375,7 @@ const Dashboard = ({ projectsDir, onSelectSession, onSelectProject, onSessionAct
         projectDisplayNames,
         searchQuery,
         isSearchMode,
+        availableLabelWidth,
     ]);
     // Refresh handler
     const refreshAll = () => {

package/dist/components/Menu.js

@@ -10,6 +10,7 @@ import { prepareSessionItems, calculateColumnPositions, assembleSessionLabel, }
 import { projectManager } from '../services/projectManager.js';
 import { useSearchMode } from '../hooks/useSearchMode.js';
 import { useDynamicLimit } from '../hooks/useDynamicLimit.js';
+import { useAvailableLabelWidth } from '../hooks/useAvailableLabelWidth.js';
 import { filterSessionItemsByQuery, filterSessionItemsByState, cycleSessionStateFilter, getSessionStateFilterLabel, } from '../utils/filterByQuery.js';
 import SearchableList from './SearchableList.js';
 import { globalSessionOrchestrator } from '../services/globalSessionOrchestrator.js';
@@ -60,6 +61,9 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
     });
     // Get worktree configuration for sorting
     const worktreeConfig = configReader.getWorktreeConfig();
+    // Room a row label may occupy; decides whether the session state tag gets
+    // its own aligned column or is appended to the branch name instead.
+    const availableLabelWidth = useAvailableLabelWidth();
     useEffect(() => {
         let cancelled = false;
         // These operations are independent. Run them concurrently so the initial
@@ -154,7 +158,7 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
         const items = prepareSessionItems(worktrees, sessions, {
             sortByLastSession: worktreeConfig.sortByLastSession,
         });
-        const columnPositions = calculateColumnPositions(items);
+        const columnPositions = calculateColumnPositions(items, availableLabelWidth);
         // Filter session items based on search query, matching the name shown in
         // the menu (branch name, " (main)", and session name) plus the path, then
         // narrow to the selected session state. The two filters are independent
@@ -320,6 +324,7 @@ const Menu = ({ sessionManager, worktreeService, initialSnapshot, onSnapshotChan
         autoApprovalToggleCounter,
         sessionManager,
         worktreeConfig.sortByLastSession,
+        availableLabelWidth,
     ]);
     // Handle hotkeys
     useInput((input, key) => {

package/dist/components/RestoreSessions.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { SessionRecord } from '../services/sessionRestoreStore.js';
+interface RestoreSessionsProps {
+    sessions: SessionRecord[];
+    /** Whether to show which project each session belongs to. */
+    showProject?: boolean;
+    onRestore: () => void;
+    onDiscard: () => void;
+}
+/**
+ * Startup offer to launch the sessions that were open when ccmanager last ran.
+ *
+ * Restoring runs each session's command preset in its worktree again; the
+ * previous terminal output and conversation are not brought back. Declining
+ * forgets the listed sessions, so the offer does not reappear on the next
+ * start.
+ */
+declare const RestoreSessions: React.FC<RestoreSessionsProps>;
+export default RestoreSessions;

package/dist/components/RestoreSessions.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import path from 'path';
+import Confirmation from './Confirmation.js';
+import { describeRecordPreset } from '../services/sessionRestorer.js';
+/**
+ * Startup offer to launch the sessions that were open when ccmanager last ran.
+ *
+ * Restoring runs each session's command preset in its worktree again; the
+ * previous terminal output and conversation are not brought back. Declining
+ * forgets the listed sessions, so the offer does not reappear on the next
+ * start.
+ */
+const RestoreSessions = ({ sessions, showProject = false, onRestore, onDiscard, }) => {
+    const message = (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Found ", sessions.length, " session", sessions.length === 1 ? '' : 's', " from the last time ccmanager ran. Start", ' ', sessions.length === 1 ? 'it' : 'them', " again?"] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: sessions.map(session => (_jsxs(Text, { children: ['  ', _jsx(Text, { color: "green", children: path.basename(session.worktreePath) }), session.sessionName ? ` (${session.sessionName})` : '', _jsxs(Text, { dimColor: true, children: [' ', "\u2014 ", describeRecordPreset(session), showProject ? ` — ${path.basename(session.projectPath)}` : ''] })] }, session.id))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Each session runs its command again in its worktree. Previous output and conversation are not restored." }) })] }));
+    return (_jsx(Confirmation, { title: _jsx(Text, { bold: true, children: "Restore previous sessions" }), message: message, options: [
+            { label: 'Restore', value: 'restore', color: 'green' },
+            { label: "Don't restore", value: 'discard', color: 'red' },
+        ], onSelect: value => {
+            if (value === 'restore') {
+                onRestore();
+            }
+            else {
+                onDiscard();
+            }
+        }, hint: _jsx(Text, { dimColor: true, children: "Use \u2191\u2193 to navigate, Enter to select. Declining forgets these sessions." }) }));
+};
+export default RestoreSessions;

package/dist/hooks/useAvailableLabelWidth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Number of terminal columns a worktree/session row label may occupy.
+ * Passed to calculateColumnPositions, which drops the aligned session-state
+ * column when the resulting layout would not fit in it.
+ */
+export declare function useAvailableLabelWidth(): number;

package/dist/hooks/useAvailableLabelWidth.js

@@ -0,0 +1,15 @@
+import { useStdout } from 'ink';
+// Columns a list row spends before the assembled label: the SelectInput
+// indicator ("❯ " or two spaces) plus the number prefix ("0 ❯ " / "  ❯ ").
+const ROW_PREFIX_WIDTH = 6;
+// Terminal width assumed when stdout reports none (e.g. a non-TTY test stream).
+const FALLBACK_TERMINAL_WIDTH = 80;
+/**
+ * Number of terminal columns a worktree/session row label may occupy.
+ * Passed to calculateColumnPositions, which drops the aligned session-state
+ * column when the resulting layout would not fit in it.
+ */
+export function useAvailableLabelWidth() {
+    const { stdout } = useStdout();
+    return Math.max(0, (stdout.columns || FALLBACK_TERMINAL_WIDTH) - ROW_PREFIX_WIDTH);
+}

package/dist/services/config/globalConfigManager.js

@@ -3,27 +3,18 @@
  * This module is for internal use within the config directory only.
  * External code should use ConfigEditor or ConfigReader instead.
  */
-import { homedir } from 'os';
 import { join } from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { DEFAULT_SHORTCUTS, } from '../../types/index.js';
 import { DEFAULT_TIMEOUT_SECONDS } from '../../constants/autoApproval.js';
+import { ensureConfigDir } from '../../utils/configDir.js';
 class GlobalConfigManager {
     configPath;
     legacyShortcutsPath;
     configDir;
     config = {};
     constructor() {
-        // Determine config directory based on platform
-        const homeDir = homedir();
-        this.configDir =
-            process.platform === 'win32'
-                ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
-                : join(homeDir, '.config', 'ccmanager');
-        // Ensure config directory exists
-        if (!existsSync(this.configDir)) {
-            mkdirSync(this.configDir, { recursive: true });
-        }
+        this.configDir = ensureConfigDir();
         this.configPath = join(this.configDir, 'config.json');
         this.legacyShortcutsPath = join(this.configDir, 'shortcuts.json');
         this.loadConfig();

package/dist/services/globalSessionOrchestrator.d.ts

@@ -12,6 +12,13 @@ declare class GlobalSessionOrchestrator {
     destroyProjectSessions(projectPath: string): void;
     getProjectPaths(): string[];
     getProjectSessions(projectPath: string): Session[];
+    /**
+     * Keep the durable session record in step with one manager's sessions, so a
+     * later ccmanager run can offer to launch them again. This orchestrator is
+     * the only place that knows which project a manager belongs to, which is why
+     * the wiring lives here rather than inside SessionManager.
+     */
+    private trackSessionsForRestore;
 }
 export declare const globalSessionOrchestrator: GlobalSessionOrchestrator;
 export {};

package/dist/services/globalSessionOrchestrator.js

@@ -1,4 +1,6 @@
 import { SessionManager } from './sessionManager.js';
+import { getCurrentRepositoryRoot } from '../utils/gitUtils.js';
+import { sessionRestoreStore } from './sessionRestoreStore.js';
 class GlobalSessionOrchestrator {
     static instance;
     projectManagers = new Map();
@@ -6,6 +8,7 @@ class GlobalSessionOrchestrator {
     constructor() {
         // Create a global session manager for single-project mode
         this.globalManager = new SessionManager();
+        this.trackSessionsForRestore(this.globalManager);
     }
     static getInstance() {
         if (!GlobalSessionOrchestrator.instance) {
@@ -22,6 +25,7 @@ class GlobalSessionOrchestrator {
         let manager = this.projectManagers.get(projectPath);
         if (!manager) {
             manager = new SessionManager();
+            this.trackSessionsForRestore(manager, projectPath);
             this.projectManagers.set(projectPath, manager);
         }
         return manager;
@@ -37,6 +41,11 @@ class GlobalSessionOrchestrator {
         return sessions;
     }
     destroyAllSessions() {
+        // Every caller of this method is quitting ccmanager, and the sessions
+        // being torn down here are exactly the ones the next run should offer to
+        // restore. Stop updating the durable record first so the teardown does
+        // not erase them.
+        sessionRestoreStore.suspendTracking();
         // Destroy sessions in global manager
         this.globalManager.destroy();
         // Destroy sessions in all project managers
@@ -63,5 +72,36 @@ class GlobalSessionOrchestrator {
         }
         return [];
     }
+    /**
+     * Keep the durable session record in step with one manager's sessions, so a
+     * later ccmanager run can offer to launch them again. This orchestrator is
+     * the only place that knows which project a manager belongs to, which is why
+     * the wiring lives here rather than inside SessionManager.
+     */
+    trackSessionsForRestore(manager, projectPath) {
+        manager.on('sessionCreated', (session) => {
+            sessionRestoreStore.record({
+                id: session.id,
+                // The global manager has no project path of its own: its sessions
+                // belong to the repository ccmanager was started in.
+                projectPath: projectPath ?? getCurrentRepositoryRoot(),
+                worktreePath: session.worktreePath,
+                presetId: session.presetId,
+                sessionName: session.sessionName,
+                devcontainerConfig: session.devcontainerConfig,
+                ownerPid: process.pid,
+                createdAt: Date.now(),
+            });
+        });
+        manager.on('sessionRenamed', (session) => {
+            sessionRestoreStore.rename(session.id, session.sessionName);
+        });
+        // A destroyed session is one that should stay gone: either the user
+        // killed it or the launched command exited on its own. The exception is
+        // the teardown on quit, which suspends tracking beforehand.
+        manager.on('sessionDestroyed', (session) => {
+            sessionRestoreStore.forget(session.id);
+        });
+    }
 }
 export const globalSessionOrchestrator = GlobalSessionOrchestrator.getInstance();

package/dist/services/globalSessionOrchestrator.restore.test.d.ts

@@ -0,0 +1 @@
+export {};