@minionry/minion 0.7.36

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

@@ -0,0 +1,565 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomUUID } from 'node:crypto';
+import { can } from '@minionry/roles';
+import { ImprovisationSessionManager } from '../../cli/improvisation-session-manager.js';
+import { sendAgentPush } from '../agent-push.js';
+import { getEffortLevel, getFastMode, getModel } from '../settings.js';
+import { DEFAULT_CHAT_TIMELINE_LIMITS } from '../timeline/index.js';
+import { registerPendingQuestion } from './ask-user-question-bridge.js';
+import { hasScopeBinding, resolveScopeDir, scopeExecutionDir, scopeRepoWorktrees, scopeWorktreePath, setScopeRepo, setScopeRepoWorktree, setScopeWorktree, } from './handler-context.js';
+import { WRITE_TOOL_NAMES } from './movement-written-files.js';
+import { triggerPostSessionQualityScan } from './post-session-scan.js';
+import { handleQueueClearPrompts, handleQueueEnqueuePrompt, handleQueueRemovePrompt } from './prompt-queue-handlers.js';
+import { isInteractiveAgentTab, QUALITY_NOTE_TRANSCRIPT_CODE, takeQualityAgentNote } from './quality-agent-notes.js';
+import { selectRecommendedAnswers } from './recommended-answers.js';
+import { buildClassifierHealthMessage } from './settings-handlers.js';
+import { resolveSkillPrompt } from './skill-handlers.js';
+import { broadcastTabEvent, broadcastTimelineEvents } from './tab-broadcast.js';
+import { normalizeEngineId } from './types.js';
+function applyExecuteOverrides(session, data) {
+    session.applyOverrides(data);
+}
+export function resolveEngineForSession(session) {
+    return normalizeEngineId(session?.engine);
+}
+export { handleHistoryMessage } from './session-history.js';
+export { initializeTab, resumeHistoricalSession } from './session-initialization.js';
+function movementHadWrites(movement) {
+    const history = movement.toolUseHistory;
+    if (!history)
+        return false;
+    return history.some((t) => WRITE_TOOL_NAMES.has(t.toolName) && t.result !== undefined && !t.isError);
+}
+function convertToolHistoryToLines(tools, ts) {
+    const lines = [];
+    for (const tool of tools) {
+        lines.push({ type: 'tool-call', text: '', toolName: tool.toolName, toolInput: tool.toolInput || {}, timestamp: ts });
+        if (tool.result !== undefined) {
+            lines.push({ type: 'tool-result', text: '', toolResult: tool.result || 'No output', toolStatus: tool.isError ? 'error' : 'success', timestamp: ts });
+        }
+    }
+    return lines;
+}
+function formatElapsedDuration(totalSeconds) {
+    const seconds = Math.floor(totalSeconds) % 60;
+    const minutes = Math.floor(totalSeconds / 60) % 60;
+    const hours = Math.floor(totalSeconds / 3600) % 24;
+    const days = Math.floor(totalSeconds / 86400);
+    if (days > 0)
+        return `${days}d ${hours}h ${minutes}m ${seconds}s`;
+    if (hours > 0)
+        return `${hours}h ${minutes}m ${seconds}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+function convertMovementToLines(movement) {
+    const lines = [];
+    const ts = new Date(movement.timestamp).getTime();
+    lines.push({ type: 'user', text: movement.userPrompt, timestamp: ts });
+    if (movement.thinkingOutput) {
+        lines.push({ type: 'thinking', text: '', thinking: movement.thinkingOutput, timestamp: ts });
+    }
+    if (movement.toolUseHistory) {
+        lines.push(...convertToolHistoryToLines(movement.toolUseHistory, ts));
+    }
+    if (movement.assistantResponse) {
+        lines.push({ type: 'assistant', text: movement.assistantResponse, timestamp: ts });
+    }
+    if (movement.errorOutput) {
+        lines.push({ type: 'error', text: `Error: ${movement.errorOutput}`, timestamp: ts });
+    }
+    const durationText = movement.durationMs
+        ? `Completed in ${formatElapsedDuration(movement.durationMs / 1000)}`
+        : 'Completed';
+    lines.push({ type: 'system', text: durationText, timestamp: ts });
+    return lines;
+}
+function requireSession(ctx, ws, tabId) {
+    const session = resolveTabSession(ctx, ws, tabId);
+    if (!session)
+        throw new Error(`No session found for tab ${tabId}`);
+    return session;
+}
+export function resolveTabSession(ctx, ws, tabId) {
+    const tabMap = ctx.connections.get(ws);
+    const mappedSessionId = tabMap?.get(tabId);
+    if (mappedSessionId) {
+        const session = ctx.sessions.get(mappedSessionId);
+        if (session)
+            return session;
+    }
+    const workingDir = ws._workingDir;
+    if (!workingDir)
+        return null;
+    const registry = ctx.getRegistry(workingDir);
+    const registrySessionId = registry.getTabSession(tabId);
+    if (!registrySessionId)
+        return null;
+    const inMemorySession = ctx.sessions.get(registrySessionId);
+    if (inMemorySession) {
+        return attachSessionToConnection(ctx, ws, tabId, inMemorySession, registry);
+    }
+    try {
+        const diskSession = ImprovisationSessionManager.resumeFromHistory(workingDir, registrySessionId);
+        ctx.sessions.set(diskSession.getSessionInfo().sessionId, diskSession);
+        registry.markTabPersisted(tabId);
+        return attachSessionToConnection(ctx, ws, tabId, diskSession, registry);
+    }
+    catch {
+        const freshSession = new ImprovisationSessionManager({
+            workingDir,
+            sessionId: registrySessionId,
+            model: getModel(),
+            effortLevel: getEffortLevel(),
+            fastMode: getFastMode(),
+        });
+        ctx.sessions.set(freshSession.getSessionInfo().sessionId, freshSession);
+        return attachSessionToConnection(ctx, ws, tabId, freshSession, registry);
+    }
+}
+function attachSessionToConnection(ctx, ws, tabId, session, registry) {
+    setupSessionListeners(ctx, session, ws, tabId);
+    const tabMap = ctx.connections.get(ws);
+    if (tabMap)
+        tabMap.set(tabId, session.getSessionInfo().sessionId);
+    registry.touchTab(tabId);
+    restoreWorktreeFromRegistry(ctx, registry, tabId);
+    return session;
+}
+export function restoreWorktreeFromRegistry(ctx, registry, tabId) {
+    if (hasScopeBinding(ctx, tabId))
+        return;
+    const regTab = registry.getTab(tabId);
+    if (!regTab)
+        return;
+    if (regTab.repoPath)
+        setScopeRepo(ctx, tabId, regTab.repoPath);
+    if (regTab.worktreePath) {
+        setScopeWorktree(ctx, tabId, regTab.worktreePath);
+        if (regTab.worktreeBranch)
+            ctx.gitBranches.set(tabId, regTab.worktreeBranch);
+    }
+    if (regTab.repoWorktrees) {
+        for (const selection of regTab.repoWorktrees) {
+            setScopeRepoWorktree(ctx, tabId, selection.repoRoot, { worktreePath: selection.worktreePath, branch: selection.branch });
+        }
+    }
+}
+function seedTimelineFromHistory(ctx, session, tabId) {
+    try {
+        ctx.chatTimelines
+            .getOrCreate(tabId)
+            .ensureSeeded(session.getHistory().movements, { executing: session.isExecuting });
+    }
+    catch (err) {
+        console.error(`[timeline] seed failed tabId=${tabId}:`, err);
+    }
+}
+function handleGetTimelineMessage(ctx, ws, tabId, msg) {
+    const session = resolveTabSession(ctx, ws, tabId);
+    if (session)
+        seedTimelineFromHistory(ctx, session, tabId);
+    const timeline = ctx.chatTimelines.getOrCreate(tabId);
+    const engine = session ? { engine: resolveEngineForSession(session) } : {};
+    const before = typeof msg.data?.before === 'string' ? msg.data.before : undefined;
+    const at = typeof msg.data?.at === 'string' ? msg.data.at : undefined;
+    const limit = typeof msg.data?.limit === 'number' && msg.data.limit >= 1 ? Math.floor(msg.data.limit) : undefined;
+    const maxEntries = limit === undefined ? undefined : Math.min(limit, DEFAULT_CHAT_TIMELINE_LIMITS.pageMaxEntries ?? limit);
+    if (at !== undefined) {
+        ctx.send(ws, { type: 'timelinePage', tabId, ...engine, data: timeline.pageFrom({ at, maxEntries }) });
+        return;
+    }
+    if (before !== undefined) {
+        ctx.send(ws, { type: 'timelinePage', tabId, ...engine, data: timeline.page({ before, maxEntries }) });
+        return;
+    }
+    const seq = ctx.tabEventBuffers.getOrCreate(tabId).currentSeq();
+    ctx.send(ws, { type: 'timelineSnapshot', tabId, ...engine, data: timeline.snapshot(seq, { maxEntries }) });
+}
+const MOVEMENT_BULK_KEYS = ['toolUseHistory', 'thinkingOutput', 'retryLog'];
+export function slimMovementForWire(movement) {
+    const slim = { ...movement };
+    for (const key of MOVEMENT_BULK_KEYS)
+        delete slim[key];
+    return slim;
+}
+export function summarizeSessionForWire(history) {
+    const movements = Array.isArray(history.movements) ? history.movements : [];
+    return {
+        sessionId: history.sessionId,
+        startedAt: history.startedAt,
+        lastActivityAt: history.lastActivityAt,
+        totalTokens: history.totalTokens ?? 0,
+        engine: history.engine ?? 'claude-code',
+        movementCount: movements.length,
+        ...(history.claudeSessionId !== undefined ? { claudeSessionId: history.claudeSessionId } : {}),
+    };
+}
+export function buildOutputHistory(session) {
+    const history = session.getHistory();
+    return history.movements
+        .filter((m) => (m.durationMs ?? 0) > 0)
+        .flatMap(convertMovementToLines);
+}
+export function setupSessionListeners(ctx, session, _ws, tabId) {
+    session.removeAllListeners();
+    session.setTabId(tabId);
+    const engine = resolveEngineForSession(session);
+    seedTimelineFromHistory(ctx, session, tabId);
+    session.on('onHistoryPersisted', () => {
+        const registry = ctx.getRegistry('');
+        try {
+            registry.markTabPersisted(tabId);
+        }
+        catch {   }
+    });
+    session.on('onOutput', (text) => {
+        broadcastTabEvent(ctx, tabId, 'output', { text, timestamp: Date.now() });
+    });
+    session.on('onThinking', (text) => {
+        broadcastTabEvent(ctx, tabId, 'thinking', { text });
+    });
+    session.on('onMovementStart', (sequenceNumber, prompt, isAutoContinue, etaProfile) => {
+        broadcastTabEvent(ctx, tabId, 'movementStart', { sequenceNumber, prompt, timestamp: Date.now(), executionStartTimestamp: session.executionStartTimestamp, isAutoContinue, etaProfile: etaProfile ?? undefined, executionTarget: session.getExecutionTarget() }, engine);
+        ctx.broadcastToAll({ type: 'tabStateChanged', engine, data: { tabId, isExecuting: true, executionStartTimestamp: session.executionStartTimestamp } });
+    });
+    session.on('onMovementComplete', (movement) => {
+        broadcastTabEvent(ctx, tabId, 'movementComplete', slimMovementForWire(movement), engine);
+        sendAgentPush({
+            event: 'task_complete',
+            tabId,
+            workingDirectory: session.getSessionInfo().workingDir,
+            movementKey: movement.sequenceNumber !== undefined ? String(movement.sequenceNumber) : undefined,
+        });
+        const registry = ctx.getRegistry('');
+        try {
+            registry.markTabUnviewed(tabId);
+        }
+        catch {   }
+        ctx.broadcastToAll({ type: 'tabStateChanged', engine, data: { tabId, isExecuting: false, hasUnviewedCompletion: true } });
+        try {
+            ctx.broadcastToAll(buildClassifierHealthMessage());
+        }
+        catch (err) {
+            console.error('[Session] Failed to broadcast classifier health:', err);
+        }
+        if (ctx.usageReporter && movement.tokensUsed) {
+            ctx.usageReporter({
+                tokensUsed: movement.tokensUsed,
+                sessionId: session.getSessionInfo().sessionId,
+                movementId: `${movement.sequenceNumber}`,
+                engine,
+                reportId: randomUUID(),
+            });
+        }
+        const hadWrites = movementHadWrites(movement);
+        const settleDir = resolveScopeDir(ctx, tabId, session.getSessionInfo().workingDir);
+        if (hadWrites) {
+            triggerPostSessionQualityScan({
+                movement,
+                worktreePath: scopeWorktreePath(ctx, tabId),
+                settleDir,
+                spaceRoot: session.getSessionInfo().workingDir,
+                ...(isInteractiveAgentTab(session, tabId) ? { noteTabId: tabId } : {}),
+            });
+        }
+        ctx.commitSuggestions?.notifyExecutionSettled(settleDir);
+        dispatchQueuedTabPrompt(ctx, session, tabId);
+    });
+    session.on('onMovementError', (error, sequenceNumber) => {
+        broadcastTabEvent(ctx, tabId, 'movementError', { message: error.message }, engine);
+        ctx.broadcastToAll({ type: 'tabStateChanged', engine, data: { tabId, isExecuting: false } });
+        sendAgentPush({
+            event: 'task_failed',
+            tabId,
+            workingDirectory: session.getSessionInfo().workingDir,
+            movementKey: sequenceNumber !== undefined ? String(sequenceNumber) : undefined,
+        });
+        ctx.commitSuggestions?.notifyExecutionSettled(resolveScopeDir(ctx, tabId, session.getSessionInfo().workingDir));
+        dispatchQueuedTabPrompt(ctx, session, tabId);
+    });
+    session.on('onSessionUpdate', (history) => {
+        broadcastTabEvent(ctx, tabId, 'sessionUpdate', summarizeSessionForWire(history), engine);
+    });
+    session.on('onPlanNeedsConfirmation', (plan) => {
+        broadcastTabEvent(ctx, tabId, 'approvalRequired', plan);
+        sendAgentPush({ event: 'approval_needed', tabId, workingDirectory: session.getSessionInfo().workingDir });
+    });
+    session.on('onToolUse', (event) => {
+        broadcastTabEvent(ctx, tabId, 'toolUse', { ...event, timestamp: Date.now() });
+    });
+    session.on('onAskUserQuestion', (req) => {
+        const items = toAskUserQuestionItems(req.questions);
+        broadcastTabEvent(ctx, tabId, 'askUserQuestion', { toolUseId: req.toolUseId, questions: items });
+        sendAgentPush({ event: 'question_waiting', tabId, workingDirectory: session.getSessionInfo().workingDir });
+        registerPendingQuestion({
+            toolUseId: req.toolUseId,
+            tabId,
+            questions: items,
+            computeTimeoutAnswers: () => selectRecommendedAnswers(items),
+        })
+            .then((resolved) => req.respond(answerMapToArrays(items, resolved.answers)))
+            .catch(() => req.respond(null));
+    });
+    session.on('onExecutionTargetUpdate', (executionTarget) => {
+        broadcastTabEvent(ctx, tabId, 'executionTargetUpdate', { executionTarget }, engine);
+    });
+    session.on('onTokenUsage', (usage) => {
+        broadcastTabEvent(ctx, tabId, 'streamingTokens', usage);
+    });
+}
+function toAskUserQuestionItems(questions) {
+    return questions.map((q) => ({
+        question: q.question,
+        header: q.header,
+        options: q.options.map((o) => ({ label: o.label, description: o.description })),
+        multiSelect: q.multiSelect,
+    }));
+}
+function answerMapToArrays(items, answers) {
+    return items.map((item) => {
+        const raw = answers[item.question];
+        if (!raw)
+            return [];
+        return item.multiSelect
+            ? raw.split(',').map((s) => s.trim()).filter(Boolean)
+            : [raw];
+    });
+}
+export function mergePreUploadedAttachments(ctx, tabId, inlineAttachments) {
+    if (!ctx.fileUploadHandler)
+        return inlineAttachments;
+    const preUploaded = ctx.fileUploadHandler.getAndClearCompletedUploads(tabId);
+    if (preUploaded.length === 0)
+        return inlineAttachments;
+    const merged = [...(inlineAttachments || [])];
+    for (const upload of preUploaded) {
+        const alreadyIncluded = merged.some(a => a.fileName === upload.fileName);
+        if (!alreadyIncluded) {
+            merged.push({
+                fileName: upload.fileName,
+                filePath: upload.filePath,
+                content: '',
+                isImage: upload.isImage,
+                mimeType: upload.mimeType,
+                _preUploaded: true,
+            });
+        }
+    }
+    return merged;
+}
+const WRITE_OPS = new Set(['execute', 'cancel', 'new', 'approve', 'reject', 'queueEnqueuePrompt', 'queueRemovePrompt', 'queueClearPrompts']);
+function emitExecuteAck(ctx, tabId, sessionId, msgId, duplicate = false) {
+    ctx.broadcastToAll({
+        type: 'executeAck',
+        tabId,
+        data: duplicate ? { msgId, sessionId, duplicate: true } : { msgId, sessionId },
+    });
+}
+function emitExecuteFailure(ctx, tabId, err, engine) {
+    const message = err instanceof Error ? err.message : String(err);
+    broadcastTabEvent(ctx, tabId, 'movementError', { message }, engine);
+    const stateChange = { tabId, isExecuting: false };
+    ctx.broadcastToAll({
+        type: 'tabStateChanged',
+        ...(engine ? { engine } : {}),
+        data: stateChange,
+    });
+}
+function handleExecuteMessage(ctx, ws, msg, tabId) {
+    if (!msg.data?.prompt)
+        throw new Error('Prompt is required');
+    const msgId = typeof msg.data.msgId === 'string' ? msg.data.msgId : undefined;
+    let session;
+    try {
+        session = requireSession(ctx, ws, tabId);
+    }
+    catch (err) {
+        if (msgId)
+            emitExecuteAck(ctx, tabId, '', msgId);
+        emitExecuteFailure(ctx, tabId, err, undefined);
+        return;
+    }
+    const { sessionId } = session.getSessionInfo();
+    const engine = resolveEngineForSession(session);
+    if (msgId && !ctx.msgIdTracker.recordIfFirst(tabId, msgId)) {
+        console.log(`[session] execute duplicate msgId=${msgId} tabId=${tabId} — re-acking without re-run`);
+        emitExecuteAck(ctx, tabId, sessionId, msgId,   true);
+        return;
+    }
+    if (msgId) {
+        console.log(`[session] execute accepted msgId=${msgId} tabId=${tabId} sessionId=${sessionId}`);
+    }
+    if (msgId)
+        emitExecuteAck(ctx, tabId, sessionId, msgId);
+    try {
+        dispatchAcceptedExecute(ctx, session, msg, tabId);
+    }
+    catch (err) {
+        emitExecuteFailure(ctx, tabId, err, engine);
+        throw err;
+    }
+}
+export function buildRepoWorktreeContextBlock(selections) {
+    if (selections.length === 0)
+        return null;
+    const lines = selections.map((selection) => `- ${selection.repoRoot} → ${selection.worktreePath}${selection.branch ? ` (branch ${selection.branch})` : ''}`);
+    return [
+        '<worktree-selections>',
+        "This tab works in these git worktrees instead of the repositories' main checkouts. Read, edit, build and run git for each repository below in its worktree path, not in the repository path:",
+        ...lines,
+        '</worktree-selections>',
+    ].join('\n');
+}
+export function runAcceptedExecute(ctx, session, input, tabId) {
+    applyExecuteOverrides(session, input);
+    const worktreeDir = scopeExecutionDir(ctx, tabId, session.getSessionInfo().workingDir);
+    const attachments = mergePreUploadedAttachments(ctx, tabId, input.attachments);
+    const rawPrompt = input.prompt;
+    const effectiveDir = worktreeDir || session.getSessionInfo().workingDir;
+    const expanded = ctx.snippetExpander ? ctx.snippetExpander.expand(rawPrompt) : null;
+    const promptAfterSnippets = expanded ? expanded.text : rawPrompt;
+    const resolved = resolveSkillPrompt(promptAfterSnippets, effectiveDir);
+    ctx.broadcastToAll({
+        type: 'promptTextSync',
+        tabId,
+        data: { tabId, text: '' },
+    });
+    const didExpand = (expanded?.expanded.length ?? 0) > 0;
+    const resolvedPrompt = resolved ? resolved.prompt : promptAfterSnippets;
+    const effectivePrompt = input.qualityNote ? `${input.qualityNote}\n\n${resolvedPrompt}` : resolvedPrompt;
+    const contextBlock = buildRepoWorktreeContextBlock(scopeRepoWorktrees(ctx, tabId));
+    const promptForEngine = contextBlock ? `${contextBlock}\n\n${effectivePrompt}` : effectivePrompt;
+    const displayPrompt = resolved || didExpand || contextBlock || input.qualityNote ? rawPrompt : undefined;
+    if (input.qualityNote)
+        writeQualityNoteToTranscript(ctx, session, tabId, input.qualityNote);
+    session.executePrompt(promptForEngine, attachments, {
+        workingDir: worktreeDir,
+        displayPrompt,
+        ...(input.msgId ? { msgId: input.msgId } : {}),
+    }).catch((err) => {
+        console.error(`[session] executePrompt failed tabId=${tabId}:`, err);
+    });
+}
+function writeQualityNoteToTranscript(ctx, session, tabId, note) {
+    try {
+        const events = ctx.chatTimelines.getOrCreate(tabId).notice('info', note, QUALITY_NOTE_TRANSCRIPT_CODE);
+        broadcastTimelineEvents(ctx, tabId, events, resolveEngineForSession(session));
+    }
+    catch (err) {
+        console.error(`[session] quality note transcript write failed tabId=${tabId}:`, err);
+    }
+}
+function qualityNoteInput(session, tabId) {
+    if (!isInteractiveAgentTab(session, tabId))
+        return {};
+    const qualityNote = takeQualityAgentNote(tabId);
+    return qualityNote ? { qualityNote } : {};
+}
+function dispatchAcceptedExecute(ctx, session, msg, tabId) {
+    if (session.isExecuting) {
+        console.log(`[session] execute ignored — already executing tabId=${tabId}`);
+        return;
+    }
+    runAcceptedExecute(ctx, session, {
+        prompt: msg.data.prompt,
+        attachments: msg.data.attachments,
+        ...(typeof msg.data.msgId === 'string' ? { msgId: msg.data.msgId } : {}),
+        ...qualityNoteInput(session, tabId),
+        engine: msg.data.engine,
+        model: msg.data.model,
+        effortLevel: msg.data.effortLevel,
+        fastMode: msg.data.fastMode,
+        ultracode: msg.data.ultracode,
+        systemPromptProfile: msg.data.systemPromptProfile,
+        systemPromptLang: msg.data.systemPromptLang,
+    }, tabId);
+}
+export function dispatchQueuedTabPrompt(ctx, session, tabId) {
+    if (session.isExecuting)
+        return;
+    const registry = ctx.getRegistry('');
+    const next = registry.shiftPromptQueue(tabId);
+    if (!next)
+        return;
+    ctx.broadcastToAll({
+        type: 'promptQueueSync',
+        tabId,
+        data: { tabId, queue: registry.getPromptQueue(tabId) },
+    });
+    try {
+        runAcceptedExecute(ctx, session, { prompt: next.prompt, attachments: next.attachments, ...(next.meta ?? {}), ...qualityNoteInput(session, tabId) }, tabId);
+    }
+    catch (err) {
+        console.error(`[session] dequeued execute failed tabId=${tabId}:`, err);
+    }
+}
+function handleNewSessionMessage(ctx, ws, tabId) {
+    const oldSession = requireSession(ctx, ws, tabId);
+    const oldSessionId = oldSession.getSessionInfo().sessionId;
+    const newSession = oldSession.startNewSession({ model: getModel(), effortLevel: getEffortLevel(), fastMode: getFastMode() });
+    oldSession.destroy();
+    ctx.sessions.delete(oldSessionId);
+    broadcastTimelineEvents(ctx, tabId, ctx.chatTimelines.getOrCreate(tabId).reset(), resolveEngineForSession(newSession));
+    setupSessionListeners(ctx, newSession, ws, tabId);
+    const newSessionId = newSession.getSessionInfo().sessionId;
+    ctx.sessions.set(newSessionId, newSession);
+    const tabMap = ctx.connections.get(ws);
+    if (tabMap)
+        tabMap.set(tabId, newSessionId);
+    const registry = ctx.getRegistry('');
+    try {
+        registry.updateTabSession(tabId, newSessionId);
+    }
+    catch {   }
+    ctx.send(ws, { type: 'newSession', tabId, engine: resolveEngineForSession(newSession), data: newSession.getSessionInfo() });
+}
+export function handleSessionMessage(ctx, ws, msg, tabId, role) {
+    if (WRITE_OPS.has(msg.type) && !can(role, 'execute')) {
+        throw new Error('Your role does not permit running or controlling sessions');
+    }
+    switch (msg.type) {
+        case 'execute':
+            handleExecuteMessage(ctx, ws, msg, tabId);
+            break;
+        case 'cancel': {
+            const session = requireSession(ctx, ws, tabId);
+            session.cancel();
+            break;
+        }
+        case 'getHistory': {
+            const session = requireSession(ctx, ws, tabId);
+            ctx.send(ws, { type: 'history', tabId, data: summarizeSessionForWire(session.getHistory()) });
+            break;
+        }
+        case 'getTimeline':
+            handleGetTimelineMessage(ctx, ws, tabId, msg);
+            break;
+        case 'new':
+            handleNewSessionMessage(ctx, ws, tabId);
+            break;
+        case 'approve': {
+            const session = requireSession(ctx, ws, tabId);
+            session.respondToApproval(true);
+            broadcastTabEvent(ctx, tabId, 'output', { text: '\n✅ Approved - proceeding with operation\n' });
+            break;
+        }
+        case 'reject': {
+            const session = requireSession(ctx, ws, tabId);
+            session.respondToApproval(false);
+            broadcastTabEvent(ctx, tabId, 'output', { text: '\n🚫 Rejected - operation cancelled\n' });
+            break;
+        }
+        case 'queueEnqueuePrompt':
+            handleQueueEnqueuePrompt(ctx, ws, msg, tabId);
+            break;
+        case 'queueRemovePrompt':
+            handleQueueRemovePrompt(ctx, ws, msg, tabId);
+            break;
+        case 'queueClearPrompts':
+            handleQueueClearPrompts(ctx, ws, msg, tabId);
+            break;
+    }
+}