ccmanager 4.3.2 → 4.4.0

package/dist/services/globalSessionOrchestrator.restore.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { EventEmitter } from 'events';
+const recordMock = vi.fn();
+const forgetMock = vi.fn();
+const renameMock = vi.fn();
+const suspendTrackingMock = vi.fn();
+vi.mock('./sessionRestoreStore.js', () => ({
+    sessionRestoreStore: {
+        record: (...args) => recordMock(...args),
+        forget: (...args) => forgetMock(...args),
+        rename: (...args) => renameMock(...args),
+        suspendTracking: () => suspendTrackingMock(),
+    },
+}));
+vi.mock('../utils/gitUtils.js', () => ({
+    getCurrentRepositoryRoot: () => '/current/repo',
+}));
+class MockSessionManager extends EventEmitter {
+    getAllSessions() {
+        return [];
+    }
+    destroy() { }
+}
+vi.mock('./sessionManager.js', () => ({
+    SessionManager: MockSessionManager,
+}));
+const { globalSessionOrchestrator } = await import('./globalSessionOrchestrator.js');
+const session = (overrides = {}) => ({
+    id: 'session-1',
+    worktreePath: '/repo/worktrees/feature',
+    presetId: 'preset-1',
+    sessionName: undefined,
+    devcontainerConfig: undefined,
+    ...overrides,
+});
+describe('GlobalSessionOrchestrator session record', () => {
+    beforeEach(() => {
+        recordMock.mockClear();
+        forgetMock.mockClear();
+        renameMock.mockClear();
+        suspendTrackingMock.mockClear();
+    });
+    it('records a session of the current repository when there is no project path', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject();
+        manager.emit('sessionCreated', session());
+        expect(recordMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'session-1',
+            projectPath: '/current/repo',
+            worktreePath: '/repo/worktrees/feature',
+            presetId: 'preset-1',
+            ownerPid: process.pid,
+        }));
+    });
+    it('records a session under the project its manager belongs to', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject('/other/project');
+        manager.emit('sessionCreated', session({ id: 'session-2' }));
+        expect(recordMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'session-2',
+            projectPath: '/other/project',
+        }));
+    });
+    it('forgets a session that was killed or exited', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject();
+        manager.emit('sessionDestroyed', session());
+        expect(forgetMock).toHaveBeenCalledWith('session-1');
+    });
+    it('keeps the record in step with a rename', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject();
+        manager.emit('sessionRenamed', session({ sessionName: 'review' }));
+        expect(renameMock).toHaveBeenCalledWith('session-1', 'review');
+    });
+    it('stops tracking before quitting, so the sessions stay restorable', () => {
+        globalSessionOrchestrator.destroyAllSessions();
+        expect(suspendTrackingMock).toHaveBeenCalled();
+    });
+});

package/dist/services/projectManager.js

@@ -2,10 +2,10 @@ import { WorktreeService } from './worktreeService.js';
 import { ENV_VARS } from '../constants/env.js';
 import { promises as fs } from 'fs';
 import path from 'path';
-import { homedir } from 'os';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { Effect } from 'effect';
 import { FileSystemError, ConfigError } from '../types/errors.js';
+import { ensureConfigDir } from '../utils/configDir.js';
 export class ProjectManager {
     currentMode;
     currentProject;
@@ -31,15 +31,7 @@ export class ProjectManager {
             this.currentMode = 'normal';
         }
         // Initialize recent projects
-        const homeDir = homedir();
-        this.configDir =
-            process.platform === 'win32'
-                ? path.join(process.env['APPDATA'] || path.join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
-                : path.join(homeDir, '.config', 'ccmanager');
-        // Ensure config directory exists
-        if (!existsSync(this.configDir)) {
-            mkdirSync(this.configDir, { recursive: true });
-        }
+        this.configDir = ensureConfigDir();
         this.dataPath = path.join(this.configDir, 'recent-projects.json');
         this.loadRecentProjects();
     }

package/dist/services/sessionManager.d.ts

@@ -83,6 +83,12 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private setupBackgroundHandler;
     private cleanupSession;
     getSessionById(id: string): Session | undefined;
+    /**
+     * Assign a user-facing name to a session. Goes through the manager rather
+     * than mutating the session object directly so that listeners (currently the
+     * restore record) learn about the new name.
+     */
+    renameSession(sessionId: string, sessionName?: string): void;
     getSessionsForWorktree(worktreePath: string): Session[];
     setSessionActive(sessionId: string, active: boolean): void;
     private emitRestoreSnapshot;

package/dist/services/sessionManager.js

@@ -342,6 +342,7 @@ export class SessionManager extends EventEmitter {
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             presetName: options.presetName,
+            presetId: options.presetId,
             detectionStrategy,
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             stateMutex: new Mutex(createInitialSessionStateData()),
@@ -385,6 +386,7 @@ export class SessionManager extends EventEmitter {
                     command,
                     fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
+                    presetId: preset.id,
                     detectionStrategy: preset.detectionStrategy,
                 });
                 if (launch.stdinPayload) {
@@ -569,6 +571,19 @@ export class SessionManager extends EventEmitter {
     getSessionById(id) {
         return this.sessions.get(id);
     }
+    /**
+     * Assign a user-facing name to a session. Goes through the manager rather
+     * than mutating the session object directly so that listeners (currently the
+     * restore record) learn about the new name.
+     */
+    renameSession(sessionId, sessionName) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.sessionName = sessionName;
+        this.emit('sessionRenamed', session);
+    }
     getSessionsForWorktree(worktreePath) {
         return Array.from(this.sessions.values()).filter(s => s.worktreePath === worktreePath);
     }
@@ -878,6 +893,7 @@ export class SessionManager extends EventEmitter {
                     command: preset.command,
                     fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
+                    presetId: preset.id,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,
                 });

package/dist/services/sessionRestoreStore.d.ts

@@ -0,0 +1,75 @@
+import { DevcontainerConfig } from '../types/index.js';
+/** Format version of the on-disk file, so future changes can be detected. */
+export declare const SESSION_RECORD_VERSION = 1;
+export declare const SESSION_RECORD_FILE_NAME = "sessions.json";
+/** A single session, described well enough to launch it again. */
+export interface SessionRecord {
+    /** Id of the in-memory session this record was written for. */
+    id: string;
+    /**
+     * Git repository root the session belongs to. Used to only offer sessions
+     * of the repository the user is actually opening.
+     */
+    projectPath: string;
+    worktreePath: string;
+    /**
+     * Id of the command preset the session was launched with. Absent when the
+     * preset could not be determined; the default preset is then used on
+     * restore. Only the id is stored — the command itself stays owned by the
+     * preset configuration.
+     */
+    presetId?: string;
+    /** User-assigned session name, if the user renamed the session. */
+    sessionName?: string;
+    /** Devcontainer commands the session was launched through, if any. */
+    devcontainerConfig?: DevcontainerConfig;
+    /**
+     * Process id of the ccmanager run that owns this session. A record whose
+     * owner process is still running belongs to another live ccmanager and must
+     * not be restored, or the same session would end up running twice.
+     */
+    ownerPid: number;
+    createdAt: number;
+}
+export declare class SessionRestoreStore {
+    private explicitFilePath?;
+    /**
+     * While true, mutations are ignored. Set just before ccmanager tears its
+     * sessions down on exit: those sessions are exactly the ones the next run
+     * should offer to restore, so their records must survive the teardown.
+     */
+    private trackingSuspended;
+    constructor(filePath?: string);
+    /**
+     * Resolved lazily rather than in the constructor so that merely importing
+     * this module does not create the configuration directory.
+     */
+    private get filePath();
+    /** All recorded sessions, including ones owned by other ccmanager runs. */
+    list(): SessionRecord[];
+    /** Add a session to the record, replacing any earlier record with the same id. */
+    record(session: SessionRecord): void;
+    /**
+     * Drop sessions from the record, so they are not offered on the next run.
+     * Called when a session ends for a reason that means it should stay ended:
+     * the user killed it, or the launched command exited by itself.
+     */
+    forget(...ids: string[]): void;
+    /**
+     * Keep a renamed session's name in the record. An absent name means the
+     * user cleared it.
+     */
+    rename(id: string, sessionName?: string): void;
+    /**
+     * Stop applying further mutations. Used when ccmanager is shutting down and
+     * destroys its sessions: without this the teardown would erase precisely the
+     * records the next run needs.
+     */
+    suspendTracking(): void;
+    /** Resume applying mutations. Counterpart of {@link suspendTracking}. */
+    resumeTracking(): void;
+    isTrackingSuspended(): boolean;
+    private read;
+    private write;
+}
+export declare const sessionRestoreStore: SessionRestoreStore;

package/dist/services/sessionRestoreStore.js

@@ -0,0 +1,138 @@
+/**
+ * @fileoverview Durable record of the sessions ccmanager currently has open,
+ * so that a later ccmanager run can offer to start them again.
+ *
+ * Only what is needed to launch the same command again is stored (which
+ * worktree, which command preset, the user-assigned session name). The
+ * terminal output and the conversation held inside the launched CLI are
+ * deliberately not stored: restoring means "run the launch command in that
+ * worktree again", not "bring back what was on screen".
+ *
+ * Every mutation is written to disk immediately and synchronously rather than
+ * on shutdown, so a crash, a `kill -9`, or a closed terminal still leaves an
+ * accurate record behind.
+ *
+ * Each mutation also re-reads the file before rewriting it. Two ccmanager
+ * processes share this one file, and a read-modify-write keeps one process's
+ * write from discarding sessions the other process recorded in the meantime.
+ */
+import path from 'path';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { ensureConfigDir } from '../utils/configDir.js';
+import { logger } from '../utils/logger.js';
+/** Format version of the on-disk file, so future changes can be detected. */
+export const SESSION_RECORD_VERSION = 1;
+export const SESSION_RECORD_FILE_NAME = 'sessions.json';
+export class SessionRestoreStore {
+    explicitFilePath;
+    /**
+     * While true, mutations are ignored. Set just before ccmanager tears its
+     * sessions down on exit: those sessions are exactly the ones the next run
+     * should offer to restore, so their records must survive the teardown.
+     */
+    trackingSuspended = false;
+    constructor(filePath) {
+        this.explicitFilePath = filePath;
+    }
+    /**
+     * Resolved lazily rather than in the constructor so that merely importing
+     * this module does not create the configuration directory.
+     */
+    get filePath() {
+        return (this.explicitFilePath ??
+            path.join(ensureConfigDir(), SESSION_RECORD_FILE_NAME));
+    }
+    /** All recorded sessions, including ones owned by other ccmanager runs. */
+    list() {
+        return this.read();
+    }
+    /** Add a session to the record, replacing any earlier record with the same id. */
+    record(session) {
+        if (this.trackingSuspended) {
+            return;
+        }
+        this.write([...this.read().filter(s => s.id !== session.id), session]);
+    }
+    /**
+     * Drop sessions from the record, so they are not offered on the next run.
+     * Called when a session ends for a reason that means it should stay ended:
+     * the user killed it, or the launched command exited by itself.
+     */
+    forget(...ids) {
+        if (this.trackingSuspended || ids.length === 0) {
+            return;
+        }
+        const dropped = new Set(ids);
+        const remaining = this.read().filter(session => !dropped.has(session.id));
+        this.write(remaining);
+    }
+    /**
+     * Keep a renamed session's name in the record. An absent name means the
+     * user cleared it.
+     */
+    rename(id, sessionName) {
+        if (this.trackingSuspended) {
+            return;
+        }
+        const sessions = this.read();
+        const target = sessions.find(session => session.id === id);
+        if (!target) {
+            return;
+        }
+        target.sessionName = sessionName;
+        this.write(sessions);
+    }
+    /**
+     * Stop applying further mutations. Used when ccmanager is shutting down and
+     * destroys its sessions: without this the teardown would erase precisely the
+     * records the next run needs.
+     */
+    suspendTracking() {
+        this.trackingSuspended = true;
+    }
+    /** Resume applying mutations. Counterpart of {@link suspendTracking}. */
+    resumeTracking() {
+        this.trackingSuspended = false;
+    }
+    isTrackingSuspended() {
+        return this.trackingSuspended;
+    }
+    read() {
+        if (!existsSync(this.filePath)) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(this.filePath, 'utf-8'));
+            if (!Array.isArray(parsed.sessions)) {
+                return [];
+            }
+            return parsed.sessions.filter(session => typeof session?.id === 'string' &&
+                typeof session?.projectPath === 'string' &&
+                typeof session?.worktreePath === 'string');
+        }
+        catch (error) {
+            // A truncated or hand-edited file must not stop ccmanager from
+            // starting; the worst outcome of ignoring it is no restore offer.
+            logger.warn(`Failed to read session records from ${this.filePath}: ${String(error)}`);
+            return [];
+        }
+    }
+    write(sessions) {
+        const contents = {
+            version: SESSION_RECORD_VERSION,
+            sessions,
+        };
+        try {
+            // Write to a sibling file and rename over the target: a crash midway
+            // through then leaves the previous complete file rather than a
+            // half-written one.
+            const tempPath = `${this.filePath}.${process.pid}.tmp`;
+            writeFileSync(tempPath, JSON.stringify(contents, null, 2));
+            renameSync(tempPath, this.filePath);
+        }
+        catch (error) {
+            logger.warn(`Failed to write session records to ${this.filePath}: ${String(error)}`);
+        }
+    }
+}
+export const sessionRestoreStore = new SessionRestoreStore();

package/dist/services/sessionRestoreStore.test.d.ts

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

package/dist/services/sessionRestoreStore.test.js

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { SessionRestoreStore, SESSION_RECORD_VERSION, } from './sessionRestoreStore.js';
+describe('SessionRestoreStore', () => {
+    let directory;
+    let filePath;
+    let store;
+    const record = (overrides = {}) => ({
+        id: 'session-1',
+        projectPath: '/repo',
+        worktreePath: '/repo/worktrees/feature',
+        presetId: 'preset-1',
+        ownerPid: 1234,
+        createdAt: 1,
+        ...overrides,
+    });
+    beforeEach(() => {
+        directory = mkdtempSync(path.join(tmpdir(), 'ccmanager-records-'));
+        filePath = path.join(directory, 'sessions.json');
+        store = new SessionRestoreStore(filePath);
+    });
+    afterEach(() => {
+        rmSync(directory, { recursive: true, force: true });
+    });
+    it('returns no sessions when nothing has been recorded yet', () => {
+        expect(store.list()).toEqual([]);
+    });
+    it('writes each recorded session to disk immediately', () => {
+        store.record(record());
+        const contents = JSON.parse(readFileSync(filePath, 'utf-8'));
+        expect(contents.version).toBe(SESSION_RECORD_VERSION);
+        expect(contents.sessions).toHaveLength(1);
+        expect(contents.sessions[0].worktreePath).toBe('/repo/worktrees/feature');
+    });
+    it('replaces an existing record with the same id instead of duplicating it', () => {
+        store.record(record());
+        store.record(record({ presetId: 'preset-2' }));
+        expect(store.list()).toHaveLength(1);
+        expect(store.list()[0]?.presetId).toBe('preset-2');
+    });
+    it('forgets the requested sessions and keeps the others', () => {
+        store.record(record({ id: 'session-1' }));
+        store.record(record({ id: 'session-2' }));
+        store.record(record({ id: 'session-3' }));
+        store.forget('session-1', 'session-3');
+        expect(store.list().map(session => session.id)).toEqual(['session-2']);
+    });
+    it('keeps a renamed session name, and clears it when the name is removed', () => {
+        store.record(record());
+        store.rename('session-1', 'review');
+        expect(store.list()[0]?.sessionName).toBe('review');
+        store.rename('session-1', undefined);
+        expect(store.list()[0]?.sessionName).toBeUndefined();
+    });
+    it('keeps records while tracking is suspended, so a shutdown does not erase them', () => {
+        store.record(record());
+        store.suspendTracking();
+        store.forget('session-1');
+        store.record(record({ id: 'session-2' }));
+        expect(store.list().map(session => session.id)).toEqual(['session-1']);
+        store.resumeTracking();
+        store.forget('session-1');
+        expect(store.list()).toEqual([]);
+    });
+    it('picks up records another process wrote instead of overwriting them', () => {
+        // Stands in for a second ccmanager writing to the shared file between
+        // this store's own writes.
+        store.record(record({ id: 'session-1' }));
+        const other = new SessionRestoreStore(filePath);
+        other.record(record({ id: 'other-session' }));
+        store.record(record({ id: 'session-2' }));
+        expect(store
+            .list()
+            .map(session => session.id)
+            .sort()).toEqual(['other-session', 'session-1', 'session-2']);
+    });
+    it('ignores a corrupted file rather than failing', () => {
+        writeFileSync(filePath, '{not json');
+        expect(store.list()).toEqual([]);
+        store.record(record());
+        expect(store.list()).toHaveLength(1);
+    });
+    it('ignores entries that are missing the fields needed to launch them', () => {
+        writeFileSync(filePath, JSON.stringify({
+            version: SESSION_RECORD_VERSION,
+            sessions: [record(), { id: 'broken' }],
+        }));
+        expect(store.list().map(session => session.id)).toEqual(['session-1']);
+    });
+});

package/dist/services/sessionRestorer.d.ts

@@ -0,0 +1,46 @@
+import { SessionRecord } from './sessionRestoreStore.js';
+export interface RestoreFailure {
+    record: SessionRecord;
+    message: string;
+}
+export interface RestoreOutcome {
+    restored: number;
+    failures: RestoreFailure[];
+}
+/**
+ * Recorded sessions that this ccmanager run may offer to launch again.
+ *
+ * @param options.projectPath - When given, only sessions of that repository are
+ * returned (single-project mode). Omit it to consider every recorded project,
+ * which is what multi-project mode does.
+ */
+export declare function listRestorableSessions(options?: {
+    projectPath?: string;
+}): SessionRecord[];
+/**
+ * Name of the command preset a record will be launched with, for display.
+ * Resolved from the current configuration rather than stored alongside the
+ * record, so a renamed preset shows its current name. Records whose preset no
+ * longer exists fall back to the default preset, as launching does.
+ */
+export declare function describeRecordPreset(record: SessionRecord): string;
+/**
+ * Launch each recorded session again, in the session manager the running
+ * ccmanager will look at for its project.
+ *
+ * Sessions are started one at a time: each one is numbered relative to the
+ * sessions already present in its worktree, which only holds if they are not
+ * created concurrently.
+ *
+ * Every record is dropped from the durable store as it is processed — a
+ * successfully restored session records itself anew under its new id, and a
+ * failed one must not keep being offered on every subsequent start.
+ */
+export declare function restoreSessions(records: SessionRecord[], options: {
+    multiProject: boolean;
+}): Promise<RestoreOutcome>;
+/**
+ * Forget the offered sessions without launching them, so declining the offer
+ * does not make it come back on the next start.
+ */
+export declare function discardRestorableSessions(records: SessionRecord[]): void;

package/dist/services/sessionRestorer.js

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Turns the durable session record written by
+ * {@link SessionRestoreStore} back into running sessions.
+ *
+ * Restoring a session means launching its command preset in its worktree
+ * again — nothing of the previous run's terminal output or conversation is
+ * brought back. An initial prompt, if the session was originally started with
+ * one, is deliberately not replayed: it was a one-off instruction, not part of
+ * the session's identity.
+ */
+import { existsSync } from 'fs';
+import { Effect, Either } from 'effect';
+import { globalSessionOrchestrator } from './globalSessionOrchestrator.js';
+import { sessionRestoreStore } from './sessionRestoreStore.js';
+import { configReader } from './config/configReader.js';
+import { formatErrorMessage } from '../utils/errorMessage.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Whether a process with this id is currently running. Used to leave alone the
+ * sessions of another ccmanager that is still open.
+ *
+ * A process id can be reused after a reboot, in which case an unrelated live
+ * process makes a record look owned and its session is silently not offered.
+ * That is the cheaper mistake: the opposite error would start a second copy of
+ * a session that is already running in another ccmanager window.
+ */
+function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        // Signal 0 performs the permission and existence checks without
+        // delivering a signal.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means the process exists but belongs to another user.
+        return (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            error.code === 'EPERM');
+    }
+}
+/**
+ * Recorded sessions that this ccmanager run may offer to launch again.
+ *
+ * @param options.projectPath - When given, only sessions of that repository are
+ * returned (single-project mode). Omit it to consider every recorded project,
+ * which is what multi-project mode does.
+ */
+export function listRestorableSessions(options = {}) {
+    return sessionRestoreStore
+        .list()
+        .filter(record => {
+        if (options.projectPath && record.projectPath !== options.projectPath) {
+            return false;
+        }
+        // The worktree may have been deleted while ccmanager was not running.
+        if (!existsSync(record.worktreePath)) {
+            logger.info(`Skipping session restore for missing worktree: ${record.worktreePath}`);
+            return false;
+        }
+        return !isProcessAlive(record.ownerPid);
+    })
+        .sort((a, b) => a.createdAt - b.createdAt);
+}
+/**
+ * Name of the command preset a record will be launched with, for display.
+ * Resolved from the current configuration rather than stored alongside the
+ * record, so a renamed preset shows its current name. Records whose preset no
+ * longer exists fall back to the default preset, as launching does.
+ */
+export function describeRecordPreset(record) {
+    const preset = record.presetId
+        ? Either.getOrElse(configReader.getPresetByIdEffect(record.presetId), () => undefined)
+        : undefined;
+    return preset?.name ?? configReader.getDefaultPreset()?.name ?? 'default';
+}
+/**
+ * Launch each recorded session again, in the session manager the running
+ * ccmanager will look at for its project.
+ *
+ * Sessions are started one at a time: each one is numbered relative to the
+ * sessions already present in its worktree, which only holds if they are not
+ * created concurrently.
+ *
+ * Every record is dropped from the durable store as it is processed — a
+ * successfully restored session records itself anew under its new id, and a
+ * failed one must not keep being offered on every subsequent start.
+ */
+export async function restoreSessions(records, options) {
+    const failures = [];
+    let restored = 0;
+    for (const record of records) {
+        sessionRestoreStore.forget(record.id);
+        // Single-project mode keeps every session in the one global manager;
+        // multi-project mode keeps a manager per project.
+        const manager = globalSessionOrchestrator.getManagerForProject(options.multiProject ? record.projectPath : undefined);
+        const sessionEffect = record.devcontainerConfig
+            ? manager.createSessionWithDevcontainerEffect(record.worktreePath, record.devcontainerConfig, record.presetId)
+            : manager.createSessionWithPresetEffect(record.worktreePath, record.presetId);
+        const result = await Effect.runPromise(Effect.either(sessionEffect));
+        if (result._tag === 'Left') {
+            const message = formatErrorMessage(result.left);
+            logger.error(`Failed to restore session in ${record.worktreePath}: ${message}`);
+            failures.push({ record, message });
+            continue;
+        }
+        if (record.sessionName) {
+            manager.renameSession(result.right.id, record.sessionName);
+        }
+        restored++;
+    }
+    return { restored, failures };
+}
+/**
+ * Forget the offered sessions without launching them, so declining the offer
+ * does not make it come back on the next start.
+ */
+export function discardRestorableSessions(records) {
+    sessionRestoreStore.forget(...records.map(record => record.id));
+}

package/dist/services/sessionRestorer.test.d.ts

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