@minionry/minion 0.7.36

package/dist/server/services/websocket/session-history.js

@@ -0,0 +1,335 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join, resolve, sep } from 'node:path';
+import { currentSessionOrigin, exportSessionHistory, importSessionHistory, parseSessionHistoryImport, SESSION_EXPORT_EXTENSION, } from '../../cli/history-portability.js';
+import { ensureHistoryDir, loadHistory, resolveHistoryPaths, saveHistory } from '../../cli/improvisation-history-store.js';
+import { buildSuccessMovement } from '../../cli/improvisation-movements.js';
+import { writeFileAtomic } from '../../utils/file-store.js';
+import { spacePath } from '../space-layout.js';
+export function persistTranscriptSession(workingDir, opts) {
+    try {
+        const { improviseDir, historyPath } = resolveHistoryPaths(workingDir, opts.sessionId);
+        ensureHistoryDir(improviseDir);
+        const history = loadHistory(historyPath, opts.sessionId);
+        if (opts.engine)
+            history.engine = opts.engine;
+        const movement = buildSuccessMovement(opts.result, {
+            sequenceNumber: history.movements.length + 1,
+            userPrompt: opts.userPrompt,
+            execStart: opts.execStart ?? Date.now(),
+            fastMode: opts.fastMode,
+            engine: opts.engine,
+            model: opts.model,
+        }, undefined);
+        history.movements.push(movement);
+        history.totalTokens += movement.tokensUsed;
+        saveHistory(historyPath, history);
+        return historyPath;
+    }
+    catch (error) {
+        console.error('[session-history] Failed to persist transcript session:', error);
+        return null;
+    }
+}
+export function handleHistoryMessage(ctx, ws, msg, tabId, workingDir) {
+    switch (msg.type) {
+        case 'getSessions': {
+            getSessionsList(workingDir, msg.data?.limit ?? 20, msg.data?.offset ?? 0).then(result => {
+                ctx.send(ws, { type: 'sessions', tabId, data: result });
+            });
+            break;
+        }
+        case 'getSessionsCount':
+            ctx.send(ws, { type: 'sessionsCount', tabId, data: { total: getSessionsCount(workingDir) } });
+            break;
+        case 'getSessionById':
+            if (!msg.data?.sessionId)
+                throw new Error('Session ID is required');
+            ctx.send(ws, { type: 'sessionData', tabId, data: getSessionById(workingDir, msg.data.sessionId) });
+            break;
+        case 'deleteSession':
+            if (!msg.data?.sessionId)
+                throw new Error('Session ID is required');
+            ctx.send(ws, { type: 'sessionDeleted', tabId, data: deleteSession(workingDir, msg.data.sessionId) });
+            break;
+        case 'clearHistory':
+            ctx.send(ws, { type: 'historyCleared', tabId, data: clearAllSessions(workingDir) });
+            break;
+        case 'searchHistory': {
+            if (!msg.data?.query)
+                throw new Error('Search query is required');
+            const result = searchSessions(workingDir, msg.data.query, msg.data?.limit ?? 20, msg.data?.offset ?? 0);
+            ctx.send(ws, { type: 'searchResults', tabId, data: { ...result, query: msg.data.query } });
+            break;
+        }
+        case 'exportSession': {
+            const sessionId = typeof msg.data?.sessionId === 'string' ? msg.data.sessionId : '';
+            ctx.send(ws, { type: 'sessionExported', tabId, data: attempt(sessionId ? () => ({ ...exportSessionToFile(workingDir, sessionId) }) : () => { throw new Error('Session ID is required'); }, { sessionId }) });
+            break;
+        }
+        case 'importSession': {
+            const filePath = typeof msg.data?.filePath === 'string' ? msg.data.filePath : '';
+            ctx.send(ws, { type: 'sessionImported', tabId, data: attempt(filePath ? () => importSessionFromFile(workingDir, filePath) : () => { throw new Error('File path is required'); }, {}) });
+            break;
+        }
+    }
+}
+function attempt(run, context) {
+    try {
+        return { ok: true, ...run() };
+    }
+    catch (err) {
+        return { ok: false, ...context, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+function findSessionFile(workingDir, sessionId) {
+    const direct = resolveHistoryPaths(workingDir, sessionId).historyPath;
+    if (existsSync(direct))
+        return direct;
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir))
+        return null;
+    for (const filename of readdirSync(sessionsDir)) {
+        if (!filename.endsWith('.json'))
+            continue;
+        const historyPath = join(sessionsDir, filename);
+        try {
+            const parsed = JSON.parse(readFileSync(historyPath, 'utf-8'));
+            if (parsed.sessionId === sessionId)
+                return historyPath;
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export function exportSessionToFile(workingDir, sessionId) {
+    const historyPath = findSessionFile(workingDir, sessionId);
+    if (!historyPath)
+        throw new Error(`Session not found: ${sessionId}`);
+    const history = loadHistory(historyPath, sessionId);
+    const envelope = exportSessionHistory(history);
+    const exportsDir = spacePath(workingDir, 'exports');
+    mkdirSync(exportsDir, { recursive: true });
+    const fileName = `${history.sessionId.replace('improv-', '')}${SESSION_EXPORT_EXTENSION}`;
+    const filePath = join(exportsDir, fileName);
+    const body = JSON.stringify(envelope, null, 2);
+    writeFileAtomic(filePath, body, { mode: 0o644 });
+    return { sessionId: history.sessionId, fileName, filePath, sizeBytes: Buffer.byteLength(body, 'utf8') };
+}
+export function importSessionFromFile(workingDir, filePath) {
+    const root = resolve(workingDir);
+    const resolved = resolve(filePath.startsWith('/') ? filePath : join(workingDir, filePath));
+    if (resolved !== root && !resolved.startsWith(root + sep)) {
+        throw new Error('The transcript file must be inside this Space');
+    }
+    if (!existsSync(resolved))
+        throw new Error('Transcript file not found');
+    const parsed = parseSessionHistoryImport(JSON.parse(readFileSync(resolved, 'utf-8')));
+    if (!parsed.ok)
+        throw new Error(`Cannot import transcript: ${parsed.error}`);
+    const imported = importSessionHistory(parsed, { local: currentSessionOrigin(workingDir) });
+    const { improviseDir, historyPath } = resolveHistoryPaths(workingDir, imported.history.sessionId);
+    ensureHistoryDir(improviseDir);
+    saveHistory(historyPath, imported.history);
+    const firstPrompt = imported.history.movements[0]?.userPrompt ?? '';
+    return {
+        sessionId: imported.history.sessionId,
+        movementCount: imported.history.movements.length,
+        engine: imported.history.engine,
+        title: firstPrompt.slice(0, 80) + (firstPrompt.length > 80 ? '...' : ''),
+        warnings: imported.warnings,
+    };
+}
+function getSessionsCount(workingDir) {
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir))
+        return 0;
+    return readdirSync(sessionsDir).filter((name) => name.endsWith('.json')).length;
+}
+async function getSessionsList(workingDir, limit = 20, offset = 0) {
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir)) {
+        return { sessions: [], total: 0, hasMore: false };
+    }
+    const historyFiles = readdirSync(sessionsDir)
+        .filter((name) => name.endsWith('.json'))
+        .sort((a, b) => {
+        const timestampA = parseInt(a.replace('.json', ''), 10);
+        const timestampB = parseInt(b.replace('.json', ''), 10);
+        return timestampB - timestampA;
+    });
+    const total = historyFiles.length;
+    const pageFiles = historyFiles.slice(offset, offset + limit);
+    const sessions = await Promise.all(pageFiles.map(async (filename) => {
+        const historyPath = join(sessionsDir, filename);
+        try {
+            const raw = await readFile(historyPath, 'utf-8');
+            return buildSessionSummary(JSON.parse(raw));
+        }
+        catch {
+            return null;
+        }
+    }));
+    return { sessions: sessions.filter(Boolean), total, hasMore: offset + limit < total };
+}
+const MOVEMENT_PROMPT_PREVIEW_CHARS = 400;
+export function summarizeMovementForWire(movement) {
+    const prompt = typeof movement.userPrompt === 'string' ? movement.userPrompt : '';
+    return {
+        id: movement.id,
+        sequenceNumber: movement.sequenceNumber,
+        userPrompt: prompt.length > MOVEMENT_PROMPT_PREVIEW_CHARS
+            ? `${prompt.slice(0, MOVEMENT_PROMPT_PREVIEW_CHARS)}…`
+            : prompt,
+        timestamp: movement.timestamp,
+        tokensUsed: movement.tokensUsed ?? 0,
+        summary: typeof movement.summary === 'string' ? movement.summary : '',
+        filesModified: Array.isArray(movement.filesModified) ? movement.filesModified : [],
+        ...(movement.durationMs !== undefined ? { durationMs: movement.durationMs } : {}),
+        ...(movement.isAutoContinue === true ? { isAutoContinue: true } : {}),
+        ...(movement.engine !== undefined ? { engine: movement.engine } : {}),
+        ...(movement.model !== undefined ? { model: movement.model } : {}),
+    };
+}
+function getSessionById(workingDir, sessionId) {
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir))
+        return null;
+    const historyFiles = readdirSync(sessionsDir).filter((name) => name.endsWith('.json'));
+    for (const filename of historyFiles) {
+        const historyPath = join(sessionsDir, filename);
+        try {
+            const historyData = JSON.parse(readFileSync(historyPath, 'utf-8'));
+            if (historyData.sessionId === sessionId) {
+                const firstPrompt = historyData.movements?.[0]?.userPrompt || '';
+                const movements = Array.isArray(historyData.movements) ? historyData.movements : [];
+                return {
+                    sessionId: historyData.sessionId,
+                    startedAt: historyData.startedAt,
+                    lastActivityAt: historyData.lastActivityAt,
+                    totalTokens: historyData.totalTokens,
+                    engine: historyData.engine || 'claude-code',
+                    movementCount: movements.length,
+                    title: firstPrompt.slice(0, 80) + (firstPrompt.length > 80 ? '...' : ''),
+                    movements: movements.map(summarizeMovementForWire),
+                };
+            }
+        }
+        catch {
+        }
+    }
+    return null;
+}
+function deleteSession(workingDir, sessionId) {
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir))
+        return { sessionId, success: false };
+    try {
+        const historyFiles = readdirSync(sessionsDir).filter((name) => name.endsWith('.json'));
+        for (const filename of historyFiles) {
+            const historyPath = join(sessionsDir, filename);
+            try {
+                const historyData = JSON.parse(readFileSync(historyPath, 'utf-8'));
+                if (historyData.sessionId === sessionId) {
+                    unlinkSync(historyPath);
+                    return { sessionId, success: true };
+                }
+            }
+            catch {
+            }
+        }
+        return { sessionId, success: false };
+    }
+    catch (error) {
+        console.error('[WebSocketImproviseHandler] Error deleting session:', error);
+        return { sessionId, success: false };
+    }
+}
+function clearAllSessions(workingDir) {
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir))
+        return { success: true, deletedCount: 0 };
+    try {
+        const historyFiles = readdirSync(sessionsDir).filter((name) => name.endsWith('.json'));
+        let deletedCount = 0;
+        for (const filename of historyFiles) {
+            const historyPath = join(sessionsDir, filename);
+            try {
+                unlinkSync(historyPath);
+                deletedCount++;
+            }
+            catch {
+            }
+        }
+        return { success: true, deletedCount };
+    }
+    catch (error) {
+        console.error('[WebSocketImproviseHandler] Error clearing sessions:', error);
+        return { success: false, deletedCount: 0 };
+    }
+}
+function movementMatchesQuery(movements, lowerQuery) {
+    if (!movements)
+        return false;
+    return movements.some((m) => (typeof m.userPrompt === 'string' && m.userPrompt.toLowerCase().includes(lowerQuery)) ||
+        (typeof m.summary === 'string' && m.summary.toLowerCase().includes(lowerQuery)) ||
+        (typeof m.assistantResponse === 'string' && m.assistantResponse.toLowerCase().includes(lowerQuery)));
+}
+function buildSessionSummary(historyData) {
+    const movements = historyData.movements;
+    const firstPrompt = (typeof movements?.[0]?.userPrompt === 'string' ? movements[0].userPrompt : '') || '';
+    const movementPreviews = (movements || []).slice(0, 3).map((m) => ({
+        userPrompt: (typeof m.userPrompt === 'string' ? m.userPrompt : '').slice(0, 100) || ''
+    }));
+    const engine = typeof historyData.engine === 'string' && historyData.engine ? historyData.engine : 'claude-code';
+    return {
+        sessionId: historyData.sessionId,
+        startedAt: historyData.startedAt,
+        lastActivityAt: historyData.lastActivityAt,
+        totalTokens: historyData.totalTokens,
+        engine,
+        movementCount: movements?.length || 0,
+        title: firstPrompt.slice(0, 80) + (firstPrompt.length > 80 ? '...' : ''),
+        movements: movementPreviews
+    };
+}
+function searchSessions(workingDir, query, limit = 20, offset = 0) {
+    const sessionsDir = spacePath(workingDir, 'history');
+    if (!existsSync(sessionsDir))
+        return { sessions: [], total: 0, hasMore: false };
+    const lowerQuery = query.toLowerCase();
+    try {
+        const historyFiles = readdirSync(sessionsDir)
+            .filter((name) => name.endsWith('.json'))
+            .sort((a, b) => {
+            const timestampA = parseInt(a.replace('.json', ''), 10);
+            const timestampB = parseInt(b.replace('.json', ''), 10);
+            return timestampB - timestampA;
+        });
+        const allMatches = [];
+        for (const filename of historyFiles) {
+            try {
+                const content = readFileSync(join(sessionsDir, filename), 'utf-8');
+                const historyData = JSON.parse(content);
+                if (movementMatchesQuery(historyData.movements, lowerQuery)) {
+                    allMatches.push(buildSessionSummary(historyData));
+                }
+            }
+            catch {
+            }
+        }
+        const total = allMatches.length;
+        return {
+            sessions: allMatches.slice(offset, offset + limit),
+            total,
+            hasMore: offset + limit < total
+        };
+    }
+    catch (error) {
+        console.error('[WebSocketImproviseHandler] Error searching sessions:', error);
+        return { sessions: [], total: 0, hasMore: false };
+    }
+}

package/dist/server/services/websocket/session-initialization.js

@@ -0,0 +1,315 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { getEffortLevel, getFastMode, getModel } from '../settings.js';
+import { getPendingQuestionsForTab } from './ask-user-question-bridge.js';
+import { scopeRepoPath, scopeRepoWorktrees, scopeWorktreePath } from './handler-context.js';
+import { resolveEngineForSession, restoreWorktreeFromRegistry, setupSessionListeners } from './session-handlers.js';
+import { broadcastTimelineEvents } from './tab-broadcast.js';
+import { replayTabEventsSince } from './tab-event-replay.js';
+function extractLastSeenSeq(data) {
+    if (!data || typeof data !== 'object')
+        return undefined;
+    const candidate = data.lastSeenSeq;
+    return typeof candidate === 'number' && Number.isFinite(candidate) ? candidate : undefined;
+}
+function extractWebManaged(data) {
+    if (!data || typeof data !== 'object')
+        return false;
+    return data.webManaged === true;
+}
+function inflightEtaPayload(session) {
+    if (!session.isExecuting)
+        return {};
+    return {
+        ...(session.etaProfile ? { etaProfile: session.etaProfile } : {}),
+        executionTarget: session.getExecutionTarget(),
+    };
+}
+function resurfacePendingQuestions(ctx, ws, tabId) {
+    for (const { toolUseId, questions } of getPendingQuestionsForTab(tabId)) {
+        ctx.send(ws, { type: 'askUserQuestion', tabId, data: { toolUseId, questions } });
+    }
+}
+function buildFullSnapshotData(session, options) {
+    const isExecuting = session.isExecuting;
+    return {
+        ...session.getSessionInfo(),
+        engine: resolveEngineForSession(session),
+        outputHistory: [],
+        isExecuting,
+        ...(isExecuting && session.executionStartTimestamp
+            ? { executionStartTimestamp: session.executionStartTimestamp }
+            : {}),
+        ...inflightEtaPayload(session),
+        ...(options.worktreePath
+            ? { worktreePath: options.worktreePath, worktreeBranch: options.worktreeBranch }
+            : {}),
+        ...(options.repoPath ? { repoPath: options.repoPath } : {}),
+        repoWorktrees: options.repoWorktrees,
+        ...(options.engineOverride ? { engineOverride: options.engineOverride } : {}),
+        ...(options.promptQueue?.length ? { promptQueue: options.promptQueue } : {}),
+        ...(options.replayGap ? { replayGap: true } : {}),
+        ...(options.extra ?? {}),
+    };
+}
+function decideRecoveryMode(result, lastSeenSeq) {
+    if (lastSeenSeq === undefined)
+        return 'snapshot';
+    if (result.hadGap)
+        return 'snapshot';
+    return 'incremental';
+}
+function sendResumedTabInitialized(ctx, ws, tabId, session, mode, replay, options) {
+    const engine = resolveEngineForSession(session);
+    if (mode === 'snapshot') {
+        ctx.send(ws, {
+            type: 'tabInitialized',
+            tabId,
+            engine,
+            data: buildFullSnapshotData(session, {
+                worktreePath: options.worktreePath,
+                worktreeBranch: options.worktreeBranch,
+                repoPath: options.repoPath,
+                repoWorktrees: options.repoWorktrees,
+                engineOverride: options.engineOverride,
+                promptQueue: options.promptQueue,
+                replayGap: replay.hadGap,
+                extra: options.extra,
+            }),
+        });
+        return;
+    }
+    ctx.send(ws, {
+        type: 'tabInitialized',
+        tabId,
+        engine,
+        data: {
+            ...session.getSessionInfo(),
+            engine,
+            resumedFromSeq: true,
+            ...(options.worktreePath
+                ? { worktreePath: options.worktreePath, worktreeBranch: options.worktreeBranch }
+                : {}),
+            ...(options.repoPath ? { repoPath: options.repoPath } : {}),
+            repoWorktrees: options.repoWorktrees,
+            ...(options.engineOverride ? { engineOverride: options.engineOverride } : {}),
+            ...(options.promptQueue?.length ? { promptQueue: options.promptQueue } : {}),
+            ...(options.extra ?? {}),
+        },
+    });
+}
+function tryResumeFromDisk(ctx, ws, tabId, workingDir, registrySessionId, tabMap, registry, lastSeenSeq) {
+    try {
+        const diskSession = ImprovisationSessionManager.resumeFromHistory(workingDir, registrySessionId);
+        setupSessionListeners(ctx, diskSession, ws, tabId);
+        const diskSessionId = diskSession.getSessionInfo().sessionId;
+        ctx.sessions.set(diskSessionId, diskSession);
+        if (tabMap)
+            tabMap.set(tabId, diskSessionId);
+        registry.touchTab(tabId);
+        registry.markTabPersisted(tabId);
+        const regTab = registry.getTab(tabId);
+        restoreWorktreeFromRegistry(ctx, registry, tabId);
+        const worktreePath = scopeWorktreePath(ctx, tabId);
+        const worktreeBranch = ctx.gitBranches.get(tabId);
+        const repoPath = scopeRepoPath(ctx, tabId);
+        const repoWorktrees = scopeRepoWorktrees(ctx, tabId);
+        const replay = replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+        const mode = decideRecoveryMode(replay, lastSeenSeq);
+        sendResumedTabInitialized(ctx, ws, tabId, diskSession, mode, replay, {
+            worktreePath,
+            worktreeBranch,
+            repoPath,
+            repoWorktrees,
+            engineOverride: regTab?.engineOverride,
+            promptQueue: regTab?.promptQueue,
+            extra: { execution: diskSession.getHistory().execution },
+        });
+        resurfacePendingQuestions(ctx, ws, tabId);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function initializeTab(ctx, ws, tabId, workingDir, tabName, rawData) {
+    const tabMap = ctx.connections.get(ws);
+    const registry = ctx.getRegistry(workingDir);
+    const lastSeenSeq = extractLastSeenSeq(rawData);
+    const existingSessionId = tabMap?.get(tabId);
+    if (existingSessionId) {
+        const existingSession = ctx.sessions.get(existingSessionId);
+        if (existingSession) {
+            reattachSession(ctx, existingSession, ws, tabId, registry, lastSeenSeq);
+            return;
+        }
+    }
+    const registrySessionId = registry.getTabSession(tabId);
+    if (registrySessionId) {
+        const inMemorySession = ctx.sessions.get(registrySessionId);
+        if (inMemorySession) {
+            reattachSession(ctx, inMemorySession, ws, tabId, registry, lastSeenSeq);
+            return;
+        }
+        if (tryResumeFromDisk(ctx, ws, tabId, workingDir, registrySessionId, tabMap, registry, lastSeenSeq)) {
+            return;
+        }
+    }
+    const existingTab = registry.getTab(tabId);
+    const webManaged = extractWebManaged(rawData);
+    if (!existingTab && !webManaged) {
+        ctx.send(ws, { type: 'tabNotFound', tabId });
+        return;
+    }
+    const session = new ImprovisationSessionManager({
+        workingDir,
+        ...(registrySessionId ? { sessionId: registrySessionId } : {}),
+        model: getModel(),
+        effortLevel: getEffortLevel(),
+        fastMode: getFastMode(),
+    });
+    setupSessionListeners(ctx, session, ws, tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    if (tabMap) {
+        tabMap.set(tabId, sessionId);
+    }
+    registry.registerTab(tabId, sessionId, tabName || existingTab?.tabName, webManaged);
+    const engine = resolveEngineForSession(session);
+    const replay = replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+    const mode = decideRecoveryMode(replay, lastSeenSeq);
+    ctx.send(ws, {
+        type: 'tabInitialized',
+        tabId,
+        engine,
+        data: {
+            ...session.getSessionInfo(),
+            ...(mode === 'incremental' ? { resumedFromSeq: true } : {}),
+            ...(replay.hadGap ? { replayGap: true } : {}),
+        }
+    });
+}
+function liveSessionForResume(ctx, tabMap, tabId, registry, historicalSessionId) {
+    const ownsIt = tabMap?.get(tabId) === historicalSessionId || registry.getTabSession(tabId) === historicalSessionId;
+    return ownsIt ? ctx.sessions.get(historicalSessionId) : undefined;
+}
+function retireDisplacedSession(ctx, tabId, boundSessionId, incoming) {
+    broadcastTimelineEvents(ctx, tabId, ctx.chatTimelines.getOrCreate(tabId).reset(), resolveEngineForSession(incoming));
+    ctx.chatTimelines.delete(tabId);
+    if (boundSessionId === undefined)
+        return;
+    const displaced = ctx.sessions.get(boundSessionId);
+    if (!displaced || displaced === incoming)
+        return;
+    displaced.destroy();
+    ctx.sessions.delete(boundSessionId);
+}
+function constructResumedSession(workingDir, historicalSessionId, registrySessionId, knownMissing) {
+    if (!knownMissing) {
+        try {
+            const session = ImprovisationSessionManager.resumeFromHistory(workingDir, historicalSessionId);
+            session.applyOverrides(session.getHistory().execution ?? { model: getModel(), effortLevel: getEffortLevel(), fastMode: getFastMode() });
+            return { session, isNewSession: false };
+        }
+        catch (error) {
+            console.warn(`[WebSocketImproviseHandler] Could not resume session ${historicalSessionId}: ${error instanceof Error ? error.message : String(error)}. Creating new session.`);
+        }
+    }
+    const session = new ImprovisationSessionManager({
+        workingDir,
+        ...(registrySessionId ? { sessionId: registrySessionId } : {}),
+        model: getModel(),
+        effortLevel: getEffortLevel(),
+        fastMode: getFastMode(),
+    });
+    return { session, isNewSession: true };
+}
+export async function resumeHistoricalSession(ctx, ws, tabId, workingDir, historicalSessionId, rawData) {
+    const tabMap = ctx.connections.get(ws);
+    const registry = ctx.getRegistry(workingDir);
+    const lastSeenSeq = extractLastSeenSeq(rawData);
+    const boundSessionId = tabMap?.get(tabId) ?? registry.getTabSession(tabId);
+    const live = liveSessionForResume(ctx, tabMap, tabId, registry, historicalSessionId);
+    if (live) {
+        reattachSession(ctx, live, ws, tabId, registry, lastSeenSeq);
+        return;
+    }
+    const registrySessionId = registry.getTabSession(tabId);
+    const isRebind = boundSessionId !== undefined && boundSessionId !== historicalSessionId;
+    const knownMissing = !isRebind && registry.isTabHistoryMissing(tabId) && !registry.hasWrittenHistoryFile(historicalSessionId);
+    const { session, isNewSession } = constructResumedSession(workingDir, historicalSessionId, registrySessionId, knownMissing);
+    if (isRebind)
+        retireDisplacedSession(ctx, tabId, boundSessionId, session);
+    setupSessionListeners(ctx, session, ws, tabId);
+    const sessionId = session.getSessionInfo().sessionId;
+    ctx.sessions.set(sessionId, session);
+    if (tabMap) {
+        tabMap.set(tabId, sessionId);
+    }
+    registry.registerTab(tabId, sessionId, registry.getTab(tabId)?.tabName);
+    if (isNewSession)
+        registry.markTabHistoryMissing(tabId);
+    const resumeSeq = isRebind ? undefined : lastSeenSeq;
+    const replay = replayTabEventsSince(ctx, ws, tabId, resumeSeq);
+    const mode = decideRecoveryMode(replay, resumeSeq);
+    sendResumedTabInitialized(ctx, ws, tabId, session, mode, replay, {
+        repoWorktrees: scopeRepoWorktrees(ctx, tabId),
+        extra: {
+            resumeFailed: isNewSession,
+            ...(isNewSession ? { sessionReset: true } : {}),
+            originalSessionId: isNewSession ? historicalSessionId : undefined,
+            execution: session.getHistory().execution,
+        },
+    });
+}
+function reattachSession(ctx, session, ws, tabId, registry, lastSeenSeq) {
+    setupSessionListeners(ctx, session, ws, tabId);
+    const tabMap = ctx.connections.get(ws);
+    const sessionId = session.getSessionInfo().sessionId;
+    if (tabMap)
+        tabMap.set(tabId, sessionId);
+    registry.touchTab(tabId);
+    const regTab = registry.getTab(tabId);
+    restoreWorktreeFromRegistry(ctx, registry, tabId);
+    const worktreePath = scopeWorktreePath(ctx, tabId);
+    const worktreeBranch = ctx.gitBranches.get(tabId);
+    const repoPath = scopeRepoPath(ctx, tabId);
+    const repoWorktrees = scopeRepoWorktrees(ctx, tabId);
+    const inflightEta = inflightEtaPayload(session);
+    const replay = replayTabEventsSince(ctx, ws, tabId, lastSeenSeq);
+    const mode = decideRecoveryMode(replay, lastSeenSeq);
+    if (mode === 'incremental') {
+        ctx.send(ws, {
+            type: 'tabInitialized',
+            tabId,
+            data: {
+                ...session.getSessionInfo(),
+                resumedFromSeq: true,
+                isExecuting: session.isExecuting,
+                ...(session.isExecuting && session.executionStartTimestamp ? { executionStartTimestamp: session.executionStartTimestamp } : {}),
+                ...inflightEta,
+                ...(worktreePath ? { worktreePath, worktreeBranch } : {}),
+                ...(repoPath ? { repoPath } : {}),
+                repoWorktrees,
+            }
+        });
+        resurfacePendingQuestions(ctx, ws, tabId);
+        return;
+    }
+    ctx.send(ws, {
+        type: 'tabInitialized',
+        tabId,
+        engine: resolveEngineForSession(session),
+        data: buildFullSnapshotData(session, {
+            worktreePath,
+            worktreeBranch,
+            repoPath,
+            repoWorktrees,
+            engineOverride: regTab?.engineOverride,
+            promptQueue: regTab?.promptQueue,
+            replayGap: replay.hadGap,
+        }),
+    });
+    resurfacePendingQuestions(ctx, ws, tabId);
+}