claudia-orchestrator 0.1.0

package/dist/services/anthropic-service.js

@@ -0,0 +1,1132 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { CUIError, } from '../types/index.js';
+import { createLogger } from '../services/logger.js';
+import { ConfigService } from './config-service.js';
+import { getCostTracker } from './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',
+};
+// ============================================================================
+// Shared Prompt Components
+// ============================================================================
+// Extracted prompt sections that are reused across multiple LLM calls.
+// Single source of truth for consistent behavior.
+/**
+ * CurrentState decision logic - guides the LLM on how to determine session state.
+ * Used in: extractSessionInsights, generateCurrentStateOnly, generateInsightsPatch
+ */
+const CURRENT_STATE_DECISION_PROMPT = `Think carefully about what someone monitoring this session needs to know.
+
+Before deciding the current state, ask yourself:
+
+1. "What is the actual situation right now?"
+   - Is the agent actively working on something?
+   - Is the agent idle, waiting for the user?
+   - Is something blocking progress?
+
+2. "What's the last thing Claude communicated to the user?"
+   - Did Claude make a request or ask a question?
+   - Did Claude present a summary and stop?
+   - Did Claude describe next steps that require user action?
+
+3. "Is there unfinished business?"
+   - Even if implementation is "done", is validation/testing/verification still needed?
+   - Did Claude say "ready to test" or "after you do X" - meaning X hasn't happened yet?
+   - Or is everything truly complete with no pending actions?
+
+4. "What does the dashboard viewer need to understand?"
+   - If they're checking in on this session, what's the most accurate summary?
+   - What's the one thing they need to know about where this session stands?
+
+IMPORTANT: When in doubt between "completed" vs "waiting", err on the side of "waiting".
+It's much worse to say everything is done when user action is still needed, than to imply
+there's pending work when things are actually complete. If there's ANY hint of testing,
+validation, verification, or "after you do X" - that's waiting, not completed.
+
+Choose the format and wording that communicates most clearly:
+- Single line summary, or
+- Bullet points (with or without icons)
+
+Color guidance:
+- **amber**: waiting for user action, pending decision, question asked
+- **red**: blocked, error preventing progress
+- **emerald**: truly complete - implemented, validated, no pending actions
+- **sky**: actively working, in progress
+
+Choose an icon that fits the situation.
+
+The right state is the one that accurately communicates the session's reality to someone monitoring from the dashboard.`;
+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 CUIError('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) {
+        if (!this.client) {
+            throw new CUIError('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, where it's at, and what's notable.
+
+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. CURRENT STATE - Describe where this coding session stands right now.
+
+   This is the most important indicator for deciding whether to jump back into a session.
+
+${CURRENT_STATE_DECISION_PROMPT.split('\n').map(line => '   ' + line).join('\n')}
+
+   LANGUAGE RULES:
+   - Use "we" to mean the session participants (user + Claude working together)
+   - NEVER use "you" or "your" - the person reading this dashboard is NOT the session participant
+   - Bad: "your edit", "you found", "waiting for your input"
+   - Good: "We made an edit", "We found the issue", "Waiting for input on X"
+
+   Each currentState has:
+   - icon: emoji that fits the situation
+   - color: semantic color (amber/red/emerald/sky) based on the guidance above
+   - content: Single line summary OR bullet points (with or without icons)
+
+3. THEME - A single word capturing the session's current mode/vibe:
+   Examples: "debugging", "building", "exploring", "firefighting", "refactoring", "designing", "investigating", "polishing"
+
+4. TAGS - Quick categorization:
+   - workType: ["implementing", "debugging", "refactoring", "exploring", "designing"]
+   - domain: Technical domains touched, e.g., ["UI", "database"], ["API", "auth"]
+   - collaboration: "autonomous" | "iterative" | "guided"
+   - complexity: "routine" | "tricky" | "gnarly"
+
+5. PANELS - Design 3-4 stable semantic panels that capture the essence of this session.
+
+   PANEL PHILOSOPHY:
+   - Panels should be STABLE - they define the semantic shape of the session
+   - Update the VALUE when facts change, not the panel itself
+   - Only change panels if the session fundamentally pivots
+   - Use expressive emoji icons that capture meaning at a glance
+
+   Each panel has:
+   - label: Short semantic label (e.g., "Goal", "Key Constraint", "Approach", "Target User")
+   - icon: Single emoji that captures the panel meaning (🎯 🧠 🔬 ⚠️ 📊 💡 🔧 🚀 etc.)
+   - value: A single concise sentence capturing the current state
+   - color: One of: "sky", "purple", "rose", "orange", "emerald", "amber", "red", "teal", "blue", "fuchsia", "slate"
+
+   Pick colors that match semantic meaning:
+   - sky/blue: informational, context, status
+   - emerald/teal: success, progress, done
+   - amber/orange: warnings, blockers, pending
+   - red/rose: errors, critical issues
+   - purple/fuchsia: decisions, architecture, design
+   - slate: neutral, reference
+
+6. MILESTONES - The roadmap of the session:
+
+   Milestones show the journey: what's done, what's active, AND what's coming.
+
+   CRITICAL: ALWAYS return 3-5 milestones. Think like a project manager - decompose the mission into steps:
+   - What has been accomplished? (done)
+   - What's actively being worked on? (in_progress)
+   - What logically comes NEXT? (pending) ← This is the most valuable part!
+
+   FORWARD-LOOKING IS KEY:
+   - Don't just report what happened - anticipate what's needed to complete the mission
+   - Break down the user's goal into logical steps, even if they weren't explicitly stated
+   - Example: If mission is "add dark mode", milestones might be:
+     ✓ [done] Create theme context
+     → [in_progress] Update components to use theme
+     ○ [pending] Add theme toggle UI
+     ○ [pending] Persist theme preference
+     ○ [pending] Test theme switching
+
+   MILESTONE PHILOSOPHY:
+   - Milestones tell the story of intent: past, present, AND planned
+   - When work completes: mark "done"
+   - When new objectives emerge: ADD new milestones (don't remove old ones)
+   - When the user pivots away from something incomplete: mark it "on_hold" (might return)
+   - When an approach is abandoned for a better one: mark it "superseded" (won't return)
+   - Available statuses (use exactly these strings): "pending", "in_progress", "done", "on_hold", "superseded"
+   - Keep 5-7 visible milestones. Oldest completed items can be dropped if needed to make room.
+
+7. NOTABLE - Cumulative event log with rich emojis:
+
+   Each event has:
+   - icon: Expressive emoji matching event type (💡 🔄 🔧 ✨ 🎯 ✅ ⚠️ 🐛 🎨 📝 🧪 🚀 etc.)
+   - type: "insight" | "pivot" | "breakthrough" | "infrastructure" | "refinement" | "validation" | "error" | "fix" | "blocker" | "decision" | "iteration"
+   - text: What happened (1 sentence)
+
+   NOTABLE PHILOSOPHY:
+   - Events ACCUMULATE over time - don't remove old events
+   - New events get added to the list as they occur
+   - Use diverse, expressive emojis to make scanning easy
+
+8. RECENT ACTIONS - 3-4 most recent concrete actions
+
+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" },
+  "currentState": { "icon": "emoji (required)", "color": "sky|emerald|amber|red|...", "content": "sentence or bullet points" },
+  "theme": "string",
+  "tags": { "workType": [...], "domain": [...], "collaboration": "...", "complexity": "..." },
+  "panels": [ { "label": "string", "icon": "emoji", "color": "sky|purple|rose|...", "value": "string" } ],
+  "milestones": [ { "label": "string", "status": "pending|in_progress|done|on_hold|superseded" } ],
+  "notable": [ { "icon": "emoji", "type": "...", "text": "string" } ],
+  "recentActions": ["string", ...]
+}`;
+        let responseText = null;
+        const startTime = Date.now();
+        try {
+            const response = await this.withRetry('extractSessionInsights', () => this.client.messages.create({
+                model: this.models.generation,
+                max_tokens: 2000,
+                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);
+            responseText = response.content[0]?.type === 'text' ? response.content[0].text : null;
+            if (!responseText) {
+                throw new CUIError('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 || !result.tags) {
+                throw new CUIError('ANTHROPIC_INSIGHTS_ERROR', 'Invalid response structure', 500);
+            }
+            // Ensure arrays exist with defaults
+            result.milestones = result.milestones || [];
+            result.notable = result.notable || [];
+            result.recentActions = result.recentActions || [];
+            result.panels = result.panels || [];
+            result.theme = result.theme || 'working';
+            result.currentState = result.currentState || { icon: '🔄', color: 'sky', content: 'Session in progress' };
+            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,
+                currentState: result.currentState.content?.slice(0, 50),
+                panelCount: result.panels.length,
+                panelLabels: result.panels.map(p => p.label || p.title || 'untitled'),
+                panelValues: result.panels.map(p => p.value ? `${p.value.slice(0, 50)}...` : p.items ? `${p.items.length} items` : 'empty'),
+                milestoneCount: result.milestones.length,
+                notableCount: result.notable.length
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof CUIError) {
+                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 CUIError('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 CUIError('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 CUIError('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 CUIError('ANTHROPIC_NAME_ERROR', 'No name returned', 500);
+            }
+            return { name };
+        }
+        catch (error) {
+            if (error instanceof CUIError) {
+                throw error;
+            }
+            this.logger.error('Session name generation failed', { error });
+            throw new CUIError('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) {
+        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 panelsStr = currentInsights.panels
+                .map(p => p.title)
+                .join(', ');
+            const actionsStr = recentActions.join('\n');
+            const prompt = `Current session insights (a living summary of the conversation):
+- Mission: "${currentInsights.mission}"
+- Milestones: ${milestonesStr || '(none)'}
+- Panels: ${panelsStr || '(none)'}
+
+Recent activity:
+${actionsStr}
+
+Should these insights be updated to reflect the recent activity?
+
+Say YES (needsPatch: true) if ANY of these apply:
+- Work was done that should be reflected in a panel (new file, code change, finding, etc.)
+- 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);
+            // 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) {
+        if (!this.client) {
+            return [];
+        }
+        const previousStateStr = previousState
+            ? `${previousState.icon} [${previousState.color}] ${previousState.content}`
+            : '(no previous state)';
+        const activityStr = recentActivity
+            .map(a => `[${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);
+            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 [];
+        }
+    }
+    /**
+     * Fast currentState-only update using Haiku.
+     * Bypasses full patch generation when only currentState needs updating.
+     * Much faster (~3-4s) than full patch pipeline (~12s).
+     */
+    async generateCurrentStateOnly(currentState, propositions) {
+        if (!this.client || propositions.length === 0) {
+            return null;
+        }
+        const previousStateStr = currentState
+            ? `${currentState.icon} [${currentState.color}] ${currentState.content}`
+            : '(no previous state)';
+        const propositionsStr = propositions.map((p, i) => `${i + 1}. ${p}`).join('\n');
+        const prompt = `You are updating the "current state" for a coding session dashboard.
+
+**Previous Current State:**
+${previousStateStr}
+
+**What Happened Since Then (propositional facts):**
+${propositionsStr}
+
+**Your Task:**
+Decide the new current state for the dashboard. This is what someone monitoring the session needs to know RIGHT NOW.
+
+${CURRENT_STATE_DECISION_PROMPT}
+
+LANGUAGE:
+- Use "we" (session participants working together)
+- NEVER "you"/"your" (dashboard reader is NOT a participant)
+- You're an OBSERVER analyzing their session
+
+Respond with ONLY valid JSON:
+{
+  "icon": "emoji",
+  "color": "amber|red|emerald|sky",
+  "content": "single line or bullet points"
+}`;
+        let rawResponse = '';
+        try {
+            const response = await this.withRetry('generateCurrentStateOnly', () => this.client.messages.create({
+                model: this.models.patch, // Use Haiku for fast currentState-only updates
+                max_tokens: 300,
+                temperature: 0,
+                messages: [{
+                        role: 'user',
+                        content: prompt
+                    }]
+            }));
+            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 (```json ... ```)
+            if (jsonText.startsWith('```')) {
+                jsonText = jsonText.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '').trim();
+            }
+            // Strip markdown headings and prose before JSON (e.g., "# Summary\nHere is...")
+            // Always try to extract JSON object 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 object found and doesn't start with {
+                this.logger.debug('CurrentState response is not JSON', { preview: jsonText.slice(0, 200) });
+                return null;
+            }
+            const result = JSON.parse(jsonText);
+            return result;
+        }
+        catch (error) {
+            this.logger.debug('Failed to generate currentState', {
+                error: error instanceof Error ? error.message : String(error),
+                responsePreview: rawResponse.slice(0, 200),
+            });
+            return null;
+        }
+    }
+    /**
+     * Generate a fast patch using Haiku that updates:
+     * - currentState
+     * - milestones (status updates + new ones)
+     * - recentActions
+     *
+     * This is the new "Haiku-heavy" patch strategy from Architecture V2.
+     * Much faster (~1-2s) than full Sonnet patch (~12s).
+     * Panels, notable, and context are handled by REFRESH (Opus).
+     */
+    async generateFastPatch(currentInsights, propositions) {
+        if (!this.client || propositions.length === 0) {
+            return null;
+        }
+        const previousStateStr = currentInsights.currentState
+            ? `${currentInsights.currentState.icon} [${currentInsights.currentState.color}] ${currentInsights.currentState.content}`
+            : '(no previous state)';
+        const milestonesStr = currentInsights.milestones.length > 0
+            ? currentInsights.milestones.map(m => `[${m.status}] ${m.label}`).join('\n')
+            : '(none)';
+        const propositionsStr = propositions.map((p, i) => `${i + 1}. ${p}`).join('\n');
+        const prompt = `You are updating a coding session dashboard based on recent activity.
+
+CURRENT STATE:
+${previousStateStr}
+
+CURRENT MILESTONES (Progress):
+${milestonesStr}
+
+RECENT ACTIVITY (propositional facts):
+${propositionsStr}
+
+Update the dashboard to reflect what happened. Return JSON with:
+
+1. **currentState**: What's the situation right now?
+   - icon: emoji
+   - color: amber (waiting), red (blocked), emerald (done), sky (working)
+   - content: single sentence or bullet points
+
+2. **milestones**: Update statuses AND add forward-looking milestones
+   - Mark completed work as "done"
+   - Mark active work as "current" (only ONE at a time)
+   - IMPORTANT: Add pending milestones for what logically comes NEXT
+   - Think ahead: what steps remain to complete the session's goal?
+   - Keep labels stable when possible (don't rephrase existing milestones)
+   - Use {"action": "update", "label": "exact existing label", "status": "done|current|pending"}
+   - Use {"action": "add", "label": "New milestone", "status": "pending"} for upcoming steps
+
+3. **recentActions**: 3-4 most recent concrete actions (tool names, file edits, etc.)
+   - Keep these short: "Read config.ts", "Edit auth.ts", "Ran tests"
+   - Most recent last
+
+LANGUAGE:
+- Use "we" (session participants)
+- Never "you/your" (observer, not participant)
+
+Respond with ONLY valid JSON:
+{
+  "currentState": { "icon": "...", "color": "...", "content": "..." },
+  "milestones": [
+    { "action": "update", "label": "exact label", "status": "done" },
+    { "action": "add", "label": "New objective", "status": "pending" }
+  ],
+  "recentActions": ["Action 1", "Action 2", "Action 3"]
+}`;
+        let rawResponse = '';
+        const startTime = Date.now();
+        try {
+            const response = await this.withRetry('generateFastPatch', () => this.client.messages.create({
+                model: this.models.patch,
+                max_tokens: 600,
+                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);
+            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
+            if (!result.currentState || !Array.isArray(result.milestones) || !Array.isArray(result.recentActions)) {
+                this.logger.debug('FastPatch invalid response structure', { keys: Object.keys(result) });
+                return null;
+            }
+            return result;
+        }
+        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
+    ) {
+        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(currentInsights.currentState, recentActivity);
+            const decompositionTime = Date.now() - decompositionStart;
+            this.logger.debug('Propositional decomposition completed', {
+                durationMs: decompositionTime,
+                propositionCount: propositions.length,
+            });
+            // Fast path: Generate currentState + milestones + recentActions 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({
+                    currentState: currentInsights.currentState,
+                    milestones: currentInsights.milestones,
+                    recentActions: currentInsights.recentActions,
+                }, propositions);
+                const totalTime = Date.now() - startTime;
+                if (fastPatch) {
+                    const patches = {};
+                    // Always include currentState if present
+                    if (fastPatch.currentState) {
+                        patches.currentState = fastPatch.currentState;
+                    }
+                    // Include milestones if there are any changes
+                    if (fastPatch.milestones && fastPatch.milestones.length > 0) {
+                        patches.milestones = fastPatch.milestones;
+                    }
+                    // Include recentActions if present
+                    if (fastPatch.recentActions && fastPatch.recentActions.length > 0) {
+                        patches.recentActions = fastPatch.recentActions;
+                    }
+                    const patchedFields = Object.keys(patches);
+                    this.logger.info('Fast path patch completed', {
+                        durationMs: totalTime,
+                        patchedFields,
+                    });
+                    return {
+                        patches,
+                        reason: `Fast path: Updated ${patchedFields.join(', ')} 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');
+            }
+            const milestonesStr = currentInsights.milestones
+                .map((m, i) => `  ${i}: [${m.status}] ${m.label}`)
+                .join('\n');
+            const panelsStr = currentInsights.panels
+                .map(p => {
+                // Handle both V8 format (label/value) and old format (title/items)
+                const panelLabel = p.label || p.title || 'Untitled';
+                const panelContent = p.value
+                    ? p.value // Show full value, not truncated
+                    : p.items?.map(item => typeof item === 'string' ? item : item.text).join(', ') || '(empty)'; // Show all items, not just first 3
+                return `  - "${panelLabel}": ${panelContent}`;
+            })
+                .join('\n');
+            // 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 currentStateStr = currentInsights.currentState
+                ? `${currentInsights.currentState.icon} [${currentInsights.currentState.color}] ${currentInsights.currentState.content}`
+                : '(none)';
+            // Format previous propositions if available
+            const previousPropsStr = (currentInsights.previousPropositions && currentInsights.previousPropositions.length > 0)
+                ? currentInsights.previousPropositions.map(p => `• ${p}`).join('\n')
+                : null;
+            const prompt = `You are analyzing a coding session transcript to update a dashboard display.
+
+IMPORTANT CONTEXT:
+- You are an OBSERVER looking at a transcript of a human ("the user") working with Claude ("the assistant")
+- The "RECENT ACTIVITY" below shows what happened in THEIR session
+- Your job is to update the dashboard to reflect what's happening in their session
+- NEVER ask questions or request clarification - just analyze what happened and update accordingly
+- The "current state" should describe THEIR session state, not ask meta-questions about the insights
+
+CURRENT SESSION INSIGHTS:
+Mission: "${currentInsights.mission}"
+Theme: ${currentInsights.theme}
+Current State: ${currentStateStr}
+
+Milestones:
+${milestonesStr || '  (none)'}
+
+Panels:
+${panelsStr || '  (none)'}
+
+Notable events:
+${currentInsights.notable.map(n => `  • ${n.icon || '•'} ${n.text}`).join('\n') || '  (none)'}
+
+${previousPropsStr ? `PROPOSITIONS THAT GENERATED CURRENT INSIGHTS:
+${previousPropsStr}
+
+` : ''}WHAT HAPPENED SINCE LAST UPDATE (exhaustive propositional facts):
+${activityStr}
+
+The above is an exhaustive, factual breakdown of everything that was done and said since the last current state update.
+Each bullet point is a specific, verifiable fact extracted from the session transcript.
+
+Generate PATCHES to update these insights based on what happened.
+Only include fields that need changing. Be surgical - don't regenerate what's still accurate.
+
+PANEL RULES (STRICT - NEVER VIOLATE):
+- Sessions have EXACTLY 4 panels - this is a hard limit
+- CURRENT PANELS: ${currentInsights.panels.map(p => `"${p.label || p.title}"`).join(', ')}
+- To change a panel's content: use {"action": "update", "label": "exact label from above", "value": "new content"}
+- To completely replace a panel: use {"action": "remove", "label": "old label"} then {"action": "add", "label": "New Label", ...}
+- You can ONLY use "add" if there are fewer than 4 panels total after removals
+- When in doubt, UPDATE existing panels rather than adding new ones
+- Match panel labels EXACTLY as shown above
+
+NOTABLE EVENT GUIDELINES:
+- Only add truly SIGNIFICANT events: breakthroughs, blockers, major decisions, errors, fixes, pivots, insights
+- Do NOT add routine actions like "added logging" or "updated tests"
+- Each event should be meaningful enough that someone reviewing the session would want to know about it
+- Use specific event types: "insight", "pivot", "breakthrough", "infrastructure", "refinement", "validation", "error", "fix", "blocker", "decision", "iteration", "correction"
+- Choose expressive emojis that capture the meaning: 💡🔄🔧✨🎯✅⚠️🐛🎨📝🧪🚀🔥⚡🛠️🏗️
+- Keep text to one concise sentence describing what happened and why it matters
+
+CURRENT STATE - ALWAYS UPDATE THIS (HIGHEST PRIORITY):
+
+${CURRENT_STATE_DECISION_PROMPT}
+
+Response format (JSON only):
+{
+  "reason": "brief explanation of changes",
+  "patches": {
+    "mission": "new mission if changed",
+    "description": "new description if changed",
+    "theme": "new theme if changed",
+    "currentState": {"icon": "emoji", "color": "sky|emerald|amber|red|...", "content": "short description of current state"},
+    "milestones": [
+      {"action": "update", "label": "exact label", "status": "done|in_progress|pending|on_hold|superseded"},
+      {"action": "add", "label": "new milestone", "status": "pending"}
+    ],
+    "panels": [
+      {"action": "update", "label": "exact label", "value": "updated single sentence"},
+      {"action": "add", "label": "New Panel", "icon": "emoji", "color": "sky|purple|rose|orange|emerald|amber|red|teal|blue|fuchsia|slate", "value": "one sentence"},
+      {"action": "remove", "label": "Obsolete Panel"}
+    ],
+    "notable": [
+      {"action": "add", "type": "breakthrough|insight|fix|error|blocker|decision|pivot|iteration|infrastructure|refinement|validation|correction", "text": "What happened and why it matters", "icon": "🚀"}
+    ],
+    "recentActions": ["Action 1", "Action 2"],
+    "tags": ["tag1", "tag2"]
+  }
+}
+
+Only include patches object keys that need updating. Omit unchanged fields (except currentState which should usually be updated).`;
+            const patchGenStart = Date.now();
+            const response = await this.withRetry('generateInsightsPatch', () => this.client.messages.create({
+                model: this.models.fullPatch,
+                max_tokens: 800,
+                temperature: 0, // Lower temperature for more consistent currentState decisions
+                messages: [{ role: 'user', content: prompt }]
+            }));
+            const patchGenTime = Date.now() - patchGenStart;
+            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);
+            // Log for observability
+            this.logger.info('Patch generation (Sonnet) completed', {
+                durationMs: duration,
+                inputTokens: response.usage?.input_tokens,
+                outputTokens: response.usage?.output_tokens,
+                activityCount: recentActivity.length,
+                responseLength: text.length
+            });
+            try {
+                const jsonMatch = text.match(/\{[\s\S]*\}/);
+                const result = JSON.parse(jsonMatch?.[0] || text);
+                const patches = result.patches || {};
+                // Log what's being patched for observability
+                const patchedFields = Object.keys(patches).filter(k => patches[k] !== undefined);
+                this.logger.info('Patch fields identified', {
+                    patchedFields,
+                    milestonesPatched: patches.milestones?.length || 0,
+                    panelsPatched: patches.panels?.length || 0,
+                    notableAdded: patches.notable?.length || 0
+                });
+                return {
+                    patches,
+                    reason: result.reason || 'Patches generated',
+                    propositions
+                };
+            }
+            catch {
+                this.logger.debug('Failed to parse patch response', { text });
+                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: [] };
+        }
+    }
+}
+// Export singleton instance
+export const anthropicService = new AnthropicService();
+//# sourceMappingURL=anthropic-service.js.map