lattice-orchestrator 0.7.0

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

@@ -0,0 +1,1678 @@
+/**
+ * InsightsCoordinator - Unified event-driven insights system.
+ *
+ * ⚠️ LARGE FILE WARNING: ~2000 lines. Navigate using section markers (search "// ====").
+ *
+ * SECTIONS:
+ * - Types (~line 40) - ActionEvent, GenerateEvent, etc.
+ * - Constants (~line 100) - Timing constants, model settings
+ * - Helpers (~line 130) - generateTraceId, etc.
+ * - InsightsCoordinator class (~line 150) - Main coordinator
+ * - Singleton (~line 1950) - getInstance, initialization
+ *
+ * KEY METHODS:
+ * - handleAction() - Process new tool/text actions
+ * - handleGenerate() - Initial insight generation
+ * - handleRefresh() - Re-fetch from cache or regenerate
+ * - doPatch() - Execute Haiku quick-check → Sonnet patch flow
+ * - doRecompute() - Full Opus regeneration
+ *
+ * This is the COORDINATOR that orchestrates insight generation. It does NOT compute
+ * insights itself - that's InsightsComputer's job. This service 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)
+ *
+ * Related services:
+ * - InsightsComputer (insights-computer.ts) - builds prompts, calls LLMs
+ * - InsightQueue (insight-queue.ts) - serializes operations per session
+ * - InsightsEventLog (insights-event-log.ts) - audit logging
+ */
+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 '../infrastructure/logger.js';
+import { ClaudeHistoryReader } from '../sessions/claude-history-reader.js';
+import { SessionInfoService } from '../sessions/session-info-service.js';
+import { InsightsComputer } from '../insights/insights-computer.js';
+import { anthropicService } from '../insights/anthropic-service.js';
+import { getSessionActivityWatcher } from '../sessions/session-activity-watcher.js';
+import { getInsightQueue } from '../insights/insight-queue.js';
+import { getInsightsEventLog } from '../insights/insights-event-log.js';
+// ============================================================================
+// Constants
+// ============================================================================
+const INITIAL_GENERATION_THRESHOLD = 20; // Generate initial insights after 20 actions
+const FULL_REGEN_INTERVAL_MS = 0; // DISABLED - patches handle incremental updates, no need for periodic full regen
+const DEBOUNCE_MS = 150; // Debounce file changes
+const COMPLETION_CHECK_DELAY_MS = 5000; // Wait 5 seconds after assistant response
+const QUICK_CHECK_DEBOUNCE_MS = 15000; // Wait 15s of quiet before running quick check
+const QUICK_CHECK_STALENESS_THRESHOLD_MS = 120 * 1000; // Force check if >120s since last check
+// ============================================================================
+// 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}`;
+}
+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;
+    return false;
+}
+// ============================================================================
+// InsightsCoordinator
+// ============================================================================
+export class InsightsCoordinator extends EventEmitter {
+    logger;
+    historyReader;
+    sessionInfoService;
+    insightsComputer;
+    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();
+    // Event log for observability
+    eventLog = getInsightsEventLog();
+    constructor() {
+        super();
+        this.logger = createLogger('InsightsCoordinator');
+        this.historyReader = new ClaudeHistoryReader();
+        this.sessionInfoService = SessionInfoService.getInstance();
+        this.insightsComputer = new InsightsComputer(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();
+        // Reconcile any sessions that changed while server was down
+        // Run async - don't block initialization
+        this.reconcileStaleInsights().catch(error => {
+            this.logger.error('Failed to reconcile stale insights on startup', error);
+        });
+        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;
+    }
+    /**
+     * Reconcile stale insights on startup.
+     *
+     * Finds sessions where the file mtime > patched_at, meaning the session
+     * had activity that wasn't captured (e.g., during server restart).
+     * Queues forced patches to bring insights up to date.
+     */
+    async reconcileStaleInsights() {
+        const startTime = Date.now();
+        try {
+            // Get all sessions with insights
+            const allInsights = await this.sessionInfoService.getAllInsights();
+            if (allInsights.size === 0) {
+                this.logger.debug('No insights to reconcile');
+                return;
+            }
+            // Get session IDs that have insights
+            const sessionIds = Array.from(allInsights.keys());
+            // Get file mtimes for all sessions
+            const mtimes = await this.historyReader.getSessionFileMtimes(sessionIds);
+            // Find sessions where file is newer than patched_at
+            const staleSessions = [];
+            for (const [sessionId, insights] of allInsights.entries()) {
+                const mtime = mtimes.get(sessionId);
+                if (!mtime)
+                    continue; // File doesn't exist
+                const patchedAt = insights.patched_at
+                    ? new Date(insights.patched_at).getTime()
+                    : insights.computed_at
+                        ? new Date(insights.computed_at).getTime()
+                        : 0;
+                // If file was modified after last patch, it's stale
+                // Add 1 second buffer to avoid false positives from timing differences
+                if (mtime > patchedAt + 1000) {
+                    staleSessions.push({
+                        sessionId,
+                        patchedAt,
+                        mtime,
+                        gap: Math.round((mtime - patchedAt) / 1000)
+                    });
+                }
+            }
+            if (staleSessions.length === 0) {
+                this.logger.info('Startup reconciliation: all insights up to date', {
+                    checkedCount: sessionIds.length,
+                    durationMs: Date.now() - startTime
+                });
+                return;
+            }
+            this.logger.info('Startup reconciliation: found stale sessions', {
+                staleCount: staleSessions.length,
+                totalChecked: sessionIds.length,
+                staleSessions: staleSessions.slice(0, 10).map(s => ({
+                    sessionId: s.sessionId.slice(0, 8),
+                    gapSeconds: s.gap
+                }))
+            });
+            // Queue forced patches for stale sessions
+            // Limit to most recently modified to avoid overwhelming the queue on first startup
+            const sortedStale = staleSessions.sort((a, b) => b.mtime - a.mtime);
+            const toReconcile = sortedStale.slice(0, 20); // Max 20 sessions per startup
+            for (const { sessionId } of toReconcile) {
+                await this.triggerReconciliationPatch(sessionId);
+            }
+            this.logger.info('Startup reconciliation: queued patches', {
+                queuedCount: toReconcile.length,
+                skippedCount: staleSessions.length - toReconcile.length,
+                durationMs: Date.now() - startTime
+            });
+        }
+        catch (error) {
+            this.logger.error('Startup reconciliation failed', error);
+        }
+    }
+    /**
+     * Trigger a forced patch for a session during reconciliation.
+     * Reads recent messages and queues a force-patch (skips Haiku quick-check).
+     */
+    async triggerReconciliationPatch(sessionId) {
+        try {
+            const { messages } = await this.historyReader.fetchConversationDirect(sessionId);
+            if (!messages || messages.length === 0)
+                return;
+            // Get the last 20 messages for context (or fewer if session is short)
+            const recentMessages = messages.slice(-20);
+            const newActions = this.extractActions(recentMessages);
+            if (newActions.length === 0) {
+                // If no actions extractable, create a synthetic one
+                newActions.push({ type: 'text', text: '[Reconciliation - catching up on missed activity]' });
+            }
+            const traceId = generateTraceId(sessionId);
+            this.logger.debug('Triggering reconciliation patch', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                messageCount: messages.length,
+                actionCount: newActions.length
+            });
+            // Initialize session state if needed
+            if (!this.sessionStates.has(sessionId)) {
+                this.sessionStates.set(sessionId, {
+                    actionCount: 0,
+                    lastActionAt: Date.now(),
+                    lastCheckAt: Date.now(),
+                    actionsSinceLastPatch: []
+                });
+            }
+            const state = this.sessionStates.get(sessionId);
+            state.actionsSinceLastPatch = newActions;
+            // Queue a forced patch (bypasses Haiku quick-check)
+            this.enqueueAction({
+                sessionId,
+                actionCount: newActions.length,
+                messageCount: messages.length,
+                newActions,
+                timestamp: Date.now(),
+                forcePatch: true,
+                traceId
+            });
+        }
+        catch (error) {
+            this.logger.warn('Failed to trigger reconciliation patch', {
+                sessionId: sessionId.slice(0, 8),
+                error
+            });
+        }
+    }
+    // ==========================================================================
+    // 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, use cached message_count as baseline
+            // to avoid re-processing old messages while still processing new ones.
+            if (previousCount === 0) {
+                const state = this.sessionStates.get(sessionId);
+                if (!state) {
+                    const cachedInsights = await this.sessionInfoService.getInsights(sessionId);
+                    if (cachedInsights && cachedInsights.computed_at) {
+                        // Use cached message count as baseline, not current count
+                        // This allows processing of new messages that arrived after the cache
+                        const cachedMsgCount = cachedInsights.message_count || 0;
+                        previousCount = cachedMsgCount;
+                        this.lastKnownMessageCounts.set(sessionId, cachedMsgCount);
+                        this.logger.info('Cold start: resuming from cached message count', {
+                            sessionId: sessionId.slice(0, 8),
+                            cachedMessageCount: cachedMsgCount,
+                            currentMessageCount: currentCount,
+                            newMessages: currentCount - cachedMsgCount,
+                            computed_at: cachedInsights.computed_at
+                        });
+                        // Don't return - continue to process any new messages
+                    }
+                }
+            }
+            // 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);
+            let shouldForceRegenDueToStaleCache = false;
+            if (!state) {
+                const cachedInsights = await this.sessionInfoService.getInsights(sessionId);
+                const hasExistingInsights = cachedInsights && cachedInsights.computed_at;
+                // Check for stale/incomplete cache that needs regeneration
+                if (hasExistingInsights) {
+                    const hasMissing = hasMissingCriticalFields(cachedInsights);
+                    // If critical fields are missing, regenerate regardless of message count
+                    // This catches sessions that were never properly generated
+                    if (hasMissing) {
+                        this.logger.info('Incomplete cache detected - triggering regeneration', {
+                            sessionId: sessionId.slice(0, 8),
+                            cachedMsgCount: cachedInsights.message_count,
+                            currentMsgCount: currentCount,
+                            missingCriticalFields: true
+                        });
+                        shouldForceRegenDueToStaleCache = true;
+                    }
+                    // Also check for very early caching (<=5 messages) with significant new activity
+                    else if (cachedInsights.message_count && cachedInsights.message_count <= 5) {
+                        const messageCountDisparity = currentCount - cachedInsights.message_count;
+                        if (messageCountDisparity >= 20) {
+                            this.logger.info('Early cache with significant new activity - triggering regeneration', {
+                                sessionId: sessionId.slice(0, 8),
+                                cachedMsgCount: cachedInsights.message_count,
+                                currentMsgCount: currentCount,
+                                disparity: messageCountDisparity
+                            });
+                            shouldForceRegenDueToStaleCache = true;
+                        }
+                    }
+                }
+                state = {
+                    actionCount: 0,
+                    lastActionAt: 0,
+                    lastCheckAt: Date.now(),
+                    insightsGeneratedAt: hasExistingInsights ? Date.now() : undefined,
+                    actionsSinceLastPatch: []
+                };
+                this.sessionStates.set(sessionId, state);
+                if (hasExistingInsights && !shouldForceRegenDueToStaleCache) {
+                    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();
+            // Accumulate actions for the next patch - ensures we have full context
+            // (user message, Claude response, tool uses) not just the latest action
+            state.actionsSinceLastPatch = state.actionsSinceLastPatch || [];
+            state.actionsSinceLastPatch.push(...newActions);
+            // Cap at 50 to prevent memory bloat in very long sessions
+            if (state.actionsSinceLastPatch.length > 50) {
+                state.actionsSinceLastPatch = state.actionsSinceLastPatch.slice(-50);
+            }
+            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 || shouldForceRegenDueToStaleCache) {
+                if (this.pendingGenerations.has(sessionId)) {
+                    this.logger.debug('Skipping generation - already in progress', {
+                        sessionId: sessionId.slice(0, 8)
+                    });
+                    return;
+                }
+                const reason = shouldForceRegenDueToStaleCache ? 'stale_cache' : 'initial';
+                this.logger.info('Triggering insights generation', {
+                    sessionId: sessionId.slice(0, 8),
+                    actionCount: state.actionCount,
+                    reason
+                });
+                this.enqueueGenerate({ sessionId, reason, actionCount: state.actionCount });
+                return;
+            }
+            // 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, currentCount);
+            }
+        }
+        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, messageCount) {
+        const hasUserMessage = newActions.some(a => a.type === 'user_message');
+        const hasToolUse = newActions.some(a => a.type === 'tool_use');
+        const lastAction = newActions[newActions.length - 1];
+        const endsWithText = lastAction?.type === 'text';
+        // User message: immediate patch to update current state
+        // This gives instant feedback when user starts a new interaction
+        if (hasUserMessage) {
+            if (state.completionCheckTimer) {
+                clearTimeout(state.completionCheckTimer);
+                state.completionCheckTimer = undefined;
+            }
+            if (state.quickCheckDebounceTimer) {
+                clearTimeout(state.quickCheckDebounceTimer);
+                state.quickCheckDebounceTimer = undefined;
+            }
+            const traceId = generateTraceId(sessionId);
+            this.logger.debug('User message - immediate patch', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+            });
+            // Extract the user message text for currentWork summarization
+            const userMessageAction = newActions.find(a => a.type === 'user_message');
+            const userMessageText = userMessageAction?.text || '';
+            // Trigger currentWork summarization (fire and forget - don't block patching)
+            if (userMessageText) {
+                this.triggerCurrentWorkSummarization(sessionId, userMessageText, traceId).catch(err => {
+                    this.logger.debug('CurrentWork summarization failed', {
+                        traceId,
+                        sessionId: sessionId.slice(0, 8),
+                        error: err instanceof Error ? err.message : String(err)
+                    });
+                });
+            }
+            // Log trigger event
+            this.eventLog.trigger({
+                traceId,
+                sessionId,
+                source: 'user_message',
+                actionCount: state.actionCount,
+                messageCount,
+                newActions: newActions.map(a => a.type + (a.name ? `:${a.name}` : '')),
+            });
+            this.enqueueAction({
+                sessionId,
+                actionCount: state.actionCount,
+                messageCount,
+                newActions,
+                timestamp: Date.now(),
+                forcePatch: true,
+                traceId
+            });
+            return;
+        }
+        // Batch ends with text (no pending tool use): likely completion
+        // Set up delayed check - if no more activity, patch after 5s
+        if (endsWithText && !hasToolUse) {
+            if (state.completionCheckTimer) {
+                clearTimeout(state.completionCheckTimer);
+            }
+            state.lastResponseTimestamp = Date.now();
+            const capturedMessageCount = messageCount;
+            state.completionCheckTimer = setTimeout(() => {
+                const traceId = generateTraceId(sessionId);
+                this.logger.debug('Completion detected - forcing patch', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                });
+                // Log completion trigger
+                this.eventLog.trigger({
+                    traceId,
+                    sessionId,
+                    source: 'completion',
+                    actionCount: state.actionCount,
+                    messageCount: capturedMessageCount,
+                    newActions: newActions.map(a => a.type + (a.name ? `:${a.name}` : '')),
+                });
+                this.enqueueAction({
+                    sessionId,
+                    actionCount: state.actionCount,
+                    messageCount: capturedMessageCount,
+                    newActions,
+                    timestamp: Date.now(),
+                    forcePatch: true,
+                    traceId
+                });
+                state.completionCheckTimer = undefined;
+            }, COMPLETION_CHECK_DELAY_MS);
+            return;
+        }
+        // Tool use in progress - debounced check
+        // Clear any pending completion timer since we're still active
+        if (state.completionCheckTimer) {
+            clearTimeout(state.completionCheckTimer);
+            state.completionCheckTimer = undefined;
+        }
+        const timeSinceLastCheck = Date.now() - state.lastCheckAt;
+        const isStale = timeSinceLastCheck > QUICK_CHECK_STALENESS_THRESHOLD_MS;
+        if (isStale) {
+            // Force check if stale
+            if (state.quickCheckDebounceTimer) {
+                clearTimeout(state.quickCheckDebounceTimer);
+                state.quickCheckDebounceTimer = undefined;
+            }
+            const traceId = generateTraceId(sessionId);
+            // Log tool_use trigger (stale)
+            this.eventLog.trigger({
+                traceId,
+                sessionId,
+                source: 'tool_use',
+                actionCount: state.actionCount,
+                messageCount,
+                newActions: newActions.map(a => a.type + (a.name ? `:${a.name}` : '')),
+            });
+            this.enqueueAction({
+                sessionId,
+                actionCount: state.actionCount,
+                messageCount,
+                newActions,
+                timestamp: Date.now(),
+                forcePatch: false,
+                traceId
+            });
+        }
+        else {
+            // Debounce: wait for quiet period before checking
+            if (state.quickCheckDebounceTimer) {
+                clearTimeout(state.quickCheckDebounceTimer);
+            }
+            const capturedActions = [...newActions];
+            const capturedActionCount = state.actionCount;
+            const capturedMessageCount = messageCount;
+            state.quickCheckDebounceTimer = setTimeout(() => {
+                const traceId = generateTraceId(sessionId);
+                // Log debounced tool_use trigger
+                this.eventLog.trigger({
+                    traceId,
+                    sessionId,
+                    source: 'tool_use',
+                    actionCount: capturedActionCount,
+                    messageCount: capturedMessageCount,
+                    newActions: capturedActions.map(a => a.type + (a.name ? `:${a.name}` : '')),
+                });
+                this.enqueueAction({
+                    sessionId,
+                    actionCount: capturedActionCount,
+                    messageCount: capturedMessageCount,
+                    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;
+            // Extract timestamp from message for temporal context
+            const msgTimestamp = msg.timestamp;
+            // Handle user messages - content can be string or array
+            if (msg.type === 'user') {
+                // Handle string content (common for user input)
+                if (typeof content === 'string') {
+                    const trimmed = content.trim();
+                    // Skip meta/system messages
+                    if (trimmed.length > 0 && !trimmed.startsWith('<') && !trimmed.includes('DO NOT respond to these messages')) {
+                        actions.push({ type: 'user_message', text: trimmed, timestamp: msgTimestamp });
+                    }
+                    continue;
+                }
+                // Handle array content (tool results, etc.)
+                if (!Array.isArray(content))
+                    continue;
+                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, timestamp: msgTimestamp });
+                        }
+                    }
+                }
+                continue;
+            }
+            // For assistant messages, content must be an array
+            if (!Array.isArray(content))
+                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, timestamp: msgTimestamp });
+                        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, timestamp: msgTimestamp });
+                        }
+                    }
+                }
+            }
+        }
+        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.insightsComputer.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.insightsComputer.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.insightsComputer.cacheInsights(sessionId, finalInsights);
+            this.markInsightsGenerated(sessionId);
+            // Log generate completion
+            this.eventLog.generate({
+                traceId: generateTraceId(sessionId),
+                sessionId,
+                afterState: {
+                    mission: finalInsights.context?.mission?.slice(0, 100),
+                    milestones: finalInsights.milestones?.slice(0, 3).map(m => m.label?.slice(0, 50)),
+                    notableCount: finalInsights.notable?.length,
+                },
+                durationMs: duration,
+            });
+            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.
+     * - Opus owns (use fresh): context, theme, tags
+     * - Haiku owns (keep cached): purpose (set via fast patch)
+     */
+    applyOwnershipModel(cached, fresh) {
+        return {
+            ...fresh,
+            // Opus owns these (use fresh)
+            context: fresh.context,
+            theme: fresh.theme,
+            tags: fresh.tags,
+            // Haiku owns purpose (set via fast patch, not full compute)
+            purpose: cached.purpose,
+            // Preserve timestamps
+            computedAt: fresh.computedAt,
+            patchedAt: cached.patchedAt,
+        };
+    }
+    // ==========================================================================
+    // LLM Operations - Patching
+    // ==========================================================================
+    async executeAction(event) {
+        const { sessionId, newActions, actionCount: _actionCount, messageCount, 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,
+                milestones: cached.milestones?.map(m => `${m.label}:${m.status}`),
+            };
+            // Use accumulated actions since last patch for richer context
+            // This ensures we have user message + Claude response + tool uses, not just the latest action
+            const state = this.sessionStates.get(sessionId);
+            const actionsForPatch = state?.actionsSinceLastPatch?.length ? state.actionsSinceLastPatch : newActions;
+            this.logger.debug('Building recentActivity for patch', {
+                sessionId: sessionId.slice(0, 8),
+                accumulatedActions: state?.actionsSinceLastPatch?.length || 0,
+                newActions: newActions.length,
+                usingAccumulated: actionsForPatch === state?.actionsSinceLastPatch
+            });
+            const recentActivity = actionsForPatch.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, timestamp: a.timestamp };
+                }
+                return { type: a.type, content: a.text || '', timestamp: a.timestamp };
+            });
+            const actionContent = actionsForPatch.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, messageCount, 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, sessionId);
+            const quickCheckDurationMs = Date.now() - quickCheckStartTime;
+            this.markQuickCheckPerformed(sessionId);
+            if (quickCheckResult.needsPatch) {
+                // Log quick check result
+                this.eventLog.quickCheck({
+                    traceId,
+                    sessionId,
+                    result: 'patch_needed',
+                    reason: quickCheckResult.reason,
+                    durationMs: quickCheckDurationMs,
+                });
+                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, messageCount, beforeState, actionContent, trigger);
+            }
+            else {
+                this.logger.debug('Quick check: no patch needed', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                    reason: quickCheckResult.reason,
+                });
+                // Log quick check skip
+                this.eventLog.quickCheck({
+                    traceId,
+                    sessionId,
+                    result: 'no_patch',
+                    reason: quickCheckResult.reason,
+                    durationMs: quickCheckDurationMs,
+                });
+                this.eventLog.skip({
+                    traceId,
+                    sessionId,
+                    reason: 'haiku_said_no',
+                    trigger: trigger,
+                });
+                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, sessionId) {
+        const mission = cached.context?.mission || 'Unknown';
+        const milestones = (cached.milestones || []);
+        return await anthropicService.quickCheckInsightsStale({ mission, milestones }, recentActions, sessionId);
+    }
+    async doPatch(sessionId, cached, recentActivity, traceId, messageCount, beforeState, actionContent, trigger) {
+        const patchStartTime = Date.now();
+        // === FRESH FETCH: Re-sample messages at patch execution time ===
+        // This fixes the race condition where assistant responses arrive after
+        // the patch was queued but before it executes. By fetching fresh here,
+        // we ensure we always have the most current conversation state.
+        let freshRecentActivity = recentActivity;
+        let freshMessageCount = messageCount;
+        let freshActionContent = actionContent;
+        try {
+            const { messages } = await this.historyReader.fetchConversationDirect(sessionId);
+            freshMessageCount = messages.length;
+            // Get messages since last patch (or last 20 if no patched_at)
+            const lastPatchTime = cached.patched_at ? new Date(cached.patched_at).getTime() : 0;
+            const newMessages = lastPatchTime > 0
+                ? messages.filter(m => new Date(m.timestamp).getTime() > lastPatchTime)
+                : messages.slice(-20); // Fallback: last 20 messages
+            if (newMessages.length > 0) {
+                const freshActions = this.extractActions(newMessages);
+                if (freshActions.length > 0) {
+                    // Convert to recentActivity format
+                    freshRecentActivity = freshActions.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, timestamp: a.timestamp };
+                        }
+                        return { type: a.type, content: a.text || '', timestamp: a.timestamp };
+                    });
+                    // Update actionContent for audit logging
+                    freshActionContent = freshActions.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)}`;
+                    });
+                    this.logger.info('[PATCH TRACE] Fresh fetch found new activity', {
+                        traceId,
+                        sessionId: sessionId.slice(0, 8),
+                        originalMessageCount: messageCount,
+                        freshMessageCount,
+                        newMessagesSinceLastPatch: newMessages.length,
+                        freshActionCount: freshActions.length,
+                    });
+                }
+            }
+        }
+        catch (fetchError) {
+            // If fresh fetch fails, fall back to the original data
+            this.logger.warn('[PATCH TRACE] Fresh fetch failed, using original data', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                error: fetchError instanceof Error ? fetchError.message : String(fetchError),
+            });
+        }
+        // Use fresh data from this point forward
+        recentActivity = freshRecentActivity;
+        messageCount = freshMessageCount;
+        actionContent = freshActionContent;
+        // Use progressItems (V9 with timestamps) for better staleness detection
+        const progressItems = (cached.progress_items || []);
+        // Convert to milestone format but include updatedAt for temporal context
+        const milestonesWithTime = progressItems.map(p => ({
+            label: p.label,
+            status: p.status,
+            updatedAt: p.updatedAt
+        }));
+        const currentInsights = {
+            mission: cached.context?.mission || cached.description || 'Unknown',
+            description: cached.description || '',
+            theme: cached.theme || 'unknown',
+            milestones: milestonesWithTime,
+            notable: (cached.notable || []).map(n => ({ text: n.description || n.text || '', icon: n.icon })),
+            recentActions: (cached.recent_actions || []),
+            previousPropositions: (cached.propositions || []),
+            purpose: cached.purpose || undefined,
+            tags: cached.tags || undefined
+        };
+        const result = await anthropicService.generateInsightsPatch(currentInsights, recentActivity, true, sessionId);
+        const llmDurationMs = Date.now() - patchStartTime;
+        this.logger.info('[PATCH TRACE] LLM returned', { traceId, sessionId: sessionId.slice(0, 8), reason: result.reason?.slice(0, 100) });
+        const patchKeys = Object.keys(result.patches);
+        if (patchKeys.length === 0) {
+            this.logger.warn('[PATCH TRACE] No patches returned - early exit (no SSE will be emitted)', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                reason: result.reason,
+                propositionsCount: result.propositions?.length || 0
+            });
+            if (trigger) {
+                SessionInfoService.getInstance().auditEventInsight({
+                    traceId,
+                    sessionId,
+                    eventType: 'patch',
+                    trigger,
+                    actionContent,
+                    beforeState,
+                    llmResponse: `no_patches: ${result.reason}`,
+                    patchedFields: [],
+                    durationMs: llmDurationMs
+                });
+            }
+            return;
+        }
+        this.logger.info('[PATCH TRACE] About to apply patches', { traceId, sessionId: sessionId.slice(0, 8), patchKeys });
+        await this.applyPatches(sessionId, cached, result.patches, result.propositions, traceId, messageCount);
+        this.logger.info('[PATCH TRACE] Patches applied successfully', { traceId, sessionId: sessionId.slice(0, 8) });
+        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,
+            milestones: updatedCached.milestones?.map(m => `${m.label}:${m.status}`),
+        } : 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));
+        this.logger.info('[SSE TRACE] About to emit insights update', {
+            traceId,
+            sessionId: sessionId.slice(0, 8),
+            type: 'patched'
+        });
+        await getSessionActivityWatcher().emitInsightsUpdate(sessionId, 'patched', traceId);
+        this.logger.info('[SSE TRACE] Emitted insights update', {
+            traceId,
+            sessionId: sessionId.slice(0, 8),
+            type: 'patched'
+        });
+    }
+    async applyPatches(sessionId, cached, patches, propositions, traceId, messageCount) {
+        const updated = { ...cached };
+        // Accumulate propositions with timestamps (don't overwrite)
+        const now = new Date().toISOString();
+        const existingPropositions = updated.propositions || [];
+        const newPropositions = propositions.map(text => ({ text, addedAt: now }));
+        updated.propositions = [...existingPropositions, ...newPropositions];
+        // CRITICAL: Update message_count to prevent staleness drift
+        updated.message_count = messageCount;
+        updated.last_patch_trace_id = traceId;
+        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.purpose) {
+            updated.purpose = patches.purpose;
+        }
+        if (patches.tags) {
+            // Merge with existing tags, preserving domain which isn't re-evaluated
+            updated.tags = {
+                workType: patches.tags.workType || updated.tags?.workType || ['exploring'],
+                collaboration: (patches.tags.collaboration || updated.tags?.collaboration || 'iterative'),
+                complexity: (patches.tags.complexity || updated.tags?.complexity || 'routine'),
+                domain: updated.tags?.domain || [] // Preserve domain - not re-evaluated in fast patch
+            };
+        }
+        updated.patched_at = new Date().toISOString();
+        await SessionInfoService.getInstance().setInsights(updated);
+        // Try to generate identity image if we now have mission context (fire and forget)
+        // This handles the case where initial insights were generated before mission was extracted
+        if (updated.context?.mission) {
+            const insightsForImage = {
+                sessionId,
+                context: updated.context,
+                theme: updated.theme,
+                tags: updated.tags,
+            };
+            this.insightsComputer.maybeGenerateIdentityImage(sessionId, insightsForImage).catch(err => {
+                this.logger.debug('Failed to generate identity image after patch', {
+                    sessionId,
+                    error: err instanceof Error ? err.message : String(err)
+                });
+            });
+        }
+        // Log patch completion
+        const patchedFields = Object.keys(patches).filter(k => patches[k] !== undefined);
+        this.eventLog.patch({
+            traceId,
+            sessionId,
+            beforeState: {
+                mission: cached.context?.mission?.slice(0, 100),
+            },
+            afterState: {
+                mission: updated.context?.mission?.slice(0, 100),
+            },
+            patchedFields,
+            durationMs: 0, // Duration tracked at higher level
+        });
+    }
+    // ==========================================================================
+    // 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(),
+                actionsSinceLastPatch: []
+            };
+            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();
+            // Clear the accumulated actions buffer after successful patch
+            state.actionsSinceLastPatch = [];
+        }
+    }
+    markQuickCheckPerformed(sessionId) {
+        const state = this.sessionStates.get(sessionId);
+        if (state) {
+            state.lastCheckAt = Date.now();
+        }
+    }
+    startRegenTimer(sessionId, state) {
+        if (state.regenTimerId) {
+            clearTimeout(state.regenTimerId);
+        }
+        // Skip if scheduled regeneration is disabled
+        if (FULL_REGEN_INTERVAL_MS <= 0) {
+            return;
+        }
+        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);
+    }
+    /**
+     * Handle session ended - immediately fire any pending timers.
+     * This ensures insights update right when the session ends, not 5s later.
+     *
+     * IMPORTANT: We must fire the file debounce timer FIRST to ensure
+     * actionsSinceLastPatch contains the final response before we patch.
+     */
+    async handleSessionEnded(sessionId) {
+        const state = this.sessionStates.get(sessionId);
+        if (!state) {
+            this.logger.debug('Session ended but no state tracked', {
+                sessionId: sessionId.slice(0, 8)
+            });
+            return;
+        }
+        // CRITICAL: Fire pending file debounce timer FIRST
+        // The file watcher has a 150ms debounce. If the process exits within that window,
+        // the final response won't be in actionsSinceLastPatch yet. We need to process
+        // the file update before expediting the completion patch.
+        const debounceTimer = this.debounceTimers.get(sessionId);
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            this.debounceTimers.delete(sessionId);
+            const actionCountBefore = state.actionsSinceLastPatch?.length || 0;
+            this.logger.warn('Session ended with pending file debounce - processing now to capture final response', {
+                sessionId: sessionId.slice(0, 8),
+                actionsSinceLastPatchBefore: actionCountBefore
+            });
+            // Process the session update synchronously to capture final actions
+            await this.processSessionUpdate(sessionId);
+            const actionCountAfter = state.actionsSinceLastPatch?.length || 0;
+            this.logger.warn('File debounce processed - actions captured', {
+                sessionId: sessionId.slice(0, 8),
+                actionsBefore: actionCountBefore,
+                actionsAfter: actionCountAfter,
+                newActionsCaptured: actionCountAfter - actionCountBefore
+            });
+        }
+        // If there's a pending completion timer, fire it immediately
+        if (state.completionCheckTimer) {
+            clearTimeout(state.completionCheckTimer);
+            state.completionCheckTimer = undefined;
+            const traceId = generateTraceId(sessionId);
+            this.logger.info('Session ended - expediting completion patch', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+            });
+            // Log the trigger
+            this.eventLog.trigger({
+                traceId,
+                sessionId,
+                source: 'completion',
+                actionCount: state.actionCount,
+                messageCount: this.lastKnownMessageCounts.get(sessionId) || 0,
+                newActions: ['session_ended'],
+            });
+            // Trigger immediate patch
+            this.enqueueAction({
+                sessionId,
+                actionCount: state.actionCount,
+                messageCount: this.lastKnownMessageCounts.get(sessionId) || 0,
+                newActions: [{ type: 'text', text: '[Session ended]' }],
+                timestamp: Date.now(),
+                forcePatch: true,
+                traceId
+            });
+        }
+        // Also fire any pending quick check debounce timer
+        if (state.quickCheckDebounceTimer) {
+            clearTimeout(state.quickCheckDebounceTimer);
+            state.quickCheckDebounceTimer = undefined;
+            // The debounce timer callback captured its own data, so we just
+            // trigger a fresh patch here if there wasn't a completion timer
+            if (!state.completionCheckTimer) {
+                const traceId = generateTraceId(sessionId);
+                this.logger.info('Session ended - expediting debounced check', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                });
+                this.enqueueAction({
+                    sessionId,
+                    actionCount: state.actionCount,
+                    messageCount: this.lastKnownMessageCounts.get(sessionId) || 0,
+                    newActions: [{ type: 'text', text: '[Session ended]' }],
+                    timestamp: Date.now(),
+                    forcePatch: true,
+                    traceId
+                });
+            }
+        }
+    }
+    /**
+     * Trigger currentWork summarization and metadata evaluation when user sends a message.
+     *
+     * This gives the sidebar "Currently:" indicator something to show immediately,
+     * and evaluates theme/purpose/tags based on what the user is asking for.
+     * We provide recent conversation context so even "do it" can be understood.
+     */
+    async triggerCurrentWorkSummarization(sessionId, userMessageText, traceId) {
+        const startTime = Date.now();
+        try {
+            // Fetch recent conversation for context (last 4 exchanges max)
+            const { messages } = await this.historyReader.fetchConversationDirect(sessionId);
+            // Build recent context from conversation (excluding the new user message we just got)
+            // Take last 8 messages (roughly 4 exchanges of user+assistant)
+            const recentMessages = messages.slice(-8);
+            const recentContext = [];
+            for (const msg of recentMessages) {
+                const type = msg.type === 'user' ? 'user' : 'assistant';
+                // Extract text from message.content (Anthropic format)
+                let content = '';
+                if (msg.message && 'content' in msg.message) {
+                    const msgContent = msg.message.content;
+                    if (typeof msgContent === 'string') {
+                        content = msgContent;
+                    }
+                    else if (Array.isArray(msgContent)) {
+                        // Find first text block
+                        const textBlock = msgContent.find((block) => typeof block === 'object' && block !== null && 'type' in block && block.type === 'text');
+                        content = textBlock?.text || '';
+                    }
+                }
+                // Truncate long messages but keep enough to understand context
+                if (content) {
+                    recentContext.push({ type, content: content.slice(0, 800) });
+                }
+            }
+            // Try to get cached insights for mission/purpose/theme/tags
+            let cachedInsights;
+            try {
+                const cached = await this.insightsComputer.getCachedInsightsForSessions([sessionId]);
+                cachedInsights = cached.get(sessionId);
+            }
+            catch {
+                // No cached insights, that's fine
+            }
+            const sessionMission = cachedInsights?.context?.mission;
+            // Run currentWork summarization and metadata evaluation in parallel
+            const [currentWorkResult, metadataResult] = await Promise.all([
+                // 1. Summarize what user is asking for (for "Currently:" display)
+                anthropicService.summarizeCurrentWork(userMessageText, recentContext, sessionMission, sessionId),
+                // 2. Evaluate session metadata (purpose/theme/tags)
+                anthropicService.evaluateSessionMetadata(userMessageText, recentContext, {
+                    mission: sessionMission,
+                    purpose: cachedInsights?.purpose || undefined,
+                    theme: cachedInsights?.theme || undefined,
+                    tags: cachedInsights?.tags || undefined,
+                }, sessionId),
+            ]);
+            const durationMs = Date.now() - startTime;
+            // Emit currentWork via SSE if we got a result
+            if (currentWorkResult) {
+                this.logger.info('CurrentWork summarization complete', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                    durationMs,
+                    summary: currentWorkResult.summary.slice(0, 50),
+                });
+                const watcher = getSessionActivityWatcher();
+                watcher.emitCurrentWork({
+                    sessionId,
+                    summary: currentWorkResult.summary,
+                    userMessage: userMessageText.slice(0, 200),
+                    startedAt: new Date().toISOString(),
+                });
+            }
+            // Persist metadata updates if we got any
+            if (metadataResult) {
+                this.logger.info('Session metadata updated on user message', {
+                    traceId,
+                    sessionId: sessionId.slice(0, 8),
+                    theme: metadataResult.theme,
+                    purpose: metadataResult.purpose?.slice(0, 30),
+                });
+                await this.sessionInfoService.updateSessionMetadata(sessionId, {
+                    purpose: metadataResult.purpose,
+                    theme: metadataResult.theme,
+                    tags: metadataResult.tags,
+                });
+                // Emit SSE so UI updates in real-time
+                const watcher = getSessionActivityWatcher();
+                await watcher.emitInsightsUpdate(sessionId, 'patched', traceId);
+            }
+        }
+        catch (error) {
+            this.logger.debug('CurrentWork/metadata processing error', {
+                traceId,
+                sessionId: sessionId.slice(0, 8),
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}
+// ============================================================================
+// Singleton
+// ============================================================================
+let instance = null;
+export function getInsightsCoordinator() {
+    if (!instance) {
+        instance = new InsightsCoordinator();
+    }
+    return instance;
+}
+/**
+ * Initialize the insights coordinator. Call once at server startup.
+ */
+export function initializeInsightsCoordinator() {
+    const service = getInsightsCoordinator();
+    service.initialize();
+}
+// Legacy aliases for backward compatibility during migration
+/** @deprecated Use getInsightsCoordinator instead */
+export const getInsightsService = getInsightsCoordinator;
+/** @deprecated Use initializeInsightsCoordinator instead */
+export const initializeInsightsService = initializeInsightsCoordinator;
+//# sourceMappingURL=insights-coordinator.js.map