lattice-orchestrator 0.7.0

package/dist/services/insights/insights-computer.js

@@ -0,0 +1,936 @@
+import crypto from 'crypto';
+import { createLogger } from '../infrastructure/logger.js';
+import { anthropicService } from '../insights/anthropic-service.js';
+import { SessionInfoService } from '../sessions/session-info-service.js';
+import { geminiService } from '../gemini-service.js';
+import { getSessionActivityWatcher } from '../sessions/session-activity-watcher.js';
+/**
+ * Generate a trace ID for correlating recompute events through the system.
+ * Format: <session-prefix>-<timestamp-hex>-<random>
+ */
+function generateTraceId(sessionId) {
+    const sessionPrefix = sessionId.slice(0, 8);
+    const timestampHex = Date.now().toString(16);
+    const random = crypto.randomBytes(2).toString('hex');
+    return `${sessionPrefix}-${timestampHex}-${random}`;
+}
+function buildStateSnapshot(cache, insights) {
+    if (insights) {
+        return {
+            mission: insights.context?.mission || undefined,
+            description: insights.description || undefined,
+            theme: insights.theme || undefined,
+            milestones: insights.milestones?.map(m => `${m.label}:${m.status}`) || [],
+            notableCount: insights.notable?.length || 0,
+        };
+    }
+    if (cache) {
+        return {
+            mission: cache.context?.mission || undefined,
+            description: cache.description || undefined,
+            theme: cache.theme || undefined,
+            milestones: cache.milestones?.map((m) => `${m.label}:${m.status}`) || [],
+            notableCount: cache.notable?.length || 0,
+        };
+    }
+    return {};
+}
+/**
+ * InsightsComputer - The computational engine for generating insights.
+ *
+ * This service handles the actual LLM calls and prompt construction for insights.
+ * It does NOT coordinate when to generate insights - that's InsightsCoordinator's job.
+ *
+ * Responsibilities:
+ * - Building prompts for insight generation
+ * - Calling Anthropic/Gemini APIs
+ * - Caching computed insights
+ * - Generating identity images
+ *
+ * Related services:
+ * - InsightsCoordinator (insights-coordinator.ts) - orchestrates when to compute
+ * - AnthropicService (anthropic-service.ts) - actual API calls
+ */
+export class InsightsComputer {
+    logger;
+    historyReader;
+    sessionInfoService;
+    constructor(historyReader, sessionInfoService) {
+        this.logger = createLogger('InsightsComputer');
+        this.historyReader = historyReader;
+        this.sessionInfoService = sessionInfoService || SessionInfoService.getInstance();
+    }
+    /**
+     * Check if a session is automated (e.g., Claudia sessions).
+     * Automated sessions should skip expensive AI insight generation.
+     */
+    async isAutomatedSession(sessionId) {
+        try {
+            const { metadata } = await this.historyReader.fetchConversationDirect(sessionId);
+            return metadata.projectPath?.toLowerCase().includes('/claudia') || false;
+        }
+        catch {
+            // If we can't determine, assume not automated
+            return false;
+        }
+    }
+    /**
+     * Extract the final todo state from conversation messages
+     */
+    extractTodoState(messages) {
+        let lastTodoState = null;
+        for (const msg of messages) {
+            const content = msg.message?.content;
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (typeof block === 'object' &&
+                    block !== null &&
+                    'type' in block &&
+                    block.type === 'tool_use' &&
+                    'name' in block &&
+                    block.name === 'TodoWrite' &&
+                    'input' in block &&
+                    typeof block.input === 'object' &&
+                    block.input !== null &&
+                    'todos' in block.input &&
+                    Array.isArray(block.input.todos)) {
+                    lastTodoState = block.input.todos;
+                }
+            }
+        }
+        return lastTodoState;
+    }
+    /**
+     * Compute progress from todo state
+     */
+    computeProgress(todos) {
+        const completed = todos.filter(t => t.status === 'completed').length;
+        const inProgress = todos.filter(t => t.status === 'in_progress').length;
+        const pending = todos.filter(t => t.status === 'pending').length;
+        const total = todos.length;
+        const percent = total > 0 ? Math.round((completed / total) * 100) : 0;
+        return { completed, inProgress, pending, total, percent };
+    }
+    /**
+     * Extract the last N actions from recent messages (tool uses, user messages, assistant text)
+     * Returns an array of {tool, timestamp} for mini action log display
+     */
+    extractRecentActions(messages, limit = 14) {
+        const actions = [];
+        // Walk backwards through messages
+        for (let i = messages.length - 1; i >= 0 && actions.length < limit; i--) {
+            const msg = messages[i];
+            const content = msg.message?.content;
+            const timestamp = msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now();
+            // User messages - handle both string and array content
+            if (msg.type === 'user') {
+                // String content (most common for typed user prompts)
+                if (typeof content === 'string' && content.trim().length > 0) {
+                    actions.push({
+                        tool: 'User',
+                        timestamp
+                    });
+                    if (actions.length >= limit)
+                        break;
+                    continue;
+                }
+                // Array content - look for text blocks
+                if (Array.isArray(content)) {
+                    for (const block of content) {
+                        if (typeof block === 'object' &&
+                            block !== null &&
+                            'type' in block &&
+                            block.type === 'text' &&
+                            'text' in block &&
+                            typeof block.text === 'string' &&
+                            block.text.trim().length > 0) {
+                            actions.push({
+                                tool: 'User',
+                                timestamp
+                            });
+                            // Only count one user action per message
+                            break;
+                        }
+                    }
+                    if (actions.length >= limit)
+                        break;
+                }
+                continue;
+            }
+            // Skip non-array content for assistant messages
+            if (!Array.isArray(content))
+                continue;
+            // Assistant messages - both tool uses and text responses
+            if (msg.type === 'assistant') {
+                let hasToolUse = false;
+                let _hasText = false;
+                // First pass: check what types we have
+                for (const block of content) {
+                    if (typeof block === 'object' && block !== null && 'type' in block) {
+                        if (block.type === 'tool_use')
+                            hasToolUse = true;
+                        if (block.type === 'text')
+                            _hasText = true;
+                    }
+                }
+                // Second pass: add actions
+                for (const block of content) {
+                    if (typeof block !== 'object' || block === null || !('type' in block))
+                        continue;
+                    if (block.type === 'tool_use' && 'name' in block && typeof block.name === 'string') {
+                        actions.push({
+                            tool: block.name,
+                            timestamp
+                        });
+                        if (actions.length >= limit)
+                            break;
+                    }
+                    else if (block.type === 'text' && 'text' in block && typeof block.text === 'string') {
+                        // Only add text response if there's no tool use in this message
+                        if (!hasToolUse && block.text.trim().length > 0) {
+                            actions.push({
+                                tool: 'Response',
+                                timestamp
+                            });
+                            // Only count one text response per message
+                            break;
+                        }
+                    }
+                }
+                if (actions.length >= limit)
+                    break;
+            }
+        }
+        // Reverse to get chronological order (oldest first, newest last)
+        return actions.reverse();
+    }
+    /**
+     * Extract user prompts from conversation
+     */
+    extractUserPrompts(messages) {
+        const prompts = [];
+        for (const msg of messages) {
+            if (msg.type !== 'user')
+                continue;
+            const content = msg.message?.content;
+            if (typeof content === 'string' && content.trim()) {
+                prompts.push(content.trim());
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (typeof block === 'object' &&
+                        block !== null &&
+                        'type' in block &&
+                        block.type === 'text' &&
+                        'text' in block &&
+                        typeof block.text === 'string') {
+                        prompts.push(block.text.trim());
+                    }
+                }
+            }
+        }
+        return prompts.filter(p => p.length > 0 && !p.startsWith('['));
+    }
+    /**
+     * Extract recent assistant text responses (last N messages)
+     * Used to capture outcomes and progress for insight generation
+     */
+    extractRecentAssistantText(messages, limit = 3) {
+        const texts = [];
+        // Work backwards from the end to get most recent first
+        for (let i = messages.length - 1; i >= 0 && texts.length < limit; i--) {
+            const msg = messages[i];
+            if (msg.type !== 'assistant')
+                continue;
+            const content = msg.message?.content;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (typeof block === 'object' &&
+                        block !== null &&
+                        'type' in block &&
+                        block.type === 'text' &&
+                        'text' in block &&
+                        typeof block.text === 'string' &&
+                        block.text.trim()) {
+                        texts.push(block.text.trim());
+                        break; // Only one text block per message
+                    }
+                }
+            }
+        }
+        return texts;
+    }
+    /**
+     * Format a tool call into a human-readable action description
+     */
+    formatToolAction(toolName, input) {
+        switch (toolName) {
+            case 'Read':
+                return `Reading ${this.extractFilename(input.file_path)}`;
+            case 'Edit':
+                return `Editing ${this.extractFilename(input.file_path)}`;
+            case 'Write':
+                return `Writing ${this.extractFilename(input.file_path)}`;
+            case 'Grep':
+                return `Searching: "${input.pattern?.slice(0, 40)}"`;
+            case 'Glob':
+                return `Finding: ${input.pattern?.slice(0, 40)}`;
+            case 'Bash': {
+                const description = input.description;
+                if (description) {
+                    return description.slice(0, 50);
+                }
+                const command = input.command || '';
+                return command.slice(0, 50) || 'Running command';
+            }
+            case 'Task':
+                return input.description?.slice(0, 50) || 'Delegating task';
+            case 'TodoWrite': {
+                const todos = input.todos;
+                if (todos && todos.length > 0) {
+                    const inProgress = todos.find(t => t.status === 'in_progress');
+                    if (inProgress?.content) {
+                        return inProgress.content.slice(0, 50);
+                    }
+                }
+                return 'Updating todo list';
+            }
+            default:
+                return toolName;
+        }
+    }
+    /**
+     * Extract filename from a path for display
+     */
+    extractFilename(path) {
+        if (!path)
+            return 'file';
+        const parts = path.split('/');
+        return parts[parts.length - 1] || 'file';
+    }
+    /**
+     * Generate rich structured session insights using Opus 4.5
+     */
+    async generateStructuredInsights(messages, sessionId) {
+        // Check if Anthropic is configured
+        if (!anthropicService.isConfigured()) {
+            this.logger.debug('Anthropic service not configured, skipping insight extraction');
+            return { context: null, milestones: [], notable: [], recentActions: [], theme: null, tags: null };
+        }
+        try {
+            // Get user prompts for context
+            const userPrompts = this.extractUserPrompts(messages);
+            if (userPrompts.length === 0) {
+                return { context: null, milestones: [], notable: [], recentActions: [], theme: null, tags: null };
+            }
+            // Get todo items for context
+            const todos = this.extractTodoState(messages);
+            const todoContext = todos
+                ? `\nTask list:\n${todos.map(t => `- [${t.status}] ${t.content}`).join('\n')}`
+                : '';
+            // Get recent assistant responses for outcome/progress context
+            const recentAssistantText = this.extractRecentAssistantText(messages, 3);
+            const assistantContext = recentAssistantText.length > 0
+                ? `\nRecent assistant responses:\n${recentAssistantText.map(t => `- "${t}"`).join('\n')}`
+                : '';
+            // Build conversation context - no truncation, models have plenty of context
+            const conversationText = `User requests (chronological):
+${userPrompts.slice(-12).map(p => `- "${p}"`).join('\n')}
+${todoContext}${assistantContext}`;
+            const result = await anthropicService.extractSessionInsights(conversationText, sessionId);
+            return {
+                context: result.context,
+                milestones: result.milestones,
+                notable: result.notable || [],
+                recentActions: result.recentActions,
+                theme: result.theme || null,
+                tags: result.tags || null
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to generate structured insights - re-throwing to preserve existing cache', { error });
+            // Re-throw so callers can decide whether to use cached data or handle the error
+            throw error;
+        }
+    }
+    /**
+     * Get full insights for a session (checks cache first)
+     * For automated sessions, returns quick insights without AI generation.
+     *
+     * NON-BLOCKING BEHAVIOR:
+     * - If cache is fresh → return it immediately
+     * - If cache is stale → return stale data immediately, trigger background regeneration
+     * - If no cache → generate synchronously (first time only)
+     */
+    async getInsights(sessionId) {
+        this.logger.debug('[GET INSIGHTS] Called', {
+            sessionId: sessionId.slice(0, 8),
+            timestamp: new Date().toISOString()
+        });
+        // Check cache first
+        const cached = await this.sessionInfoService.getInsights(sessionId);
+        this.logger.debug('[GET INSIGHTS] Cache lookup result', {
+            sessionId: sessionId.slice(0, 8),
+            hasCached: !!cached,
+            isStale: cached?.stale || false,
+            cachedMission: cached?.context ? (typeof cached.context === 'string' ? JSON.parse(cached.context).mission : cached.context.mission)?.slice(0, 50) : null
+        });
+        if (cached && !cached.stale) {
+            this.logger.debug('[GET INSIGHTS] Returning cached (not stale)', {
+                sessionId: sessionId.slice(0, 8)
+            });
+            return this.cachedToSessionInsights(cached);
+        }
+        // For automated sessions, skip AI generation entirely
+        const isAutomated = await this.isAutomatedSession(sessionId);
+        if (isAutomated) {
+            this.logger.debug('Skipping AI insights for automated session', { sessionId });
+            return this.getInsightsQuick(sessionId);
+        }
+        // NON-BLOCKING: If we have stale cache, return it immediately and regenerate in background
+        if (cached && cached.stale) {
+            this.logger.debug('[GET INSIGHTS] Returning stale cache, triggering background regeneration', {
+                sessionId: sessionId.slice(0, 8)
+            });
+            // Fire off background regeneration (don't await)
+            this.regenerateInsightsInBackground(sessionId, cached).catch(err => this.logger.debug('Background regeneration failed', { sessionId, error: err }));
+            // Return stale data immediately for fast UX
+            return this.cachedToSessionInsights(cached);
+        }
+        // No cache at all - must generate synchronously (first time for this session)
+        this.logger.warn('[GET INSIGHTS] No cache - triggering synchronous generation', {
+            sessionId: sessionId.slice(0, 8)
+        });
+        const traceId = generateTraceId(sessionId);
+        const startTime = Date.now();
+        const beforeState = buildStateSnapshot(cached);
+        const insights = await this.computeInsights(sessionId);
+        // Cache the result and audit the recompute
+        const afterState = buildStateSnapshot(null, insights);
+        const changedFields = [];
+        if (beforeState.mission !== afterState.mission)
+            changedFields.push('mission');
+        if (beforeState.description !== afterState.description)
+            changedFields.push('description');
+        if (beforeState.theme !== afterState.theme)
+            changedFields.push('theme');
+        if (JSON.stringify(beforeState.milestones) !== JSON.stringify(afterState.milestones))
+            changedFields.push('milestones');
+        const durationMs = Date.now() - startTime;
+        // Audit the recompute
+        this.sessionInfoService.auditEventInsight({
+            traceId,
+            sessionId,
+            eventType: 'recompute',
+            trigger: 'api_request',
+            beforeState,
+            afterState,
+            patchedFields: changedFields,
+            durationMs,
+            llmResponse: `Opus returned: context=${!!insights.context}, description=${!!insights.description}, milestones=${(insights.milestones || []).length}`,
+        });
+        // Cache the result (don't await - fire and forget)
+        this.cacheInsights(sessionId, insights).catch(err => this.logger.debug('Failed to cache insights', { sessionId, error: err }));
+        // Build V9 fields inline for immediate return (before cache is written)
+        const now = new Date().toISOString();
+        const progressItems = (insights.milestones || []).map(m => ({
+            label: m.label,
+            status: m.status,
+            addedAt: now,
+            updatedAt: now
+        }));
+        const progressSummary = {
+            done: progressItems.filter(p => p.status === 'done').length,
+            current: progressItems.filter(p => p.status === 'current').length,
+            pending: progressItems.filter(p => p.status === 'pending').length,
+            paused: 0,
+            abandoned: 0,
+            total: progressItems.length
+        };
+        const notableEvents = (insights.notable || []).map(n => ({
+            text: n.text || n.description || '',
+            icon: n.icon,
+            addedAt: now
+        }));
+        const recentActionsV2 = (insights.recentActions || []).map(text => ({
+            text,
+            addedAt: now
+        }));
+        return {
+            ...insights,
+            progressItems,
+            progressSummary,
+            notableEvents,
+            recentActionsV2
+        };
+    }
+    /**
+     * Regenerate insights in the background (for stale cache refresh).
+     * This runs async and updates the cache when done.
+     */
+    async regenerateInsightsInBackground(sessionId, existingCache) {
+        const traceId = generateTraceId(sessionId);
+        const startTime = Date.now();
+        const beforeState = buildStateSnapshot(existingCache);
+        this.logger.info('[BACKGROUND REGEN] Starting', {
+            traceId,
+            sessionId: sessionId.slice(0, 8)
+        });
+        try {
+            const insights = await this.computeInsights(sessionId);
+            // Cache the result and audit the recompute
+            const afterState = buildStateSnapshot(null, insights);
+            const changedFields = [];
+            if (beforeState.mission !== afterState.mission)
+                changedFields.push('mission');
+            if (beforeState.description !== afterState.description)
+                changedFields.push('description');
+            if (beforeState.theme !== afterState.theme)
+                changedFields.push('theme');
+            if (JSON.stringify(beforeState.milestones) !== JSON.stringify(afterState.milestones))
+                changedFields.push('milestones');
+            const durationMs = Date.now() - startTime;
+            // Audit the recompute
+            this.sessionInfoService.auditEventInsight({
+                traceId,
+                sessionId,
+                eventType: 'recompute',
+                trigger: 'background_stale_refresh',
+                beforeState,
+                afterState,
+                patchedFields: changedFields,
+                durationMs,
+                llmResponse: `Opus returned: context=${!!insights.context}, description=${!!insights.description}, milestones=${(insights.milestones || []).length}`,
+            });
+            await this.cacheInsights(sessionId, insights);
+            this.logger.info('[BACKGROUND REGEN] Completed', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                durationMs,
+                changedFields
+            });
+        }
+        catch (error) {
+            this.logger.warn('[BACKGROUND REGEN] Failed - existing cache preserved', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                error
+            });
+            // Don't throw - this is a background operation
+            // IMPORTANT: We intentionally don't cache anything on failure to preserve existing good data
+        }
+    }
+    /**
+     * Compute insights from conversation (bypasses cache)
+     */
+    async computeInsights(sessionId) {
+        const { messages } = await this.historyReader.fetchConversationDirect(sessionId);
+        const messageCount = messages.length;
+        // Extract todo state
+        const todos = this.extractTodoState(messages);
+        // Compute progress
+        const progress = todos ? this.computeProgress(todos) : null;
+        // Get recently completed (last 3)
+        const recentlyCompleted = todos
+            ? todos
+                .filter(t => t.status === 'completed')
+                .slice(-3)
+                .map(t => t.content)
+            : [];
+        // Get outstanding tasks
+        const outstanding = todos
+            ? todos
+                .filter(t => t.status === 'pending' || t.status === 'in_progress')
+                .map(t => t.content)
+            : [];
+        // Get current task (in_progress)
+        const currentTask = todos
+            ? todos.find(t => t.status === 'in_progress')?.content || null
+            : null;
+        // Generate rich structured insights using Opus
+        const structured = await this.generateStructuredInsights(messages, sessionId);
+        // Use Opus theme (no heuristic fallback - theme is evaluated on user message)
+        const theme = structured.theme || null;
+        // Generate brief description for title (backward compat)
+        const description = structured.context?.mission || null;
+        // Build purposes array from context for backward compatibility
+        const purposes = structured.context
+            ? [structured.context.mission]
+            : [];
+        return {
+            sessionId,
+            context: structured.context,
+            tags: structured.tags,
+            theme,
+            purposes,
+            description,
+            progress,
+            recentlyCompleted,
+            outstanding,
+            currentTask,
+            messageCount,
+            // purpose is set by fast patch (Haiku), not full compute (Opus)
+            // It will be preserved from existing cache during cacheInsights
+            // === Deprecated fields (kept for backward compat with cached data) ===
+            // These are no longer generated by LLM - always empty defaults.
+            // V8 fields will be converted to V9 equivalents in cacheInsights()
+            currentState: null,
+            panels: [],
+            milestones: structured.milestones, // Always [] from anthropic-service
+            notable: structured.notable, // Always [] from anthropic-service
+            recentActions: structured.recentActions, // Always [] from anthropic-service
+        };
+    }
+    /**
+     * Cache insights to database
+     */
+    async cacheInsights(sessionId, insights) {
+        const now = new Date().toISOString();
+        // Preserve existing purpose if new insights don't have one
+        // (purpose is set by fast patch/Haiku, not full compute/Opus)
+        let purposeToCache = insights.purpose;
+        if (!purposeToCache) {
+            const existing = await this.sessionInfoService.getInsights(sessionId);
+            purposeToCache = existing?.purpose;
+        }
+        // Initialize V9 progress items from milestones
+        const progressItems = (insights.milestones || []).map(m => ({
+            label: m.label,
+            status: m.status,
+            addedAt: now,
+            updatedAt: now
+        }));
+        // Compute progress summary
+        const progressSummary = {
+            done: progressItems.filter(p => p.status === 'done').length,
+            current: progressItems.filter(p => p.status === 'current').length,
+            pending: progressItems.filter(p => p.status === 'pending').length,
+            paused: 0,
+            abandoned: 0,
+            total: progressItems.length
+        };
+        // Initialize V9 notable events from notable
+        const notableEvents = (insights.notable || []).map(n => ({
+            text: n.text || n.description || '',
+            icon: n.icon,
+            addedAt: now
+        }));
+        // Initialize V9 recent actions
+        const recentActionsV2 = (insights.recentActions || []).map(text => ({
+            text,
+            addedAt: now
+        }));
+        const cached = {
+            session_id: sessionId,
+            description: insights.description ?? null,
+            context: insights.context,
+            current_state: insights.currentState ?? null,
+            last_patch_trace_id: null,
+            purposes: insights.purposes || [],
+            milestones: insights.milestones || [],
+            notable: insights.notable || [],
+            tags: insights.tags,
+            recent_actions: insights.recentActions || [],
+            panels: insights.panels || [],
+            progress_completed: insights.progress?.completed || 0,
+            progress_total: insights.progress?.total || 0,
+            outstanding_tasks: insights.outstanding || [],
+            completed_tasks: insights.recentlyCompleted || [],
+            current_task: insights.currentTask ?? null,
+            theme: insights.theme,
+            computed_at: now,
+            stale: false,
+            message_count: insights.messageCount,
+            // V9 accumulative fields
+            progress_items: progressItems,
+            notable_events: notableEvents,
+            recent_actions_v2: recentActionsV2,
+            progress_summary: progressSummary,
+            // Evolving purpose (preserved from existing cache if not in new insights)
+            purpose: purposeToCache
+        };
+        await this.sessionInfoService.setInsights(cached);
+        // Generate identity image if session doesn't have one yet (fire and forget)
+        this.maybeGenerateIdentityImage(sessionId, insights).catch(err => {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            this.logger.warn('Failed to generate identity image (background)', {
+                sessionId,
+                errorMessage,
+                errorType: err?.constructor?.name
+            });
+        });
+    }
+    /**
+     * Generate identity image for a session if it doesn't already have one.
+     * This is called after insights are cached/patched, and runs in the background.
+     * Public so InsightsCoordinator can call it after patching too.
+     */
+    async maybeGenerateIdentityImage(sessionId, insights) {
+        // Check if session already has an identity image
+        const hasImage = await this.sessionInfoService.hasIdentityImage(sessionId);
+        if (hasImage) {
+            return;
+        }
+        // Need context to generate meaningful image
+        if (!insights.context?.mission) {
+            this.logger.debug('Skipping identity image - no mission context', { sessionId });
+            return;
+        }
+        const imageContext = {
+            mission: insights.context.mission,
+            project: insights.context.project,
+            theme: insights.theme ?? undefined,
+            workTypes: insights.tags?.workType
+        };
+        this.logger.info('Generating identity image for session', {
+            sessionId,
+            imageContext
+        });
+        try {
+            const result = await geminiService.generateSessionImage(imageContext);
+            await this.sessionInfoService.setIdentityImage(sessionId, result.imageData);
+            this.logger.info('Identity image generated and saved', { sessionId });
+            // Emit a follow-up SSE event so clients can update their cache with the new image
+            // This solves the race condition where the initial insights SSE is sent before
+            // the identity image is generated
+            try {
+                await getSessionActivityWatcher().emitInsightsUpdate(sessionId, 'patched');
+                this.logger.debug('Emitted SSE update for new identity image', { sessionId });
+            }
+            catch (sseError) {
+                this.logger.debug('Failed to emit SSE for identity image', { sessionId, error: sseError });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.warn('Failed to generate identity image', {
+                sessionId,
+                errorMessage,
+                errorType: error?.constructor?.name
+            });
+            // Don't throw - this is a non-critical background operation
+        }
+    }
+    /**
+     * Convert cached insights to SessionInsights format
+     */
+    cachedToSessionInsights(cached) {
+        return {
+            sessionId: cached.session_id,
+            context: cached.context,
+            tags: cached.tags,
+            purposes: cached.purposes || [],
+            description: cached.description,
+            progress: cached.progress_total > 0 ? {
+                completed: cached.progress_completed,
+                inProgress: 0,
+                pending: cached.progress_total - cached.progress_completed,
+                total: cached.progress_total,
+                percent: Math.round((cached.progress_completed / cached.progress_total) * 100)
+            } : null,
+            recentlyCompleted: cached.completed_tasks,
+            outstanding: cached.outstanding_tasks,
+            currentTask: cached.current_task,
+            theme: cached.theme,
+            computedAt: cached.computed_at,
+            patchedAt: cached.patched_at,
+            messageCountAtPatch: cached.message_count,
+            purpose: cached.purpose,
+            // V9 accumulative fields (actively used)
+            progressItems: cached.progress_items,
+            notableEvents: cached.notable_events,
+            recentActionsV2: cached.recent_actions_v2,
+            progressSummary: cached.progress_summary,
+            // === Deprecated fields (kept for backward compat) ===
+            // These may have data from older sessions but are no longer generated
+            currentState: null,
+            lastPatchTraceId: cached.last_patch_trace_id,
+            panels: [],
+            milestones: (cached.milestones || []),
+            notable: (cached.notable || []),
+            recentActions: cached.recent_actions || [],
+        };
+    }
+    /**
+     * Get cached insights for multiple sessions (for list view)
+     */
+    async getCachedInsightsForSessions(sessionIds) {
+        const allCached = await this.sessionInfoService.getAllInsights();
+        const result = new Map();
+        for (const id of sessionIds) {
+            const cached = allCached.get(id);
+            if (cached) {
+                result.set(id, this.cachedToSessionInsights(cached));
+            }
+        }
+        return result;
+    }
+    /**
+     * Compute and cache insights for sessions that don't have cached insights
+     */
+    async computeMissingInsights(sessionIds, maxConcurrent = 3) {
+        const missing = await this.sessionInfoService.getMissingInsightsSessionIds(sessionIds);
+        if (missing.length === 0) {
+            return 0;
+        }
+        this.logger.info('Computing missing insights', { count: missing.length });
+        // Process in batches to avoid overwhelming the system
+        let computed = 0;
+        for (let i = 0; i < missing.length; i += maxConcurrent) {
+            const batch = missing.slice(i, i + maxConcurrent);
+            await Promise.all(batch.map(async (sessionId) => {
+                try {
+                    const insights = await this.computeInsights(sessionId);
+                    await this.cacheInsights(sessionId, insights);
+                    computed++;
+                }
+                catch (error) {
+                    this.logger.debug('Failed to compute insights for session', { sessionId, error });
+                }
+            }));
+        }
+        return computed;
+    }
+    /**
+     * Recompute insights for stale sessions (force refresh)
+     * Preserves accumulated milestones/notable from existing cache if new result is empty
+     */
+    async recomputeStaleInsights(sessionIds, maxConcurrent = 3) {
+        if (sessionIds.length === 0) {
+            return 0;
+        }
+        this.logger.info('Recomputing stale insights', { count: sessionIds.length });
+        // Process in batches to avoid overwhelming the system
+        let computed = 0;
+        for (let i = 0; i < sessionIds.length; i += maxConcurrent) {
+            const batch = sessionIds.slice(i, i + maxConcurrent);
+            await Promise.all(batch.map(async (sessionId) => {
+                const traceId = generateTraceId(sessionId);
+                const startTime = Date.now();
+                try {
+                    // Get existing cache BEFORE regenerating - we may need to preserve accumulated state
+                    const existingCache = await this.sessionInfoService.getInsights(sessionId);
+                    const beforeState = buildStateSnapshot(existingCache);
+                    this.logger.info('Computing insights for session', { traceId, sessionId });
+                    const insights = await this.computeInsights(sessionId);
+                    // Preserve accumulated milestones/notable if new result came back empty
+                    // This handles cases where the LLM regeneration doesn't capture the full history
+                    // Note: These V8 fields are deprecated and always [] for new sessions,
+                    // but old cached data may have values we want to preserve during recompute.
+                    if (existingCache) {
+                        const existingMilestones = existingCache.milestones || [];
+                        const existingNotable = existingCache.notable || [];
+                        // If new milestones are empty but we had some before, preserve them
+                        if ((insights.milestones || []).length === 0 && existingMilestones.length > 0) {
+                            this.logger.info('Preserving accumulated milestones from cache', {
+                                traceId,
+                                sessionId,
+                                preservedCount: existingMilestones.length
+                            });
+                            insights.milestones = existingMilestones;
+                        }
+                        // If new notable events are empty but we had some before, preserve them
+                        if ((insights.notable || []).length === 0 && existingNotable.length > 0) {
+                            this.logger.info('Preserving accumulated notable events from cache', {
+                                traceId,
+                                sessionId,
+                                preservedCount: existingNotable.length
+                            });
+                            insights.notable = existingNotable;
+                        }
+                    }
+                    await this.cacheInsights(sessionId, insights);
+                    computed++;
+                    // Build after state and determine what changed
+                    const afterState = buildStateSnapshot(null, insights);
+                    const changedFields = [];
+                    if (beforeState.mission !== afterState.mission)
+                        changedFields.push('mission');
+                    if (beforeState.description !== afterState.description)
+                        changedFields.push('description');
+                    if (beforeState.theme !== afterState.theme)
+                        changedFields.push('theme');
+                    if (JSON.stringify(beforeState.milestones) !== JSON.stringify(afterState.milestones))
+                        changedFields.push('milestones');
+                    const durationMs = Date.now() - startTime;
+                    // Audit the recompute with full before/after state
+                    this.sessionInfoService.auditEventInsight({
+                        traceId,
+                        sessionId,
+                        eventType: 'recompute',
+                        trigger: 'stale_refresh',
+                        beforeState,
+                        afterState,
+                        patchedFields: changedFields,
+                        durationMs,
+                        llmResponse: `Opus returned: context=${!!insights.context}, description=${!!insights.description}, milestones=${(insights.milestones || []).length}`,
+                    });
+                    this.logger.info('Insights computed successfully', {
+                        traceId,
+                        sessionId,
+                        milestones: (insights.milestones || []).length,
+                        notable: (insights.notable || []).length,
+                        changedFields,
+                        durationMs,
+                    });
+                }
+                catch (error) {
+                    this.logger.warn('Failed to compute insights for session', { traceId, sessionId, error });
+                }
+            }));
+        }
+        return computed;
+    }
+    /**
+     * Get insights without AI generation (faster, for list views)
+     */
+    async getInsightsQuick(sessionId) {
+        // Check cache first - return cached AI insights if available
+        const cached = await this.sessionInfoService.getInsights(sessionId);
+        if (cached) {
+            return this.cachedToSessionInsights(cached);
+        }
+        // No cached insights - fall back to local extraction (no AI call)
+        const { messages } = await this.historyReader.fetchConversationDirect(sessionId);
+        const todos = this.extractTodoState(messages);
+        const progress = todos ? this.computeProgress(todos) : null;
+        const recentlyCompleted = todos
+            ? todos
+                .filter(t => t.status === 'completed')
+                .slice(-3)
+                .map(t => t.content)
+            : [];
+        const outstanding = todos
+            ? todos
+                .filter(t => t.status === 'pending' || t.status === 'in_progress')
+                .map(t => t.content)
+            : [];
+        const currentTask = todos
+            ? todos.find(t => t.status === 'in_progress')?.content || null
+            : null;
+        // No theme in quick mode - will be set on user message
+        return {
+            sessionId,
+            context: null,
+            tags: null,
+            purposes: [],
+            description: null, // Skip AI generation for quick mode
+            progress,
+            recentlyCompleted,
+            outstanding,
+            currentTask,
+            theme: null,
+            // Deprecated fields (empty defaults)
+            currentState: null,
+            panels: [],
+            milestones: [],
+            notable: [],
+            recentActions: [],
+        };
+    }
+}
+// Legacy alias for backward compatibility during migration
+/** @deprecated Use InsightsComputer instead */
+export const SessionInsightsService = InsightsComputer;
+//# sourceMappingURL=insights-computer.js.map