lattice-orchestrator 0.7.0

package/dist/services/insights/anthropic-service.js

@@ -0,0 +1,1062 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { LatticeError, } from '../../types/index.js';
+import { createLogger } from '../../services/infrastructure/logger.js';
+import { ConfigService } from '../infrastructure/config-service.js';
+import { getCostTracker } from '../infrastructure/cost-tracker.js';
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 10000,
+};
+/**
+ * Determines if an error is retryable (transient network/rate limit issues).
+ * Non-retryable: auth errors, credit exhaustion, invalid requests.
+ */
+function isRetryableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const errorName = error instanceof Error ? error.name : '';
+    // Non-retryable errors - don't waste retries on these
+    if (message.includes('credit balance') || message.includes('billing'))
+        return false;
+    if (message.includes('invalid_api_key') || message.includes('authentication'))
+        return false;
+    if (message.includes('invalid_request_error'))
+        return false;
+    // Retryable: rate limits, overloaded, server errors, network issues
+    if (message.includes('rate_limit') || message.includes('overloaded'))
+        return true;
+    if (message.includes('529') || message.includes('503') || message.includes('500'))
+        return true;
+    if (errorName === 'APIConnectionError' || message.includes('ECONNRESET'))
+        return true;
+    if (errorName === 'RateLimitError' || errorName === 'InternalServerError')
+        return true;
+    // Default: retry on unknown errors (might be transient)
+    return true;
+}
+/**
+ * Calculates exponential backoff delay with jitter.
+ */
+function calculateBackoff(attempt, config) {
+    const exponentialDelay = config.baseDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * 0.3 * exponentialDelay; // 0-30% jitter
+    return Math.min(exponentialDelay + jitter, config.maxDelayMs);
+}
+/**
+ * Sleep for a specified duration.
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+// ============================================================================
+// Model Configuration
+// ============================================================================
+// Centralized model IDs - update these when Anthropic releases new versions.
+// These are defaults; can be overridden via config.anthropic.models.*
+const DEFAULT_MODELS = {
+    /** Full insight generation - Sonnet balances quality/cost well for structured extraction */
+    generation: 'claude-sonnet-4-5-20250929',
+    /** Quick staleness checks - needs speed over capability */
+    quickCheck: 'claude-haiku-4-5-20251001',
+    /** Fast patch generation - speed over quality */
+    patch: 'claude-haiku-4-5-20251001',
+    /** Full patch generation (fallback) - for complex patches when fast path fails */
+    fullPatch: 'claude-haiku-4-5-20251001',
+    /** Proposition extraction - factual extraction task */
+    propositions: 'claude-haiku-4-5-20251001',
+};
+export class AnthropicService {
+    logger;
+    client = null;
+    // Model configuration - populated from config or defaults
+    // Uses explicit mutable type rather than `typeof DEFAULT_MODELS` which is readonly due to `as const`
+    models;
+    constructor() {
+        this.logger = createLogger('AnthropicService');
+        this.models = { ...DEFAULT_MODELS };
+    }
+    async initialize() {
+        const config = ConfigService.getInstance().getConfig();
+        const apiKey = config.anthropic?.apiKey || process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            this.logger.warn('Anthropic API key not configured');
+            return;
+        }
+        try {
+            this.client = new Anthropic({ apiKey });
+            // Load model overrides from config
+            const configModels = config.anthropic?.models;
+            if (configModels) {
+                if (configModels.generation)
+                    this.models.generation = configModels.generation;
+                if (configModels.quickCheck)
+                    this.models.quickCheck = configModels.quickCheck;
+                if (configModels.patch)
+                    this.models.patch = configModels.patch;
+                if (configModels.fullPatch)
+                    this.models.fullPatch = configModels.fullPatch;
+                if (configModels.propositions)
+                    this.models.propositions = configModels.propositions;
+            }
+            // Also support legacy config.anthropic.model for generation
+            if (config.anthropic?.model) {
+                this.models.generation = config.anthropic.model;
+            }
+            this.logger.info('Anthropic service initialized', { models: this.models });
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize Anthropic service', { error });
+            throw new LatticeError('ANTHROPIC_INIT_ERROR', 'Failed to initialize Anthropic service', 500);
+        }
+    }
+    /**
+     * Execute a function with exponential backoff retry on transient errors.
+     */
+    async withRetry(operation, fn, config = DEFAULT_RETRY_CONFIG) {
+        let lastError;
+        for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry non-retryable errors
+                if (!isRetryableError(error)) {
+                    throw error;
+                }
+                // Don't retry after max attempts
+                if (attempt >= config.maxRetries) {
+                    this.logger.warn(`${operation}: All ${config.maxRetries} retries exhausted`, {
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                    throw error;
+                }
+                const delayMs = calculateBackoff(attempt, config);
+                this.logger.info(`${operation}: Retry ${attempt + 1}/${config.maxRetries} after ${Math.round(delayMs)}ms`, {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                await sleep(delayMs);
+            }
+        }
+        throw lastError;
+    }
+    async checkHealth() {
+        if (!this.client) {
+            return {
+                status: 'unhealthy',
+                message: 'Anthropic API key not configured',
+                apiKeyValid: false
+            };
+        }
+        try {
+            const response = await this.withRetry('checkHealth', () => this.client.messages.create({
+                model: this.models.generation,
+                max_tokens: 50,
+                messages: [{ role: 'user', content: 'Say "ok" and nothing else.' }]
+            }));
+            const text = response.content[0]?.type === 'text' ? response.content[0].text : null;
+            if (text) {
+                return {
+                    status: 'healthy',
+                    message: 'Anthropic API is accessible',
+                    apiKeyValid: true
+                };
+            }
+            return {
+                status: 'unhealthy',
+                message: 'Unexpected response from Anthropic API',
+                apiKeyValid: true
+            };
+        }
+        catch (error) {
+            this.logger.error('Health check failed', { error });
+            return {
+                status: 'unhealthy',
+                message: error instanceof Error ? error.message : 'Unknown error',
+                apiKeyValid: false
+            };
+        }
+    }
+    /**
+     * Log cost for an LLM API call.
+     * Call this after each API call to track costs.
+     */
+    logCost(response, operation, model, durationMs, sessionId) {
+        try {
+            const costTracker = getCostTracker();
+            costTracker.log({
+                sessionId: sessionId || 'unknown',
+                operation,
+                model,
+                inputTokens: response.usage?.input_tokens || 0,
+                outputTokens: response.usage?.output_tokens || 0,
+                durationMs,
+            });
+        }
+        catch (error) {
+            // Don't let cost logging failures break the main flow
+            this.logger.debug('Failed to log cost', { error, operation });
+        }
+    }
+    /**
+     * Extract rich, structured session insights using Opus 4.5
+     */
+    async extractSessionInsights(conversationText, sessionId) {
+        if (!this.client) {
+            throw new LatticeError('ANTHROPIC_API_KEY_MISSING', 'Anthropic API key not configured', 400);
+        }
+        const systemPrompt = `You are analyzing a coding session transcript to extract structured information for a dashboard display.
+
+The goal: Someone glancing at this dashboard should immediately understand what this session is about.
+
+Extract the following:
+
+1. CONTEXT - Identity of the session:
+   - project: The codebase/repo name
+   - area: The specific component/module/domain if applicable (null if general)
+   - mission: The overarching goal in one sentence - be specific
+   - scope: "minor" (quick fix), "feature" (meaningful addition), "major" (significant change)
+
+2. THEME - A single word capturing the session's current mode/vibe:
+   Examples: "debugging", "building", "exploring", "firefighting", "refactoring", "designing", "investigating", "polishing"
+
+3. TAGS - Quick categorization for filtering/display:
+   - workType: Array of what's happening - pick ONLY from: "implementing", "debugging", "refactoring", "exploring", "designing", "investigating"
+     (implementing=writing new code, debugging=fixing bugs, refactoring=restructuring, exploring=reading/understanding, designing=planning architecture, investigating=diagnosing/researching)
+   - domain: Array of technical areas - e.g., "UI", "backend", "database", "API", "infra", "auth", "testing"
+   - collaboration: How the session is proceeding - "autonomous" (Claude working independently), "iterative" (back-and-forth), "guided" (user directing each step)
+   - complexity: Session difficulty - "routine" (straightforward), "tricky" (requires care), "gnarly" (complex/hairy - reserved for multi-system debugging or architecture-spanning changes)
+
+CRITICAL OUTPUT INSTRUCTIONS:
+- Respond with ONLY valid JSON
+- Do NOT include explanatory text before or after the JSON
+- Do NOT include markdown code blocks or formatting
+- Start your response with { and end with }
+- No prose, no commentary, ONLY the JSON object
+
+JSON Structure:
+{
+  "context": { "project": "string", "area": "string|null", "mission": "string", "scope": "minor|feature|major" },
+  "theme": "string",
+  "tags": { "workType": ["string", ...], "domain": ["string", ...], "collaboration": "autonomous|iterative|guided", "complexity": "routine|tricky|gnarly" }
+}`;
+        let responseText = null;
+        const startTime = Date.now();
+        try {
+            const response = await this.withRetry('extractSessionInsights', () => this.client.messages.create({
+                model: this.models.generation,
+                max_tokens: 500, // Reduced - only extracting context, theme, tags now
+                system: systemPrompt,
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Analyze this coding session and extract structured insights:\n\n${conversationText}`
+                    },
+                    {
+                        role: 'assistant',
+                        content: '{' // Prefill to force JSON output
+                    }
+                ]
+            }));
+            const durationMs = Date.now() - startTime;
+            // Log cost for GENERATE operation
+            this.logCost(response, 'GENERATE', this.models.generation, durationMs, sessionId);
+            responseText = response.content[0]?.type === 'text' ? response.content[0].text : null;
+            if (!responseText) {
+                throw new LatticeError('ANTHROPIC_INSIGHTS_ERROR', 'No response text returned', 500);
+            }
+            // Prepend the '{' we used for prefill
+            responseText = '{' + responseText;
+            // Extract JSON from response with multiple fallback strategies
+            let jsonText = responseText.trim();
+            // Strategy 1: Try to extract from markdown code blocks
+            const codeBlockMatch = responseText.match(/```(?:json)?\s*([\s\S]*?)```/);
+            if (codeBlockMatch) {
+                jsonText = codeBlockMatch[1].trim();
+            }
+            else {
+                // Strategy 2: Look for content between first { and last }
+                const firstBrace = jsonText.indexOf('{');
+                const lastBrace = jsonText.lastIndexOf('}');
+                if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+                    jsonText = jsonText.substring(firstBrace, lastBrace + 1);
+                }
+            }
+            // Log the extracted JSON for debugging
+            this.logger.debug('Extracted JSON from LLM response', {
+                responsePreview: responseText.slice(0, 100),
+                extractedPreview: jsonText.slice(0, 100),
+                usedCodeBlock: !!codeBlockMatch
+            });
+            const result = JSON.parse(jsonText);
+            // Validate structure - be lenient, provide defaults
+            if (!result.context) {
+                throw new LatticeError('ANTHROPIC_INSIGHTS_ERROR', 'Invalid response structure', 500);
+            }
+            // Theme and tags come from the LLM prompt
+            result.theme = result.theme || 'working';
+            result.tags = result.tags || null;
+            // These fields are deprecated and no longer requested in the LLM prompt.
+            // They're set to empty defaults for type compatibility.
+            // V8 fields (milestones, notable, recentActions) were removed from prompt
+            // but types still require them for backward compat with cached data.
+            result.milestones = [];
+            result.notable = [];
+            result.recentActions = [];
+            result.currentState = null;
+            result.panels = [];
+            this.logger.info('Session insights extracted (Opus)', {
+                model: this.models.generation,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                project: result.context.project,
+                theme: result.theme
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof LatticeError) {
+                throw error;
+            }
+            // Check for credit/billing errors and make them LOUD
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('credit balance') || errorMessage.includes('billing')) {
+                this.logger.error('🚨 ANTHROPIC API CREDITS EXHAUSTED 🚨', {
+                    errorMessage,
+                    action: 'ADD CREDITS AT https://console.anthropic.com/settings/billing'
+                });
+                throw new LatticeError('ANTHROPIC_NO_CREDITS', '🚨 Anthropic API credits exhausted. Add credits at https://console.anthropic.com/settings/billing', 402);
+            }
+            // Log error with proper serialization AND the response that failed to parse
+            this.logger.error('Session insights extraction failed', {
+                errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                errorType: error?.constructor?.name,
+                // Include the actual response for debugging
+                responsePreview: responseText?.slice(0, 500) || 'no response'
+            });
+            throw new LatticeError('ANTHROPIC_INSIGHTS_ERROR', 'Failed to extract session insights', 500);
+        }
+    }
+    /**
+     * Generate a session name (simpler extraction for naming)
+     */
+    async generateSessionName(conversationText) {
+        if (!this.client) {
+            throw new LatticeError('ANTHROPIC_API_KEY_MISSING', 'Anthropic API key not configured', 400);
+        }
+        try {
+            const response = await this.withRetry('generateSessionName', () => this.client.messages.create({
+                model: this.models.generation,
+                max_tokens: 100,
+                messages: [{
+                        role: 'user',
+                        content: `Generate a brief, descriptive name (3-6 words) for this coding session. Include the project/area context. Focus on the main task or feature being worked on. Do not include generic words like "session", "conversation", or "chat".
+
+Examples of good names:
+- "CUI: Session insights UI redesign"
+- "Auth: Fix redirect loop bug"
+- "API: Add rate limiting middleware"
+
+Respond with ONLY the name, nothing else.
+
+Conversation:
+${conversationText}`
+                    }]
+            }));
+            const name = response.content[0]?.type === 'text' ? response.content[0].text.trim() : null;
+            if (!name) {
+                throw new LatticeError('ANTHROPIC_NAME_ERROR', 'No name returned', 500);
+            }
+            return { name };
+        }
+        catch (error) {
+            if (error instanceof LatticeError) {
+                throw error;
+            }
+            this.logger.error('Session name generation failed', { error });
+            throw new LatticeError('ANTHROPIC_NAME_ERROR', 'Failed to generate session name', 500);
+        }
+    }
+    isConfigured() {
+        return this.client !== null;
+    }
+    /**
+     * Quick check using Haiku to determine if insights need patching.
+     *
+     * This is a fast, cheap call that just answers "has anything meaningful changed?"
+     * based on recent actions. If yes, we'll follow up with Sonnet for actual patching.
+     */
+    async quickCheckInsightsStale(currentInsights, recentActions, sessionId) {
+        if (!this.client) {
+            return { needsPatch: false, reason: 'Anthropic not configured' };
+        }
+        const startTime = Date.now();
+        try {
+            const milestonesStr = currentInsights.milestones
+                .map(m => `[${m.status}] ${m.label}`)
+                .join(', ');
+            const actionsStr = recentActions.join('\n');
+            const prompt = `Current session insights (a living summary of the conversation):
+- Mission: "${currentInsights.mission}"
+- Milestones: ${milestonesStr || '(none)'}
+
+Recent activity:
+${actionsStr}
+
+Should these insights be updated to reflect the recent activity?
+
+Say YES (needsPatch: true) if ANY of these apply:
+- Progress was made on any task or milestone
+- Focus shifted to a new area or topic
+- Something notable happened worth capturing
+- The summary feels stale compared to what just happened
+
+Say NO only if the recent actions are trivial or already reflected in current insights.
+
+Err on the side of updating - the insights should feel LIVE and current.
+
+Respond with JSON only:
+{"needsPatch": true/false, "reason": "brief explanation"}`;
+            const response = await this.withRetry('quickCheckInsightsStale', () => this.client.messages.create({
+                model: this.models.quickCheck,
+                max_tokens: 100,
+                messages: [{ role: 'user', content: prompt }]
+            }));
+            const duration = Date.now() - startTime;
+            const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            // Log cost for QUICK_CHECK operation
+            this.logCost(response, 'QUICK_CHECK', this.models.quickCheck, duration, sessionId);
+            // Log for observability
+            this.logger.info('Quick check (Haiku) completed', {
+                durationMs: duration,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                recentActionsCount: recentActions.length,
+                responsePreview: text.slice(0, 100)
+            });
+            try {
+                const jsonMatch = text.match(/\{[\s\S]*\}/);
+                const result = JSON.parse(jsonMatch?.[0] || text);
+                return {
+                    needsPatch: result.needsPatch === true,
+                    reason: result.reason || 'No reason provided'
+                };
+            }
+            catch {
+                this.logger.debug('Failed to parse quick check response', { text });
+                return { needsPatch: false, reason: 'Parse error - keeping cached' };
+            }
+        }
+        catch (error) {
+            // Check for credit/billing errors and make them LOUD
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('credit balance') || errorMessage.includes('billing')) {
+                this.logger.error('🚨 ANTHROPIC API CREDITS EXHAUSTED 🚨', {
+                    errorMessage,
+                    action: 'ADD CREDITS AT https://console.anthropic.com/settings/billing',
+                    context: 'Quick check failed due to billing issue'
+                });
+            }
+            else {
+                this.logger.error('Quick check failed', { error });
+            }
+            return { needsPatch: false, reason: 'Check error - keeping cached' };
+        }
+    }
+    /**
+     * Decompose recent activity into exhaustive propositional facts.
+     * Separates "what happened" (facts) from "what does this mean" (interpretation).
+     * Returns structured bullet points of all tool uses, user messages, and Claude messages.
+     */
+    async decomposeActivityIntoPropositions(previousState, recentActivity, sessionId) {
+        if (!this.client) {
+            return [];
+        }
+        const previousStateStr = previousState
+            ? `${previousState.icon} [${previousState.color}] ${previousState.content}`
+            : '(no previous state)';
+        const activityStr = recentActivity
+            .map(a => {
+            // Format timestamp as HH:MM:SS for readability
+            const timeStr = a.timestamp
+                ? new Date(a.timestamp).toLocaleTimeString('en-US', { hour12: false })
+                : '';
+            const prefix = timeStr ? `[${timeStr}] ` : '';
+            return `${prefix}[${a.type}] ${a.content}`;
+        })
+            .join('\n\n');
+        const prompt = `You are analyzing a transcript of a coding session between a user and Claude (an AI assistant).
+
+**Previous Current State:**
+${previousStateStr}
+
+**Recent Activity:**
+${activityStr}
+
+**Your Task:**
+Create an exhaustive list of propositional facts about what happened in this activity.
+Be thorough and explicit - list EVERYTHING that was done and said.
+
+Format as bullet points:
+- Tool uses: "Claude used [tool] to [action]"
+- Claude statements: "Claude said/stated/explained [fact]"
+- User messages: "User asked/requested/said [fact]"
+
+Be exhaustive - every action, every statement, every request should become a bullet point.
+Keep each bullet point factual and specific, not interpretive.
+
+Examples:
+✓ "Claude used Grep to search for 'validateUser' in the codebase"
+✓ "Claude stated that the bug was caused by missing null checks"
+✓ "Claude said the fix is ready to test after server restart"
+✓ "User asked about the performance impact"
+✗ "Claude made progress on the bug" (too vague)
+✗ "The session is going well" (interpretive, not factual)
+
+Return ONLY a JSON array of strings, one per proposition:
+["proposition 1", "proposition 2", ...]`;
+        let rawResponse = '';
+        const startTime = Date.now();
+        try {
+            const response = await this.withRetry('decomposeActivityIntoPropositions', () => this.client.messages.create({
+                model: this.models.propositions, // Use Haiku - faster for factual extraction
+                max_tokens: 2000,
+                temperature: 0,
+                messages: [{
+                        role: 'user',
+                        content: prompt
+                    }]
+            }));
+            const durationMs = Date.now() - startTime;
+            // Log cost for PROPOSITIONS operation (Haiku)
+            this.logCost(response, 'PROPOSITIONS', this.models.propositions, durationMs, sessionId);
+            const textContent = response.content.find(block => block.type === 'text');
+            if (!textContent || textContent.type !== 'text') {
+                return [];
+            }
+            rawResponse = textContent.text;
+            let jsonText = textContent.text.trim();
+            // Strip markdown code blocks if present (```json ... ```)
+            if (jsonText.startsWith('```')) {
+                jsonText = jsonText.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
+            }
+            // Strip markdown headings and prose before JSON (e.g., "# Summary\nHere are...")
+            // Always try to extract JSON array first, even if text looks like it starts with [
+            const jsonMatch = jsonText.match(/\[[\s\S]*?\](?=\s*$)/);
+            if (jsonMatch) {
+                jsonText = jsonMatch[0];
+            }
+            else if (!jsonText.startsWith('[')) {
+                // No JSON array found and doesn't start with [
+                this.logger.debug('Decomposition response is not JSON', { preview: jsonText.slice(0, 200) });
+                return [];
+            }
+            const propositions = JSON.parse(jsonText);
+            // Log token usage for cost tracking
+            this.logger.info('Propositional decomposition (Haiku)', {
+                model: this.models.propositions,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                propositionCount: Array.isArray(propositions) ? propositions.length : 0,
+                activityCount: recentActivity.length
+            });
+            return Array.isArray(propositions) ? propositions : [];
+        }
+        catch (error) {
+            this.logger.debug('Failed to decompose activity into propositions', {
+                error: error instanceof Error ? error.message : String(error),
+                responsePreview: rawResponse.slice(0, 200),
+            });
+            return [];
+        }
+    }
+    /**
+     * Generate fast patch for session purpose only.
+     *
+     * Theme/tags are now evaluated on user message (evaluateSessionMetadata),
+     * so this method only updates the evolving session purpose based on
+     * what Claude actually did (vs what user asked for).
+     */
+    async generateFastPatch(currentInsights, propositions, _recentActivity, sessionId) {
+        if (!this.client || propositions.length === 0) {
+            return null;
+        }
+        const missionStr = currentInsights.mission || '(not set)';
+        const purposeStr = currentInsights.purpose || missionStr;
+        const propositionsStr = propositions.map((p, i) => `${i + 1}. ${p}`).join('\n');
+        // Simplified prompt - only evaluate purpose, not theme/tags
+        // Theme/tags are now evaluated on user message to prevent flip-flopping
+        const prompt = `You are updating a coding session dashboard based on recent activity.
+
+ORIGINAL SESSION MISSION (frozen at start):
+${missionStr}
+
+CURRENT PURPOSE (what session has evolved to):
+${purposeStr}
+
+RECENT ACTIVITY (propositional facts):
+${propositionsStr}
+
+Based on what was just accomplished, update the session purpose:
+
+**purpose** (30-50 chars): What is this session about NOW?
+- The session's current identity/focus
+- Keep concise: "Building auth system" not "We are currently..."
+- May match the original mission, or may have evolved
+
+Respond with ONLY valid JSON:
+{"purpose": "current session focus"}`;
+        let rawResponse = '';
+        const startTime = Date.now();
+        try {
+            const response = await this.withRetry('generateFastPatch', () => this.client.messages.create({
+                model: this.models.patch,
+                max_tokens: 100, // Reduced - only extracting purpose now
+                temperature: 0,
+                messages: [{
+                        role: 'user',
+                        content: prompt
+                    }]
+            }));
+            const durationMs = Date.now() - startTime;
+            // Log cost for FAST_PATCH operation (Haiku)
+            this.logCost(response, 'FAST_PATCH', this.models.patch, durationMs, sessionId);
+            const textContent = response.content.find(block => block.type === 'text');
+            if (!textContent || textContent.type !== 'text') {
+                return null;
+            }
+            rawResponse = textContent.text;
+            let jsonText = textContent.text.trim();
+            // Strip markdown code blocks if present
+            if (jsonText.startsWith('```')) {
+                jsonText = jsonText.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
+            }
+            // Extract JSON object
+            const jsonMatch = jsonText.match(/\{[\s\S]*\}(?=\s*$)/);
+            if (jsonMatch) {
+                jsonText = jsonMatch[0];
+            }
+            else if (!jsonText.startsWith('{')) {
+                this.logger.debug('FastPatch response is not JSON', { preview: jsonText.slice(0, 200) });
+                return null;
+            }
+            const result = JSON.parse(jsonText);
+            // Validate structure - purpose is required
+            if (!result.purpose || typeof result.purpose !== 'string') {
+                this.logger.debug('FastPatch missing purpose', { keys: Object.keys(result) });
+                return null;
+            }
+            return {
+                milestones: [],
+                recentActions: [],
+                purpose: result.purpose,
+            };
+        }
+        catch (error) {
+            this.logger.debug('FastPatch generation failed', {
+                error: error instanceof Error ? error.message : String(error),
+                responsePreview: rawResponse.slice(0, 200),
+            });
+            return null;
+        }
+    }
+    /**
+     * Generate targeted patches to insights using Sonnet.
+     *
+     * Called when quickCheckInsightsStale returns needsPatch=true.
+     * Returns specific patches to apply rather than regenerating everything.
+     *
+     * @param useFastPath - If true, only generate currentState using fast Haiku-only pipeline (~5s vs ~12s)
+     */
+    async generateInsightsPatch(currentInsights, recentActivity, useFastPath = true, // Default to fast path for better UX
+    sessionId) {
+        if (!this.client) {
+            return { patches: {}, reason: 'Anthropic not configured', propositions: [] };
+        }
+        const startTime = Date.now();
+        try {
+            // Step 1: Decompose activity into propositional facts
+            const decompositionStart = Date.now();
+            const propositions = await this.decomposeActivityIntoPropositions(null, recentActivity, sessionId);
+            const decompositionTime = Date.now() - decompositionStart;
+            this.logger.debug('Propositional decomposition completed', {
+                durationMs: decompositionTime,
+                propositionCount: propositions.length,
+            });
+            // Fast path: Generate purpose, theme, tags using Haiku (~1-2s vs ~12s full patch)
+            // This is the "Haiku-heavy" strategy from Architecture V2
+            if (useFastPath) {
+                this.logger.debug('Using fast path for patch generation');
+                const fastPatch = await this.generateFastPatch({
+                    milestones: currentInsights.milestones,
+                    recentActions: currentInsights.recentActions,
+                    notable: currentInsights.notable, // For deduplication
+                    mission: currentInsights.mission, // For pivot detection
+                    purpose: currentInsights.purpose, // Current evolving purpose
+                    theme: currentInsights.theme, // Current theme for re-evaluation
+                    tags: currentInsights.tags, // Current tags for re-evaluation
+                }, propositions, recentActivity, // Pass activity for intent extraction (Strategy 3)
+                sessionId);
+                const totalTime = Date.now() - startTime;
+                if (fastPatch && fastPatch.purpose) {
+                    this.logger.info('Fast path patch completed', {
+                        durationMs: totalTime,
+                        purpose: fastPatch.purpose,
+                    });
+                    return {
+                        patches: { purpose: fastPatch.purpose },
+                        reason: `Fast path: Updated purpose based on propositional analysis`,
+                        propositions
+                    };
+                }
+                // Fall through to full path if fast path fails
+                this.logger.debug('Fast path returned null, falling back to full patch generation');
+            }
+            // Use propositions if available, fallback to raw activity
+            const activityStr = propositions.length > 0
+                ? propositions.map(p => `• ${p}`).join('\n')
+                : recentActivity.slice(-10).map(a => `[${a.type}] ${a.content}`).join('\n');
+            const prompt = `You are analyzing a coding session transcript to update a dashboard display.
+
+CURRENT SESSION:
+Mission: "${currentInsights.mission}"
+Theme: ${currentInsights.theme}
+Purpose: ${currentInsights.purpose || currentInsights.mission}
+
+RECENT ACTIVITY:
+${activityStr}
+
+Based on what happened, extract the session's current **purpose** (what it's about NOW).
+
+**purpose**: 30-50 chars describing the session's current focus
+- What someone would say if asked "what are you working on?"
+- Keep it concise: "Building auth system" not "We are currently..."
+- May match the original mission, or may have pivoted
+
+Response format (JSON only):
+{
+  "reason": "brief explanation",
+  "patches": {
+    "purpose": "current session focus"
+  }
+}`;
+            const patchGenStart = Date.now();
+            const response = await this.withRetry('generateInsightsPatch', () => this.client.messages.create({
+                model: this.models.fullPatch,
+                max_tokens: 150, // Only extracting purpose now
+                temperature: 0,
+                messages: [{ role: 'user', content: prompt }]
+            }));
+            const duration = Date.now() - startTime;
+            const text = response.content[0]?.type === 'text' ? response.content[0].text : '';
+            // Log cost for PATCH operation (full path)
+            this.logCost(response, 'PATCH', this.models.fullPatch, duration, sessionId);
+            this.logger.info('Fallback patch generation (Sonnet) completed', {
+                durationMs: duration,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+            });
+            try {
+                const jsonMatch = text.match(/\{[\s\S]*\}/);
+                const jsonToParse = jsonMatch?.[0] || text;
+                const result = JSON.parse(jsonToParse);
+                const patches = result.patches || {};
+                return {
+                    patches,
+                    reason: result.reason || 'Fallback patch generated',
+                    propositions
+                };
+            }
+            catch (parseError) {
+                this.logger.warn('Failed to parse fallback patch response', {
+                    error: parseError instanceof Error ? parseError.message : String(parseError),
+                    textPreview: text.slice(0, 200),
+                });
+                return { patches: {}, reason: 'Parse error - no patches applied', propositions };
+            }
+        }
+        catch (error) {
+            // Check for credit/billing errors and make them LOUD
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('credit balance') || errorMessage.includes('billing')) {
+                this.logger.error('🚨 ANTHROPIC API CREDITS EXHAUSTED 🚨', {
+                    errorMessage,
+                    action: 'ADD CREDITS AT https://console.anthropic.com/settings/billing',
+                    context: 'Patch generation failed due to billing issue'
+                });
+            }
+            else {
+                this.logger.error('Patch generation failed', { error });
+            }
+            return { patches: {}, reason: 'Generation error - no patches applied', propositions: [] };
+        }
+    }
+    /**
+     * Summarize what the user is currently asking Claude to do.
+     *
+     * Called immediately when a user message is detected, this generates a brief
+     * description that makes sense even if the user just said "do it" - because
+     * we provide recent conversation context.
+     *
+     * Uses Haiku for speed (~1-2s). The goal is "what would you tell someone
+     * who walked in and asked what you're working on right now?"
+     */
+    async summarizeCurrentWork(userMessage, recentContext, sessionMission, sessionId) {
+        if (!this.client) {
+            return null;
+        }
+        const startTime = Date.now();
+        try {
+            // Build context from recent conversation (last few exchanges)
+            const contextStr = recentContext.length > 0
+                ? recentContext.map(m => `[${m.type === 'user' ? 'User' : 'Claude'}]: ${m.content.slice(0, 500)}`).join('\n\n')
+                : '(new conversation)';
+            const missionStr = sessionMission ? `Session mission: ${sessionMission}\n\n` : '';
+            const prompt = `${missionStr}Recent conversation context:
+${contextStr}
+
+The user just sent this message:
+"${userMessage}"
+
+In 5-10 words, what is the user asking Claude to do RIGHT NOW?
+- Be specific and concrete (not "continuing work" or "helping with code")
+- If the user said something vague like "do it" or "yes" or "go ahead", infer from context what "it" refers to
+- Use action verbs: "Implementing...", "Fixing...", "Adding...", "Debugging..."
+- If truly unclear, describe what can be inferred
+
+Respond with ONLY the summary text, nothing else. No quotes, no explanation.`;
+            const response = await this.withRetry('summarizeCurrentWork', () => this.client.messages.create({
+                model: this.models.quickCheck, // Haiku - speed is critical
+                max_tokens: 50,
+                temperature: 0,
+                messages: [{ role: 'user', content: prompt }]
+            }));
+            const durationMs = Date.now() - startTime;
+            // Log cost
+            this.logCost(response, 'CURRENT_WORK', this.models.quickCheck, durationMs, sessionId);
+            // Strip trailing period - we want consistency with history items which never end with periods
+            const rawText = response.content[0]?.type === 'text' ? response.content[0].text.trim() : null;
+            const text = rawText?.replace(/\.+$/, '') || null;
+            if (!text) {
+                return null;
+            }
+            this.logger.info('Current work summarized', {
+                durationMs,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                summary: text.slice(0, 50),
+            });
+            return { summary: text };
+        }
+        catch (error) {
+            this.logger.debug('Failed to summarize current work', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Evaluate session metadata (purpose/theme/tags) based on user message and context.
+     * Called on user message to update session classification. This replaces the
+     * timer-based fast patch approach with explicit user-message triggering.
+     */
+    async evaluateSessionMetadata(userMessage, recentContext, current, sessionId) {
+        if (!this.client) {
+            return null;
+        }
+        const startTime = Date.now();
+        try {
+            // Build context from recent conversation
+            const contextStr = recentContext.length > 0
+                ? recentContext.map(m => `[${m.type === 'user' ? 'User' : 'Claude'}]: ${m.content.slice(0, 400)}`).join('\n\n')
+                : '(new conversation)';
+            const missionStr = current.mission || '(not set)';
+            const purposeStr = current.purpose || missionStr;
+            const currentTheme = current.theme || 'exploring';
+            const currentTags = current.tags || { workType: ['exploring'], collaboration: 'iterative', complexity: 'routine' };
+            const prompt = `You classify coding session activity based on what the user just asked for.
+
+SESSION MISSION: ${missionStr}
+CURRENT PURPOSE: ${purposeStr}
+CURRENT THEME: ${currentTheme}
+CURRENT TAGS: workType=${JSON.stringify(currentTags.workType)}, collaboration=${currentTags.collaboration}, complexity=${currentTags.complexity}
+
+Recent conversation:
+${contextStr}
+
+User just sent: "${userMessage.slice(0, 500)}"
+
+Based on what the user is now asking Claude to do, update:
+
+1. **purpose** (30-50 chars): Session's current focus. Keep concise.
+2. **theme** (single word): "debugging" | "building" | "exploring" | "firefighting" | "refactoring" | "designing" | "investigating" | "polishing"
+3. **tags**:
+   - workType: ["implementing" | "debugging" | "refactoring" | "exploring" | "designing" | "investigating"]
+   - collaboration: "autonomous" | "iterative" | "guided"
+   - complexity: "routine" | "tricky" | "gnarly"
+
+IMPORTANT: Only change values if this message clearly shifts the session's focus. Preserve current values for continuation messages like "yes", "do it", "continue".
+
+Respond with ONLY valid JSON:
+{"purpose": "...", "theme": "...", "tags": {"workType": [...], "collaboration": "...", "complexity": "..."}}`;
+            const response = await this.withRetry('evaluateSessionMetadata', () => this.client.messages.create({
+                model: this.models.quickCheck, // Haiku - speed is critical
+                max_tokens: 150,
+                temperature: 0,
+                messages: [{ role: 'user', content: prompt }]
+            }));
+            const durationMs = Date.now() - startTime;
+            // Log cost
+            this.logCost(response, 'METADATA_EVAL', this.models.quickCheck, durationMs, sessionId);
+            const text = response.content[0]?.type === 'text' ? response.content[0].text.trim() : null;
+            if (!text) {
+                return null;
+            }
+            // Parse JSON response
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                this.logger.debug('No JSON found in metadata eval response', { text });
+                return null;
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            this.logger.info('Session metadata evaluated', {
+                durationMs,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                theme: parsed.theme,
+                purpose: parsed.purpose?.slice(0, 30),
+            });
+            return {
+                purpose: parsed.purpose,
+                theme: parsed.theme,
+                tags: parsed.tags,
+            };
+        }
+        catch (error) {
+            this.logger.debug('Failed to evaluate session metadata', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    /**
+     * Generate intelligent permission pattern suggestions using Haiku.
+     *
+     * Called immediately when a permission request arrives, this generates
+     * contextually-aware pattern options. By the time the user clicks
+     * "Similar", suggestions should already be ready.
+     *
+     * @param toolName - The tool being invoked (e.g., "Bash", "Write")
+     * @param toolInput - The tool input parameters (e.g., { command: "..." })
+     * @returns Array of suggested patterns from most specific to broadest
+     */
+    async suggestPermissionPatterns(toolName, toolInput) {
+        if (!this.client) {
+            return [];
+        }
+        const startTime = Date.now();
+        try {
+            // Build context based on tool type
+            let contextStr;
+            let valueStr;
+            if (toolName === 'Bash') {
+                const command = toolInput.command || '';
+                valueStr = command;
+                contextStr = `Bash command: ${command}`;
+            }
+            else if (['Write', 'Read', 'Edit'].includes(toolName)) {
+                const filePath = toolInput.file_path || '';
+                valueStr = filePath;
+                contextStr = `${toolName} file: ${filePath}`;
+            }
+            else {
+                // Unknown tool - return basic suggestions
+                return [
+                    `${toolName}(${JSON.stringify(toolInput).slice(0, 50)})`,
+                    toolName
+                ];
+            }
+            const prompt = `You help users create permission patterns for a coding assistant tool.
+
+The user is being asked to approve: ${contextStr}
+
+Generate permission patterns from MOST SPECIFIC (safest) to LEAST SPECIFIC (broadest).
+Each pattern should be meaningfully different and useful.
+
+For Bash commands:
+- Understand the INTENT behind the command, not just the literal text
+- Extract the core tool and action (e.g., "git commit" from "git commit -m 'msg'")
+- For piped commands like "fd -e tsx | head", focus on the primary command (fd)
+- For chained commands like "npm install && npm run build", focus on the first command (npm install)
+
+Pattern syntax:
+- Bash(exact command) - matches only this exact command
+- Bash(git commit *) - matches any git commit command
+- Bash(git *) - matches any git command
+- Bash - matches all bash commands
+
+For file operations:
+- Write(/exact/path/file.tsx) - exact file only
+- Write(/path/to/dir/*.tsx) - any .tsx in that directory
+- Write(/path/**/*.tsx) - any .tsx recursively under path
+- Write(*.tsx) - any .tsx file anywhere
+- Write - all write operations
+
+Generate 3-5 patterns, ordered from safest to broadest.
+IMPORTANT: Only return patterns that make semantic sense for this operation.
+
+Respond with ONLY a JSON array of pattern strings:
+["pattern1", "pattern2", ...]`;
+            const response = await this.withRetry('suggestPermissionPatterns', () => this.client.messages.create({
+                model: this.models.quickCheck, // Haiku - speed is critical
+                max_tokens: 200,
+                temperature: 0,
+                messages: [{ role: 'user', content: prompt }]
+            }));
+            const durationMs = Date.now() - startTime;
+            // Log for observability (no cost tracking category for this yet)
+            this.logger.info('Permission patterns suggested', {
+                durationMs,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                toolName,
+                valuePreview: valueStr.slice(0, 50),
+            });
+            const text = response.content[0]?.type === 'text' ? response.content[0].text.trim() : null;
+            if (!text) {
+                return [];
+            }
+            // Parse JSON array response
+            let jsonText = text;
+            // Strip markdown code blocks if present
+            if (jsonText.startsWith('```')) {
+                jsonText = jsonText.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
+            }
+            // Extract JSON array
+            const jsonMatch = jsonText.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                this.logger.debug('No JSON array found in pattern response', { text });
+                return [];
+            }
+            const patterns = JSON.parse(jsonMatch[0]);
+            // Validate patterns - ensure they're strings and not empty
+            const validPatterns = patterns.filter(p => typeof p === 'string' && p.length > 0);
+            // Always ensure the broadest pattern is included
+            if (validPatterns.length > 0 && !validPatterns.includes(toolName)) {
+                validPatterns.push(toolName);
+            }
+            return validPatterns;
+        }
+        catch (error) {
+            this.logger.debug('Failed to suggest permission patterns', {
+                error: error instanceof Error ? error.message : String(error),
+                toolName,
+            });
+            return [];
+        }
+    }
+}
+// Export singleton instance
+export const anthropicService = new AnthropicService();
+//# sourceMappingURL=anthropic-service.js.map