claudia-orchestrator 0.1.0

package/dist/services/insights-service.js

@@ -0,0 +1,1152 @@
+/**
+ * InsightsService - Unified event-driven insights system.
+ *
+ * This consolidates InsightsEventCoordinator + InsightsEventHandler into a single service.
+ * It handles:
+ * 1. Watching for session activity (file changes in ~/.claude/projects)
+ * 2. Tracking session state (action counts, timing, etc.)
+ * 3. Triggering insight generation and patching via InsightQueue
+ * 4. Executing LLM operations (generation, quick check, patch)
+ *
+ * Architecture V2 Features:
+ * - InsightQueue for serialization (eliminates race conditions)
+ * - Haiku-heavy patches (cheap quick checks, targeted updates)
+ * - Ownership model for REFRESH (deterministic field ownership)
+ */
+import { EventEmitter } from 'events';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as crypto from 'crypto';
+import { createLogger } from './logger.js';
+import { ClaudeHistoryReader } from './claude-history-reader.js';
+import { SessionInfoService } from './session-info-service.js';
+import { SessionInsightsService } from './session-insights-service.js';
+import { anthropicService } from './anthropic-service.js';
+import { getSessionActivityWatcher } from './session-activity-watcher.js';
+import { getInsightQueue } from './insight-queue.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const INITIAL_GENERATION_THRESHOLD = 15; // Generate initial insights after 15 actions
+const FULL_REGEN_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes (reduced - Haiku patches handle most updates)
+const DEBOUNCE_MS = 150; // Debounce file changes
+const COMPLETION_CHECK_DELAY_MS = 5000; // Wait 5 seconds after assistant response
+const QUICK_CHECK_DEBOUNCE_MS = 5000; // Wait 5s of quiet before running quick check
+const QUICK_CHECK_STALENESS_THRESHOLD_MS = 30 * 1000; // Force check if >30s since last check
+const MAX_MILESTONES = 12; // Cap milestones to prevent endless growth
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Generate a short trace ID for correlating events through the system.
+ */
+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}`;
+}
+/**
+ * Check if insights are missing critical content fields.
+ *
+ * Only checks fields that are truly essential for the dashboard to be useful.
+ * Notable, progress_total, and recent_actions are OPTIONAL - sessions may not
+ * have significant events, todos, or enough activity yet.
+ */
+function hasMissingCriticalFields(insights) {
+    if (!insights)
+        return true;
+    // Mission is critical - we need to know what the session is about
+    if (!insights.context || !insights.context.mission)
+        return true;
+    // Panels are critical - they provide the main dashboard content
+    if (!insights.panels || insights.panels.length === 0)
+        return true;
+    // Milestones are critical - they show progress/intent
+    if (!insights.milestones || insights.milestones.length === 0)
+        return true;
+    // NOT critical (removed):
+    // - notable: may be empty if no significant events occurred
+    // - progress_total: 0 if no TodoWrite used (common)
+    // - recent_actions: may be empty early in session
+    return false;
+}
+// ============================================================================
+// InsightsService
+// ============================================================================
+export class InsightsService extends EventEmitter {
+    logger;
+    historyReader;
+    sessionInfoService;
+    insightsComputeService;
+    projectsDir;
+    // File watching
+    watchers = new Map();
+    debounceTimers = new Map();
+    isWatching = false;
+    // Session state tracking
+    sessionStates = new Map();
+    lastKnownMessageCounts = new Map();
+    // Duplicate prevention
+    pendingGenerations = new Set();
+    pendingQuickChecks = new Set();
+    // Queue integration - store events for deferred execution
+    pendingActionEvents = new Map();
+    pendingGenerateEvents = new Map();
+    constructor() {
+        super();
+        this.logger = createLogger('InsightsService');
+        this.historyReader = new ClaudeHistoryReader();
+        this.sessionInfoService = SessionInfoService.getInstance();
+        this.insightsComputeService = new SessionInsightsService(this.historyReader, this.sessionInfoService);
+        this.projectsDir = path.join(os.homedir(), '.claude', 'projects');
+    }
+    // ==========================================================================
+    // Lifecycle
+    // ==========================================================================
+    /**
+     * Initialize the insights service. Call once at startup.
+     */
+    initialize() {
+        // Set up the insight queue executor
+        const queue = getInsightQueue();
+        queue.setExecutor(this.executeQueueOperation.bind(this));
+        // Start watching for session activity
+        this.startWatching();
+        this.logger.info('Insights service initialized');
+    }
+    /**
+     * Stop the insights service. Call at shutdown.
+     */
+    stop() {
+        this.logger.info('Stopping insights service');
+        // Stop file watchers
+        for (const watcher of this.watchers.values()) {
+            watcher.close();
+        }
+        this.watchers.clear();
+        // Clear debounce timers
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        // Clear session timers
+        for (const state of this.sessionStates.values()) {
+            if (state.regenTimerId)
+                clearTimeout(state.regenTimerId);
+            if (state.completionCheckTimer)
+                clearTimeout(state.completionCheckTimer);
+            if (state.quickCheckDebounceTimer)
+                clearTimeout(state.quickCheckDebounceTimer);
+        }
+        this.sessionStates.clear();
+        this.isWatching = false;
+    }
+    // ==========================================================================
+    // File Watching
+    // ==========================================================================
+    startWatching() {
+        if (this.isWatching)
+            return;
+        this.logger.info('Starting file watchers', { projectsDir: this.projectsDir });
+        try {
+            this.watchDirectory(this.projectsDir);
+            if (fs.existsSync(this.projectsDir)) {
+                const projects = fs.readdirSync(this.projectsDir);
+                for (const project of projects) {
+                    const projectPath = path.join(this.projectsDir, project);
+                    if (fs.statSync(projectPath).isDirectory()) {
+                        this.watchProjectDirectory(projectPath);
+                    }
+                }
+            }
+            this.isWatching = true;
+            this.logger.info('File watchers started', { watcherCount: this.watchers.size });
+        }
+        catch (error) {
+            this.logger.error('Failed to start file watchers', error);
+        }
+    }
+    watchDirectory(dirPath) {
+        if (this.watchers.has(dirPath))
+            return;
+        try {
+            const watcher = fs.watch(dirPath, { persistent: false }, (eventType, filename) => {
+                if (!filename)
+                    return;
+                const fullPath = path.join(dirPath, filename);
+                if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+                    this.watchProjectDirectory(fullPath);
+                }
+            });
+            this.watchers.set(dirPath, watcher);
+        }
+        catch (error) {
+            this.logger.warn('Failed to watch directory', { dirPath, error });
+        }
+    }
+    watchProjectDirectory(projectPath) {
+        if (this.watchers.has(projectPath))
+            return;
+        try {
+            const watcher = fs.watch(projectPath, { persistent: false }, (eventType, filename) => {
+                if (!filename || !filename.endsWith('.jsonl'))
+                    return;
+                const filePath = path.join(projectPath, filename);
+                this.handleFileChange(filePath, filename);
+            });
+            this.watchers.set(projectPath, watcher);
+        }
+        catch (error) {
+            this.logger.warn('Failed to watch project directory', { projectPath, error });
+        }
+    }
+    handleFileChange(filePath, filename) {
+        const sessionId = filename.replace('.jsonl', '');
+        // Debounce rapid changes
+        const existingTimer = this.debounceTimers.get(sessionId);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        this.debounceTimers.set(sessionId, setTimeout(async () => {
+            this.debounceTimers.delete(sessionId);
+            await this.processSessionUpdate(sessionId);
+        }, DEBOUNCE_MS));
+    }
+    // ==========================================================================
+    // Session Update Processing
+    // ==========================================================================
+    async processSessionUpdate(sessionId) {
+        try {
+            const { messages } = await this.historyReader.fetchConversationDirect(sessionId);
+            let previousCount = this.lastKnownMessageCounts.get(sessionId) || 0;
+            const currentCount = messages.length;
+            // COLD START FIX: If this is first time seeing this session,
+            // check if cached insights exist. If so, skip entire history.
+            if (previousCount === 0) {
+                const state = this.sessionStates.get(sessionId);
+                if (!state) {
+                    const cachedInsights = await this.sessionInfoService.getInsights(sessionId);
+                    if (cachedInsights && cachedInsights.computed_at) {
+                        previousCount = currentCount;
+                        this.lastKnownMessageCounts.set(sessionId, currentCount);
+                        this.logger.info('Cold start: skipping history for session with existing insights', {
+                            sessionId: sessionId.slice(0, 8),
+                            messageCount: currentCount,
+                            computed_at: cachedInsights.computed_at
+                        });
+                        return;
+                    }
+                }
+            }
+            // No new messages
+            if (currentCount <= previousCount) {
+                return;
+            }
+            this.lastKnownMessageCounts.set(sessionId, currentCount);
+            // Extract new actions from new messages
+            const newMessages = messages.slice(previousCount);
+            const newActions = this.extractActions(newMessages);
+            if (newActions.length === 0) {
+                return;
+            }
+            // Update session state
+            let state = this.sessionStates.get(sessionId);
+            if (!state) {
+                const cachedInsights = await this.sessionInfoService.getInsights(sessionId);
+                const hasExistingInsights = cachedInsights && cachedInsights.computed_at;
+                state = {
+                    actionCount: 0,
+                    lastActionAt: 0,
+                    lastCheckAt: Date.now(),
+                    insightsGeneratedAt: hasExistingInsights ? Date.now() : undefined
+                };
+                this.sessionStates.set(sessionId, state);
+                if (hasExistingInsights) {
+                    this.logger.debug('Session state initialized with existing insights', {
+                        sessionId: sessionId.slice(0, 8),
+                        computed_at: cachedInsights.computed_at
+                    });
+                }
+            }
+            const previousActionCount = state.actionCount;
+            state.actionCount += newActions.length;
+            state.lastActionAt = Date.now();
+            this.logger.debug('Session activity detected', {
+                sessionId: sessionId.slice(0, 8),
+                newActions: newActions.length,
+                totalActions: state.actionCount,
+                hasInsights: !!state.insightsGeneratedAt
+            });
+            // Check if we should trigger initial generation
+            const shouldGenerateInitial = !state.insightsGeneratedAt &&
+                previousActionCount < INITIAL_GENERATION_THRESHOLD &&
+                state.actionCount >= INITIAL_GENERATION_THRESHOLD;
+            if (shouldGenerateInitial) {
+                if (this.pendingGenerations.has(sessionId)) {
+                    this.logger.debug('Skipping generation - already in progress', {
+                        sessionId: sessionId.slice(0, 8)
+                    });
+                    return;
+                }
+                this.logger.info('Triggering insights generation', {
+                    sessionId: sessionId.slice(0, 8),
+                    actionCount: state.actionCount,
+                    reason: 'initial'
+                });
+                this.enqueueGenerate({ sessionId, reason: 'initial', actionCount: state.actionCount });
+                return;
+            }
+            // Background regen every 100 actions (Haiku patches handle incremental updates)
+            if (state.insightsGeneratedAt && state.actionCount % 100 === 0 && state.actionCount > 0) {
+                if (!this.pendingGenerations.has(sessionId)) {
+                    this.logger.debug('Triggering background regeneration', {
+                        sessionId: sessionId.slice(0, 8),
+                        actionCount: state.actionCount
+                    });
+                    this.enqueueGenerate({ sessionId, reason: 'background', actionCount: state.actionCount });
+                }
+            }
+            // Force generation if insights exist but are missing critical content
+            // Check only every 100 actions - Haiku patches should fill gaps in most cases
+            // Also enforce 10-minute cooldown to prevent rapid regeneration
+            const MISSING_FIELDS_CHECK_INTERVAL = 100;
+            const REGENERATION_COOLDOWN_MS = 10 * 60 * 1000; // 10 minutes
+            let shouldForceRegenDueToMissingFields = false;
+            if (state.insightsGeneratedAt && state.actionCount % MISSING_FIELDS_CHECK_INTERVAL === 0) {
+                const cachedInsights = await this.sessionInfoService.getInsights(sessionId);
+                const hasMissing = hasMissingCriticalFields(cachedInsights);
+                // Check cooldown - don't regenerate if we regenerated recently
+                const timeSinceLastGen = Date.now() - state.insightsGeneratedAt;
+                const cooldownActive = timeSinceLastGen < REGENERATION_COOLDOWN_MS;
+                if (hasMissing && cooldownActive) {
+                    this.logger.debug('Skipping missing_fields regen due to cooldown', {
+                        sessionId: sessionId.slice(0, 8),
+                        timeSinceLastGenMs: timeSinceLastGen,
+                        cooldownMs: REGENERATION_COOLDOWN_MS
+                    });
+                }
+                shouldForceRegenDueToMissingFields = hasMissing && !cooldownActive;
+            }
+            if (shouldForceRegenDueToMissingFields) {
+                if (this.pendingGenerations.has(sessionId)) {
+                    return;
+                }
+                this.logger.info('Triggering insights generation', {
+                    sessionId: sessionId.slice(0, 8),
+                    actionCount: state.actionCount,
+                    reason: 'missing_fields'
+                });
+                this.enqueueGenerate({ sessionId, reason: 'missing_fields', actionCount: state.actionCount });
+                return;
+            }
+            // If we have insights, trigger action event for patch checking
+            if (state.insightsGeneratedAt) {
+                this.handleSessionAction(sessionId, state, newActions);
+            }
+        }
+        catch (error) {
+            this.logger.debug('Failed to process session update', {
+                sessionId: sessionId.slice(0, 8),
+                error
+            });
+        }
+    }
+    /**
+     * Handle action event - determine if/how to trigger patch checking
+     */
+    handleSessionAction(sessionId, state, newActions) {
+        const hasOnlyTextResponse = newActions.length === 1 && newActions[0].type === 'text';
+        const hasToolUse = newActions.some(a => a.type === 'tool_use');
+        if (hasOnlyTextResponse && !hasToolUse) {
+            // This might be a completion message - set up delayed check
+            if (state.completionCheckTimer) {
+                clearTimeout(state.completionCheckTimer);
+            }
+            state.lastResponseTimestamp = Date.now();
+            state.completionCheckTimer = setTimeout(() => {
+                const traceId = generateTraceId(sessionId);
+                this.logger.debug('Completion detected - forcing patch', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                });
+                this.enqueueAction({
+                    sessionId,
+                    actionCount: state.actionCount,
+                    newActions,
+                    timestamp: Date.now(),
+                    forcePatch: true,
+                    traceId
+                });
+                state.completionCheckTimer = undefined;
+            }, COMPLETION_CHECK_DELAY_MS);
+        }
+        else {
+            // Has tool use or user message - debounced action event
+            if (state.completionCheckTimer) {
+                clearTimeout(state.completionCheckTimer);
+                state.completionCheckTimer = undefined;
+            }
+            const hasUserMessage = newActions.some(a => a.type === 'user_message');
+            const timeSinceLastCheck = Date.now() - state.lastCheckAt;
+            const isStale = timeSinceLastCheck > QUICK_CHECK_STALENESS_THRESHOLD_MS;
+            if (hasUserMessage || isStale) {
+                // Immediate emit
+                if (state.quickCheckDebounceTimer) {
+                    clearTimeout(state.quickCheckDebounceTimer);
+                    state.quickCheckDebounceTimer = undefined;
+                }
+                const traceId = generateTraceId(sessionId);
+                this.enqueueAction({
+                    sessionId,
+                    actionCount: state.actionCount,
+                    newActions,
+                    timestamp: Date.now(),
+                    forcePatch: hasUserMessage,
+                    traceId
+                });
+            }
+            else {
+                // DEBOUNCE: Wait for quiet period
+                if (state.quickCheckDebounceTimer) {
+                    clearTimeout(state.quickCheckDebounceTimer);
+                }
+                const capturedActions = [...newActions];
+                const capturedActionCount = state.actionCount;
+                state.quickCheckDebounceTimer = setTimeout(() => {
+                    const traceId = generateTraceId(sessionId);
+                    this.enqueueAction({
+                        sessionId,
+                        actionCount: capturedActionCount,
+                        newActions: capturedActions,
+                        timestamp: Date.now(),
+                        forcePatch: false,
+                        traceId
+                    });
+                    state.quickCheckDebounceTimer = undefined;
+                }, QUICK_CHECK_DEBOUNCE_MS);
+            }
+        }
+    }
+    // ==========================================================================
+    // Action Extraction
+    // ==========================================================================
+    extractActions(messages) {
+        const actions = [];
+        const pendingToolUses = new Map();
+        for (const msg of messages) {
+            const content = msg.message?.content;
+            if (!Array.isArray(content))
+                continue;
+            if (msg.type === 'user') {
+                for (const block of content) {
+                    if (typeof block !== 'object' || block === null || !('type' in block))
+                        continue;
+                    if (block.type === 'tool_result' && 'tool_use_id' in block) {
+                        const toolUseId = block.tool_use_id;
+                        const pending = pendingToolUses.get(toolUseId);
+                        if (pending) {
+                            let resultContent = '';
+                            if (typeof block.content === 'string') {
+                                resultContent = block.content;
+                            }
+                            else if (Array.isArray(block.content)) {
+                                resultContent = block.content
+                                    .filter((b) => b.type === 'text' && b.text)
+                                    .map((b) => b.text)
+                                    .join('\n');
+                            }
+                            if (actions[pending.index]) {
+                                actions[pending.index].output = resultContent.slice(0, 200);
+                            }
+                            pendingToolUses.delete(toolUseId);
+                        }
+                        continue;
+                    }
+                    if (block.type === 'text' && 'text' in block) {
+                        const fullText = block.text.trim();
+                        if (fullText.length > 0) {
+                            actions.push({ type: 'user_message', text: fullText });
+                        }
+                    }
+                }
+                continue;
+            }
+            if (msg.type === 'assistant') {
+                for (const block of content) {
+                    if (typeof block !== 'object' || block === null || !('type' in block))
+                        continue;
+                    if (block.type === 'tool_use' && 'name' in block && 'id' in block) {
+                        const toolName = block.name;
+                        const toolId = block.id;
+                        const input = block.input;
+                        let inputSummary = '';
+                        if (input) {
+                            switch (toolName) {
+                                case 'Read':
+                                case 'Edit':
+                                case 'Write':
+                                    inputSummary = this.extractFilename(input.file_path);
+                                    break;
+                                case 'Grep':
+                                    inputSummary = `pattern: "${input.pattern?.slice(0, 40)}"`;
+                                    break;
+                                case 'Glob':
+                                    inputSummary = `pattern: ${input.pattern?.slice(0, 40)}`;
+                                    break;
+                                case 'Bash': {
+                                    const desc = input.description;
+                                    const cmd = input.command;
+                                    inputSummary = desc || cmd?.slice(0, 80) || '';
+                                    break;
+                                }
+                                case 'Task':
+                                    inputSummary = input.description?.slice(0, 60) || '';
+                                    break;
+                                default: {
+                                    const firstKey = Object.keys(input)[0];
+                                    if (firstKey && input[firstKey]) {
+                                        const val = input[firstKey];
+                                        inputSummary = typeof val === 'string' ? val.slice(0, 60) : JSON.stringify(val).slice(0, 60);
+                                    }
+                                }
+                            }
+                        }
+                        const actionIndex = actions.length;
+                        actions.push({ type: 'tool_use', name: toolName, input: inputSummary });
+                        pendingToolUses.set(toolId, { name: toolName, input: inputSummary, index: actionIndex });
+                    }
+                    else if (block.type === 'text' && 'text' in block) {
+                        const fullText = block.text.trim();
+                        if (fullText.length > 0) {
+                            actions.push({ type: 'text', text: fullText });
+                        }
+                    }
+                }
+            }
+        }
+        return actions;
+    }
+    extractFilename(filePath) {
+        if (!filePath)
+            return '';
+        const parts = filePath.split('/');
+        return parts[parts.length - 1] || filePath.slice(-40);
+    }
+    // ==========================================================================
+    // Queue Integration
+    // ==========================================================================
+    enqueueGenerate(event) {
+        const { sessionId, reason } = event;
+        this.pendingGenerateEvents.set(sessionId, event);
+        const opType = (reason === 'background' || reason === 'scheduled') ? 'REFRESH' : 'GENERATE';
+        const priority = (reason === 'initial' || reason === 'missing_fields') ? 'high' : 'low';
+        getInsightQueue().enqueue({
+            type: opType,
+            sessionId,
+            priority,
+            trigger: this.mapReasonToTrigger(reason),
+        });
+    }
+    enqueueAction(event) {
+        const { sessionId, newActions, traceId } = event;
+        this.pendingActionEvents.set(sessionId, event);
+        const hasUserMessage = newActions.some(a => a.type === 'user_message');
+        const trigger = hasUserMessage ? 'user_message' : 'tool_use';
+        const priority = hasUserMessage ? 'high' : 'normal';
+        getInsightQueue().enqueue({
+            type: 'PATCH',
+            sessionId,
+            priority,
+            trigger,
+            traceId,
+        });
+    }
+    mapReasonToTrigger(reason) {
+        switch (reason) {
+            case 'initial': return 'initial';
+            case 'scheduled': return 'scheduled';
+            case 'manual': return 'manual';
+            case 'missing_fields': return 'missing_fields';
+            case 'background': return 'scheduled';
+            default: return 'manual';
+        }
+    }
+    async executeQueueOperation(op) {
+        const { type, sessionId, trigger, traceId } = op;
+        this.logger.debug('Executing queued operation', {
+            type,
+            sessionId: sessionId.slice(0, 8),
+            trigger,
+            traceId,
+        });
+        switch (type) {
+            case 'GENERATE': {
+                const event = this.pendingGenerateEvents.get(sessionId);
+                if (event) {
+                    this.pendingGenerateEvents.delete(sessionId);
+                    await this.executeGenerate(event);
+                }
+                break;
+            }
+            case 'PATCH': {
+                const event = this.pendingActionEvents.get(sessionId);
+                if (event) {
+                    this.pendingActionEvents.delete(sessionId);
+                    await this.executeAction(event);
+                }
+                break;
+            }
+            case 'REFRESH': {
+                const event = this.pendingGenerateEvents.get(sessionId);
+                if (event) {
+                    this.pendingGenerateEvents.delete(sessionId);
+                    await this.executeGenerate(event);
+                }
+                else {
+                    await this.executeGenerate({ sessionId, reason: 'scheduled', actionCount: 0 });
+                }
+                break;
+            }
+        }
+    }
+    // ==========================================================================
+    // LLM Operations - Generation
+    // ==========================================================================
+    async executeGenerate(event) {
+        const { sessionId, reason, actionCount } = event;
+        if (this.pendingGenerations.has(sessionId)) {
+            return;
+        }
+        this.pendingGenerations.add(sessionId);
+        try {
+            this.logger.debug('Generating insights', {
+                sessionId: sessionId.slice(0, 8),
+                reason,
+                actionCount
+            });
+            const startTime = Date.now();
+            const freshInsights = await this.insightsComputeService.computeInsights(sessionId);
+            const duration = Date.now() - startTime;
+            let finalInsights = freshInsights;
+            // For REFRESH, apply ownership model
+            if (reason === 'background' || reason === 'scheduled') {
+                try {
+                    const cachedInsights = await this.insightsComputeService.getInsights(sessionId);
+                    if (cachedInsights) {
+                        finalInsights = this.applyOwnershipModel(cachedInsights, freshInsights);
+                        this.logger.debug('[REFRESH] Ownership model applied', {
+                            sessionId: sessionId.slice(0, 8),
+                            finalMission: finalInsights.context?.mission?.slice(0, 50),
+                            finalMilestoneCount: finalInsights.milestones?.length || 0,
+                        });
+                    }
+                }
+                catch (mergeError) {
+                    this.logger.warn('[REFRESH] Ownership apply failed, using fresh insights', {
+                        sessionId: sessionId.slice(0, 8),
+                        error: mergeError instanceof Error ? mergeError.message : String(mergeError)
+                    });
+                }
+            }
+            await this.insightsComputeService.cacheInsights(sessionId, finalInsights);
+            this.markInsightsGenerated(sessionId);
+            this.logger.info('Insights generated successfully', {
+                sessionId: sessionId.slice(0, 8),
+                reason,
+                durationMs: duration,
+                mission: finalInsights.context?.mission?.slice(0, 50),
+            });
+            await new Promise(resolve => setTimeout(resolve, 100));
+            await getSessionActivityWatcher().emitInsightsUpdate(sessionId, 'generated');
+        }
+        catch (error) {
+            this.logger.error('Failed to generate insights', {
+                sessionId: sessionId.slice(0, 8),
+                reason,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        finally {
+            this.pendingGenerations.delete(sessionId);
+        }
+    }
+    /**
+     * Apply deterministic ownership model for REFRESH operations.
+     * - Haiku owns (keep cached): currentState, milestones, recentActions
+     * - Opus owns (use fresh): context, panels, tags, theme
+     * - Notable: accumulates (merge, don't replace)
+     */
+    applyOwnershipModel(cached, fresh) {
+        const mergedNotable = this.mergeNotableEvents(cached.notable || [], fresh.notable || []);
+        return {
+            ...fresh,
+            context: fresh.context,
+            panels: fresh.panels,
+            tags: fresh.tags,
+            theme: fresh.theme,
+            currentState: cached.currentState,
+            milestones: cached.milestones,
+            recentActions: cached.recentActions,
+            notable: mergedNotable,
+            purposes: fresh.purposes?.length ? fresh.purposes : cached.purposes,
+            description: fresh.description || cached.description,
+            progress: fresh.progress || cached.progress,
+            recentlyCompleted: fresh.recentlyCompleted?.length ? fresh.recentlyCompleted : cached.recentlyCompleted,
+            outstanding: fresh.outstanding?.length ? fresh.outstanding : cached.outstanding,
+            currentTask: fresh.currentTask || cached.currentTask,
+            computedAt: fresh.computedAt,
+            patchedAt: cached.patchedAt,
+        };
+    }
+    mergeNotableEvents(existing, fresh) {
+        const existingSignatures = new Set(existing.map(e => (e.text || e.description || '').toLowerCase().trim()));
+        const merged = [...existing];
+        for (const freshEvent of fresh) {
+            const signature = (freshEvent.text || freshEvent.description || '').toLowerCase().trim();
+            if (signature && !existingSignatures.has(signature)) {
+                merged.push(freshEvent);
+                existingSignatures.add(signature);
+            }
+        }
+        const MAX_NOTABLE = 20;
+        if (merged.length > MAX_NOTABLE) {
+            return merged.slice(-MAX_NOTABLE);
+        }
+        return merged;
+    }
+    // ==========================================================================
+    // LLM Operations - Patching
+    // ==========================================================================
+    async executeAction(event) {
+        const { sessionId, newActions, actionCount, forcePatch, traceId } = event;
+        const trigger = newActions.some(a => a.type === 'user_message') ? 'user_message'
+            : newActions.some(a => a.type === 'tool_use') ? 'tool_use'
+                : 'completion';
+        if (this.pendingQuickChecks.has(sessionId)) {
+            this.logger.debug('Skipping check - already in progress', { traceId, sessionId: sessionId.slice(0, 8) });
+            SessionInfoService.getInstance().auditEventInsight({
+                traceId,
+                sessionId,
+                eventType: 'skip',
+                trigger,
+                actionContent: newActions.map(a => a.type === 'tool_use' ? `tool:${a.name}` : `${a.type}:${(a.text || '').slice(0, 50)}`),
+                skippedReason: 'already_in_progress'
+            });
+            return;
+        }
+        this.pendingQuickChecks.add(sessionId);
+        const startTime = Date.now();
+        try {
+            const cached = await SessionInfoService.getInstance().getInsights(sessionId);
+            if (!cached) {
+                this.logger.debug('No cached insights for check', { traceId, sessionId: sessionId.slice(0, 8) });
+                SessionInfoService.getInstance().auditEventInsight({
+                    traceId,
+                    sessionId,
+                    eventType: 'skip',
+                    trigger,
+                    actionContent: newActions.map(a => a.type === 'tool_use' ? `tool:${a.name}` : `${a.type}:${(a.text || '').slice(0, 50)}`),
+                    skippedReason: 'no_cached_insights'
+                });
+                return;
+            }
+            const beforeState = {
+                mission: cached.context?.mission,
+                currentState: cached.current_state?.content,
+                milestones: cached.milestones?.map(m => `${m.label}:${m.status}`),
+                panels: cached.panels?.map(p => p.label || p.title || 'unnamed')
+            };
+            const recentActivity = newActions.map(a => {
+                if (a.type === 'tool_use') {
+                    let content = `Tool: ${a.name}`;
+                    if (a.input)
+                        content += ` (${a.input})`;
+                    if (a.output)
+                        content += ` → ${a.output.slice(0, 100)}`;
+                    return { type: a.type, content };
+                }
+                return { type: a.type, content: a.text || '' };
+            });
+            const actionContent = newActions.map(a => {
+                if (a.type === 'tool_use') {
+                    let content = `tool:${a.name}`;
+                    if (a.input)
+                        content += `(${a.input.slice(0, 30)})`;
+                    return content;
+                }
+                return `${a.type}:${(a.text || '').slice(0, 50)}`;
+            });
+            if (forcePatch) {
+                await this.doPatch(sessionId, cached, recentActivity, traceId, beforeState, actionContent, trigger);
+                return;
+            }
+            // Normal flow: quick check with Haiku first
+            const recentActionsText = newActions.map(a => {
+                if (a.type === 'tool_use') {
+                    let actionText = `Tool: ${a.name}`;
+                    if (a.input)
+                        actionText += ` (${a.input})`;
+                    if (a.output)
+                        actionText += ` → ${a.output.slice(0, 100)}`;
+                    return actionText;
+                }
+                else if (a.type === 'user_message') {
+                    return `User: ${a.text}`;
+                }
+                else {
+                    return `Response: ${a.text}`;
+                }
+            });
+            const quickCheckStartTime = Date.now();
+            const quickCheckResult = await this.doQuickCheck(cached, recentActionsText, traceId);
+            const quickCheckDurationMs = Date.now() - quickCheckStartTime;
+            this.markQuickCheckPerformed(sessionId);
+            if (quickCheckResult.needsPatch) {
+                SessionInfoService.getInstance().auditEventInsight({
+                    traceId,
+                    sessionId,
+                    eventType: 'quick_check',
+                    trigger,
+                    actionContent,
+                    beforeState,
+                    llmResponse: `needsPatch=true: ${quickCheckResult.reason}`,
+                    durationMs: quickCheckDurationMs
+                });
+                await this.doPatch(sessionId, cached, recentActivity, traceId, beforeState, actionContent, trigger);
+            }
+            else {
+                this.logger.debug('Quick check: no patch needed', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                    reason: quickCheckResult.reason,
+                });
+                SessionInfoService.getInstance().auditEventInsight({
+                    traceId,
+                    sessionId,
+                    eventType: 'quick_check',
+                    trigger,
+                    actionContent,
+                    beforeState,
+                    llmResponse: `needsPatch=false: ${quickCheckResult.reason}`,
+                    durationMs: quickCheckDurationMs,
+                    skippedReason: 'haiku_said_no_patch_needed'
+                });
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to handle action event', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            this.pendingQuickChecks.delete(sessionId);
+        }
+    }
+    async doQuickCheck(cached, recentActions, traceId) {
+        const mission = cached.context?.mission || 'Unknown';
+        const milestones = (cached.milestones || []);
+        const panels = (cached.panels || []);
+        return await anthropicService.quickCheckInsightsStale({ mission, milestones, panels }, recentActions);
+    }
+    async doPatch(sessionId, cached, recentActivity, traceId, beforeState, actionContent, trigger) {
+        const patchStartTime = Date.now();
+        const currentInsights = {
+            mission: cached.context?.mission || cached.description || 'Unknown',
+            description: cached.description || '',
+            theme: cached.theme || 'unknown',
+            currentState: cached.current_state || null,
+            milestones: (cached.milestones || []),
+            panels: (cached.panels || []),
+            notable: (cached.notable || []).map(n => ({ text: n.description || n.text || '', icon: n.icon })),
+            recentActions: (cached.recent_actions || []),
+            tags: cached.tags ? [...(cached.tags.workType || []), ...(cached.tags.domain || [])] : [],
+            previousPropositions: (cached.propositions || [])
+        };
+        const result = await anthropicService.generateInsightsPatch(currentInsights, recentActivity);
+        const llmDurationMs = Date.now() - patchStartTime;
+        const patchKeys = Object.keys(result.patches);
+        if (patchKeys.length === 0) {
+            this.logger.debug('Sonnet generated no patches', { traceId, sessionId: sessionId.slice(0, 8) });
+            if (trigger) {
+                SessionInfoService.getInstance().auditEventInsight({
+                    traceId,
+                    sessionId,
+                    eventType: 'patch',
+                    trigger,
+                    actionContent,
+                    beforeState,
+                    llmResponse: `no_patches: ${result.reason}`,
+                    patchedFields: [],
+                    durationMs: llmDurationMs
+                });
+            }
+            return;
+        }
+        await this.applyPatches(sessionId, cached, result.patches, result.propositions, traceId);
+        this.markInsightsPatched(sessionId);
+        const totalDurationMs = Date.now() - patchStartTime;
+        this.logger.debug('Patches applied', {
+            traceId,
+            sessionId: sessionId.slice(0, 8),
+            patchedFields: patchKeys,
+        });
+        const updatedCached = await SessionInfoService.getInstance().getInsights(sessionId);
+        const afterState = updatedCached ? {
+            mission: updatedCached.context?.mission,
+            currentState: updatedCached.current_state?.content,
+            milestones: updatedCached.milestones?.map(m => `${m.label}:${m.status}`),
+            panels: updatedCached.panels?.map(p => p.label || p.title || 'unnamed')
+        } : undefined;
+        if (trigger) {
+            SessionInfoService.getInstance().auditEventInsight({
+                traceId,
+                sessionId,
+                eventType: 'patch',
+                trigger,
+                actionContent,
+                beforeState,
+                afterState,
+                llmResponse: result.reason,
+                patchedFields: patchKeys,
+                durationMs: totalDurationMs
+            });
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+        await getSessionActivityWatcher().emitInsightsUpdate(sessionId, 'patched');
+    }
+    async applyPatches(sessionId, cached, patches, propositions, traceId) {
+        const updated = { ...cached };
+        updated.propositions = propositions;
+        if (patches.mission && updated.context) {
+            updated.context = { ...updated.context, mission: patches.mission };
+        }
+        if (patches.description) {
+            updated.description = patches.description;
+        }
+        if (patches.theme) {
+            updated.theme = patches.theme;
+        }
+        if (patches.currentState) {
+            updated.current_state = patches.currentState;
+            updated.last_patch_trace_id = traceId;
+        }
+        if (patches.recentActions) {
+            updated.recent_actions = patches.recentActions;
+        }
+        if (patches.milestones && Array.isArray(updated.milestones)) {
+            const milestones = [...updated.milestones];
+            // Track existing labels for deduplication (case-insensitive)
+            const existingLabels = new Set(milestones.map(m => m.label.toLowerCase().trim()));
+            for (const patch of patches.milestones) {
+                if (patch.action === 'update') {
+                    const idx = milestones.findIndex(m => m.label === patch.label);
+                    if (idx >= 0 && patch.status) {
+                        milestones[idx] = { ...milestones[idx], status: patch.status };
+                    }
+                }
+                else if (patch.action === 'add' && patch.status) {
+                    // Deduplicate: skip if label already exists
+                    const normalizedLabel = patch.label.toLowerCase().trim();
+                    if (!existingLabels.has(normalizedLabel)) {
+                        milestones.push({ label: patch.label, status: patch.status });
+                        existingLabels.add(normalizedLabel);
+                    }
+                }
+            }
+            // Cap milestones to prevent endless growth (keep most recent)
+            if (milestones.length > MAX_MILESTONES) {
+                // Keep the first few done items and the most recent items
+                const doneItems = milestones.filter(m => m.status === 'done').slice(0, 3);
+                const nonDoneItems = milestones.filter(m => m.status !== 'done');
+                const recentItems = milestones.slice(-(MAX_MILESTONES - doneItems.length));
+                // Merge: keep done items that aren't in recent, plus recent
+                const mergedSet = new Set(recentItems.map(m => m.label));
+                const uniqueDone = doneItems.filter(m => !mergedSet.has(m.label));
+                updated.milestones = [...uniqueDone, ...recentItems].slice(-MAX_MILESTONES);
+            }
+            else {
+                updated.milestones = milestones;
+            }
+        }
+        if (patches.panels && Array.isArray(updated.panels)) {
+            const panels = [...updated.panels];
+            for (const patch of patches.panels) {
+                if (patch.action === 'remove') {
+                    const idx = panels.findIndex(p => (p.label && p.label === patch.label) ||
+                        (p.title && p.title === patch.title));
+                    if (idx >= 0) {
+                        panels.splice(idx, 1);
+                    }
+                }
+                else if (patch.action === 'update') {
+                    const idx = panels.findIndex(p => (p.label && p.label === patch.label) ||
+                        (p.title && p.title === patch.title));
+                    if (idx >= 0) {
+                        if (patch.value !== undefined) {
+                            panels[idx] = { ...panels[idx], value: patch.value };
+                        }
+                        else if (patch.items !== undefined) {
+                            panels[idx] = { ...panels[idx], items: patch.items };
+                        }
+                    }
+                }
+                else if (patch.action === 'add') {
+                    if (panels.length >= 4) {
+                        this.logger.warn('Panel limit reached - skipping add', {
+                            traceId,
+                            sessionId: sessionId.slice(0, 8),
+                        });
+                        continue;
+                    }
+                    panels.push({
+                        label: patch.label,
+                        icon: patch.icon,
+                        color: patch.color,
+                        value: patch.value
+                    });
+                }
+            }
+            if (panels.length > 4) {
+                panels.splice(4);
+            }
+            updated.panels = panels;
+        }
+        if (patches.notable && Array.isArray(updated.notable)) {
+            const notable = [...updated.notable];
+            for (const patch of patches.notable) {
+                if (patch.action === 'add') {
+                    notable.push({
+                        type: patch.type || 'event',
+                        description: patch.text,
+                        text: patch.text,
+                        icon: patch.icon
+                    });
+                }
+            }
+            updated.notable = notable;
+        }
+        updated.patched_at = new Date().toISOString();
+        await SessionInfoService.getInstance().setInsights(updated);
+    }
+    // ==========================================================================
+    // Session State Management
+    // ==========================================================================
+    /**
+     * Called when insights have been generated for a session
+     */
+    markInsightsGenerated(sessionId) {
+        let state = this.sessionStates.get(sessionId);
+        if (!state) {
+            state = {
+                actionCount: 0,
+                lastActionAt: Date.now(),
+                lastCheckAt: Date.now()
+            };
+            this.sessionStates.set(sessionId, state);
+        }
+        state.insightsGeneratedAt = Date.now();
+        state.insightsPatchedAt = undefined;
+        this.startRegenTimer(sessionId, state);
+        this.logger.info('Insights generated, starting regen timer', {
+            sessionId: sessionId.slice(0, 8),
+            regenAt: new Date(Date.now() + FULL_REGEN_INTERVAL_MS).toISOString()
+        });
+    }
+    markInsightsPatched(sessionId) {
+        const state = this.sessionStates.get(sessionId);
+        if (state) {
+            state.insightsPatchedAt = Date.now();
+            state.lastCheckAt = Date.now();
+        }
+    }
+    markQuickCheckPerformed(sessionId) {
+        const state = this.sessionStates.get(sessionId);
+        if (state) {
+            state.lastCheckAt = Date.now();
+        }
+    }
+    startRegenTimer(sessionId, state) {
+        if (state.regenTimerId) {
+            clearTimeout(state.regenTimerId);
+        }
+        state.regenTimerId = setTimeout(() => {
+            const timeSinceLastAction = Date.now() - state.lastActionAt;
+            if (timeSinceLastAction > 5 * 60 * 1000) {
+                this.logger.info('Session idle - cleaning up tracking', {
+                    sessionId: sessionId.slice(0, 8),
+                    idleMinutes: Math.round(timeSinceLastAction / 60000)
+                });
+                this.cleanupSession(sessionId);
+                return;
+            }
+            this.logger.info('Triggering scheduled full regeneration', {
+                sessionId: sessionId.slice(0, 8),
+            });
+            this.enqueueGenerate({ sessionId, reason: 'scheduled', actionCount: state.actionCount });
+        }, FULL_REGEN_INTERVAL_MS);
+    }
+    /**
+     * Clean up tracking for a session (call when archived or idle)
+     */
+    cleanupSession(sessionId) {
+        const state = this.sessionStates.get(sessionId);
+        if (!state) {
+            return;
+        }
+        this.logger.info('Cleaning up session tracking', {
+            sessionId: sessionId.slice(0, 8),
+            actionCount: state.actionCount,
+        });
+        if (state.regenTimerId)
+            clearTimeout(state.regenTimerId);
+        if (state.completionCheckTimer)
+            clearTimeout(state.completionCheckTimer);
+        if (state.quickCheckDebounceTimer)
+            clearTimeout(state.quickCheckDebounceTimer);
+        const debounceTimer = this.debounceTimers.get(sessionId);
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            this.debounceTimers.delete(sessionId);
+        }
+        const projectPath = path.join(this.projectsDir, sessionId);
+        const watcher = this.watchers.get(projectPath);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(projectPath);
+        }
+        this.sessionStates.delete(sessionId);
+        this.lastKnownMessageCounts.delete(sessionId);
+        this.logger.debug('Session cleanup complete', {
+            sessionId: sessionId.slice(0, 8),
+            remainingTrackedSessions: this.sessionStates.size
+        });
+    }
+    /**
+     * Get the current state for a session (for debugging/UI)
+     */
+    getSessionState(sessionId) {
+        return this.sessionStates.get(sessionId);
+    }
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let instance = null;
+export function getInsightsService() {
+    if (!instance) {
+        instance = new InsightsService();
+    }
+    return instance;
+}
+/**
+ * Initialize the insights service. Call once at server startup.
+ */
+export function initializeInsightsService() {
+    const service = getInsightsService();
+    service.initialize();
+}
+//# sourceMappingURL=insights-service.js.map