grov 0.1.1 → 0.2.2

package/dist/lib/llm-extractor.d.ts

@@ -1,5 +1,5 @@
 import type { ParsedSession } from './jsonl-parser.js';
-import type { TaskStatus } from './store.js';
+import type { TaskStatus, SessionState, StepRecord } from './store.js';
 export interface ExtractedReasoning {
     task: string;
     goal: string;
@@ -17,6 +17,23 @@ export interface ExtractedReasoning {
  * Check if LLM extraction is available (OpenAI API key set)
  */
 export declare function isLLMAvailable(): boolean;
+export interface ExtractedIntent {
+    goal: string;
+    expected_scope: string[];
+    constraints: string[];
+    success_criteria?: string[];
+    keywords: string[];
+}
+/**
+ * Extract intent from first user prompt using Haiku
+ * Called once at session start to populate session_states
+ * Falls back to basic extraction if API unavailable (for hook compatibility)
+ */
+export declare function extractIntent(firstPrompt: string): Promise<ExtractedIntent>;
+/**
+ * Check if intent extraction is available
+ */
+export declare function isIntentExtractionAvailable(): boolean;
 /**
  * Check if Anthropic API is available (for drift detection)
  */
@@ -34,17 +51,49 @@ export declare function extractReasoning(session: ParsedSession): Promise<Extrac
  */
 export declare function classifyTaskStatus(session: ParsedSession): Promise<TaskStatus>;
 /**
- * Extracted intent from first prompt
+ * Check if session summary generation is available
  */
-export interface ExtractedIntent {
-    goal: string;
-    expected_scope: string[];
-    constraints: string[];
-    success_criteria: string[];
-    keywords: string[];
+export declare function isSummaryAvailable(): boolean;
+/**
+ * Generate session summary for CLEAR operation
+ * Reference: plan_proxy_local.md Section 2.3, 4.5
+ */
+export declare function generateSessionSummary(sessionState: SessionState, steps: StepRecord[]): Promise<string>;
+/**
+ * Task analysis result from Haiku
+ */
+export interface TaskAnalysis {
+    action: 'continue' | 'new_task' | 'subtask' | 'parallel_task' | 'task_complete' | 'subtask_complete';
+    topic_match?: 'YES' | 'NO';
+    task_id: string;
+    current_goal: string;
+    parent_task_id?: string;
+    reasoning: string;
+    step_reasoning?: string;
 }
 /**
- * Extract intent from a prompt using Claude Haiku
- * Falls back to basic extraction if API unavailable
+ * Check if task analysis is available
+ */
+export declare function isTaskAnalysisAvailable(): boolean;
+/**
+ * Analyze task context to determine task status
+ * Called after each main model response to orchestrate sessions
+ * Also compresses reasoning for steps if assistantResponse > 1000 chars
+ */
+export declare function analyzeTaskContext(currentSession: SessionState | null, latestUserMessage: string, recentSteps: StepRecord[], assistantResponse: string): Promise<TaskAnalysis>;
+export interface ExtractedReasoningAndDecisions {
+    reasoning_trace: string[];
+    decisions: Array<{
+        choice: string;
+        reason: string;
+    }>;
+}
+/**
+ * Check if reasoning extraction is available
+ */
+export declare function isReasoningExtractionAvailable(): boolean;
+/**
+ * Extract reasoning trace and decisions from steps
+ * Called at task_complete to populate team memory with rich context
  */
-export declare function extractIntent(prompt: string): Promise<ExtractedIntent>;
+export declare function extractReasoningAndDecisions(stepsReasoning: string[], originalGoal: string): Promise<ExtractedReasoningAndDecisions>;

package/dist/lib/llm-extractor.js

@@ -2,8 +2,18 @@
 // and Anthropic Claude Haiku for drift detection
 import OpenAI from 'openai';
 import Anthropic from '@anthropic-ai/sdk';
+import { config } from 'dotenv';
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
 import { debugLLM } from './debug.js';
 import { truncate } from './utils.js';
+// Load ~/.grov/.env as fallback for API key
+// This allows users to store their API key in a safe location outside any repo
+const grovEnvPath = join(homedir(), '.grov', '.env');
+if (existsSync(grovEnvPath)) {
+    config({ path: grovEnvPath });
+}
 let client = null;
 let anthropicClient = null;
 /**
@@ -39,6 +49,133 @@ function getAnthropicClient() {
 export function isLLMAvailable() {
     return !!process.env.OPENAI_API_KEY;
 }
+/**
+ * Extract intent from first user prompt using Haiku
+ * Called once at session start to populate session_states
+ * Falls back to basic extraction if API unavailable (for hook compatibility)
+ */
+export async function extractIntent(firstPrompt) {
+    // Check availability first - allows hook to work without API key
+    if (!isIntentExtractionAvailable()) {
+        return createFallbackIntent(firstPrompt);
+    }
+    try {
+        const client = getAnthropicClient();
+        const prompt = `Analyze this user request and extract structured intent for a coding assistant session.
+
+USER REQUEST:
+${firstPrompt.substring(0, 2000)}
+
+Extract as JSON:
+{
+  "goal": "The main objective in 1-2 sentences",
+  "expected_scope": ["list", "of", "files/folders", "likely", "to", "be", "modified"],
+  "constraints": ["EXPLICIT restrictions from the user - see examples below"],
+  "success_criteria": ["How to know when the task is complete"],
+  "keywords": ["relevant", "technical", "terms"]
+}
+
+═══════════════════════════════════════════════════════════════
+CONSTRAINTS EXTRACTION - BE VERY THOROUGH
+═══════════════════════════════════════════════════════════════
+
+Look for NEGATIVE constraints (things NOT to do):
+- "NU modifica" / "DON'T modify" / "NEVER change" / "don't touch"
+- "NU rula" / "DON'T run" / "NO commands" / "don't execute"
+- "fără X" / "without X" / "except X" / "not including"
+- "nu scrie cod" / "don't write code" / "just plan"
+
+Look for POSITIVE constraints (things MUST do / ONLY do):
+- "ONLY modify X" / "DOAR în X" / "only in folder Y"
+- "must use Y" / "trebuie să folosești Y"
+- "keep it simple" / "no external dependencies"
+- "use TypeScript" / "must be async"
+
+EXAMPLES:
+Input: "Fix bug in auth. NU modifica nimic in afara de sandbox/, NU rula comenzi."
+Output constraints: ["DO NOT modify files outside sandbox/", "DO NOT run commands"]
+
+Input: "Add feature X. Only use standard library, keep backward compatible."
+Output constraints: ["ONLY use standard library", "Keep backward compatible"]
+
+Input: "Analyze code and create plan. Nu scrie cod inca, doar planifica."
+Output constraints: ["DO NOT write code yet", "Only create plan/analysis"]
+
+For expected_scope:
+- Include file patterns (e.g., "src/auth/", "*.test.ts", "sandbox/")
+- Include component/module names mentioned
+- Be conservative - only include clearly relevant areas
+
+RESPONSE RULES:
+- English only (translate Romanian/other languages to English)
+- No emojis
+- Valid JSON only
+- If no constraints found, return empty array []`;
+        const response = await client.messages.create({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 500,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const content = response.content?.[0];
+        if (!content || content.type !== 'text') {
+            return createFallbackIntent(firstPrompt);
+        }
+        try {
+            const jsonMatch = content.text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                return createFallbackIntent(firstPrompt);
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                goal: typeof parsed.goal === 'string' ? parsed.goal : firstPrompt.substring(0, 200),
+                expected_scope: Array.isArray(parsed.expected_scope)
+                    ? parsed.expected_scope.filter((s) => typeof s === 'string')
+                    : [],
+                constraints: Array.isArray(parsed.constraints)
+                    ? parsed.constraints.filter((c) => typeof c === 'string')
+                    : [],
+                success_criteria: Array.isArray(parsed.success_criteria)
+                    ? parsed.success_criteria.filter((s) => typeof s === 'string')
+                    : [],
+                keywords: Array.isArray(parsed.keywords)
+                    ? parsed.keywords.filter((k) => typeof k === 'string')
+                    : [],
+            };
+        }
+        catch {
+            return createFallbackIntent(firstPrompt);
+        }
+    }
+    catch {
+        // Outer catch - API errors, network issues, etc.
+        return createFallbackIntent(firstPrompt);
+    }
+}
+/**
+ * Fallback intent extraction without LLM
+ */
+function createFallbackIntent(prompt) {
+    // Basic keyword extraction
+    const words = prompt.toLowerCase().split(/\s+/);
+    const techKeywords = words.filter(w => w.length > 3 &&
+        /^[a-z]+$/.test(w) &&
+        !['this', 'that', 'with', 'from', 'have', 'will', 'would', 'could', 'should'].includes(w));
+    // Extract file patterns
+    const filePatterns = prompt.match(/[\w\/.-]+\.(ts|js|tsx|jsx|py|go|rs|java|css|html|md)/g) || [];
+    return {
+        goal: prompt.substring(0, 200),
+        expected_scope: [...new Set(filePatterns)].slice(0, 5),
+        constraints: [],
+        success_criteria: [],
+        keywords: [...new Set(techKeywords)].slice(0, 10),
+    };
+}
+/**
+ * Check if intent extraction is available
+ */
+export function isIntentExtractionAvailable() {
+    return !!(process.env.ANTHROPIC_API_KEY || process.env.GROV_API_KEY);
+}
 /**
  * Check if Anthropic API is available (for drift detection)
  */
@@ -75,22 +212,37 @@ ${sessionSummary}
 
 Extract the following as JSON:
 {
-  "task": "Brief description of what the user was trying to do (1 sentence)",
-  "goal": "The underlying goal or problem being solved",
-  "reasoning_trace": ["Key reasoning steps taken", "Decisions made and why", "What was investigated"],
-  "decisions": [{"choice": "What was decided", "reason": "Why this choice was made"}],
-  "constraints": ["Any constraints or requirements discovered"],
+  "task": "Brief description (1 sentence)",
+  "goal": "The underlying problem being solved",
+  "reasoning_trace": [
+    "Be SPECIFIC: include file names, function names, line numbers when relevant",
+    "Format: '[Action] [target] to/for [purpose]'",
+    "Example: 'Read auth.ts:47 to understand token refresh logic'",
+    "Example: 'Fixed null check in validateToken() - was causing silent failures'",
+    "NOT: 'Investigated auth' or 'Fixed bug'"
+  ],
+  "decisions": [{"choice": "What was decided", "reason": "Why this over alternatives"}],
+  "constraints": ["Discovered limitations, rate limits, incompatibilities"],
   "status": "complete|partial|question|abandoned",
   "tags": ["relevant", "domain", "tags"]
 }
 
+IMPORTANT for reasoning_trace:
+- Each entry should be ACTIONABLE information for future developers
+- Include specific file:line references when possible
+- Explain WHY not just WHAT (e.g., "Chose JWT over sessions because stateless scales better")
+- Bad: "Fixed the bug" / Good: "Fixed race condition in UserService.save() - was missing await"
+
 Status definitions:
 - "complete": Task was finished, implementation done
 - "partial": Work started but not finished
 - "question": Claude asked a question and is waiting for user response
 - "abandoned": User interrupted or moved to different topic
 
-Return ONLY valid JSON, no explanation.`
+RESPONSE RULES:
+- English only (translate if input is in other language)
+- No emojis
+- Valid JSON only`
             }
         ]
     });
@@ -290,119 +442,288 @@ function validateStatus(status) {
     }
     return 'partial'; // Default
 }
+// ============================================
+// SESSION SUMMARY FOR CLEAR OPERATION
+// Reference: plan_proxy_local.md Section 2.3, 4.5
+// ============================================
 /**
- * Extract intent from a prompt using Claude Haiku
- * Falls back to basic extraction if API unavailable
+ * Check if session summary generation is available
  */
-export async function extractIntent(prompt) {
-    // Try LLM extraction if available
-    if (isAnthropicAvailable()) {
-        try {
-            return await extractIntentWithLLM(prompt);
+export function isSummaryAvailable() {
+    return !!(process.env.ANTHROPIC_API_KEY || process.env.GROV_API_KEY);
+}
+/**
+ * Generate session summary for CLEAR operation
+ * Reference: plan_proxy_local.md Section 2.3, 4.5
+ */
+export async function generateSessionSummary(sessionState, steps) {
+    const client = getAnthropicClient();
+    const stepsText = steps
+        .filter(s => s.is_validated)
+        .slice(-20)
+        .map(step => {
+        let desc = `- ${step.action_type}`;
+        if (step.files.length > 0) {
+            desc += `: ${step.files.join(', ')}`;
         }
-        catch (error) {
-            debugLLM('extractIntent LLM failed, using fallback: %O', error);
-            return extractIntentBasic(prompt);
+        if (step.command) {
+            desc += ` (${step.command.substring(0, 50)})`;
         }
+        return desc;
+    })
+        .join('\n');
+    const prompt = `Create a concise summary of this coding session for context continuation.
+
+ORIGINAL GOAL: ${sessionState.original_goal || 'Not specified'}
+
+EXPECTED SCOPE: ${sessionState.expected_scope.join(', ') || 'Not specified'}
+
+CONSTRAINTS: ${sessionState.constraints.join(', ') || 'None'}
+
+ACTIONS TAKEN:
+${stepsText || 'No actions recorded'}
+
+Create a summary with these sections (keep total under 500 words):
+1. ORIGINAL GOAL: (1 sentence)
+2. PROGRESS: (2-3 bullet points of what was accomplished)
+3. KEY DECISIONS: (any important choices made)
+4. FILES MODIFIED: (list of files)
+5. CURRENT STATE: (where the work left off)
+6. NEXT STEPS: (recommended next actions)
+
+Format as plain text, not JSON.`;
+    const response = await client.messages.create({
+        model: 'claude-haiku-4-5-20251001',
+        max_tokens: 800,
+        messages: [{ role: 'user', content: prompt }],
+    });
+    const content = response.content?.[0];
+    if (!content || content.type !== 'text') {
+        return createFallbackSummary(sessionState, steps);
     }
-    // Fallback to basic extraction
-    return extractIntentBasic(prompt);
+    return `PREVIOUS SESSION CONTEXT (auto-generated after context limit):
+
+${content.text}`;
 }
 /**
- * Extract intent using Claude Haiku
+ * Create fallback summary without LLM
  */
-async function extractIntentWithLLM(prompt) {
-    const anthropic = getAnthropicClient();
-    const model = getDriftModel();
-    const response = await anthropic.messages.create({
-        model,
-        max_tokens: 1024,
-        messages: [
-            {
-                role: 'user',
-                content: `Analyze this user prompt and extract the task intent. Return ONLY valid JSON, no explanation.
+function createFallbackSummary(sessionState, steps) {
+    const files = [...new Set(steps.flatMap(s => s.files))];
+    return `PREVIOUS SESSION CONTEXT (auto-generated after context limit):
 
-USER PROMPT:
-${prompt}
+ORIGINAL GOAL: ${sessionState.original_goal || 'Not specified'}
 
-Extract as JSON:
+PROGRESS: ${steps.length} actions taken
+
+FILES MODIFIED:
+${files.slice(0, 10).map(f => `- ${f}`).join('\n') || '- None recorded'}
+
+Please continue from where you left off.`;
+}
+/**
+ * Check if task analysis is available
+ */
+export function isTaskAnalysisAvailable() {
+    return !!(process.env.ANTHROPIC_API_KEY || process.env.GROV_API_KEY);
+}
+/**
+ * Analyze task context to determine task status
+ * Called after each main model response to orchestrate sessions
+ * Also compresses reasoning for steps if assistantResponse > 1000 chars
+ */
+export async function analyzeTaskContext(currentSession, latestUserMessage, recentSteps, assistantResponse) {
+    const client = getAnthropicClient();
+    const stepsText = recentSteps.slice(0, 5).map(s => {
+        let desc = `- ${s.action_type}`;
+        if (s.files.length > 0) {
+            desc += `: ${s.files.slice(0, 3).join(', ')}`;
+        }
+        return desc;
+    }).join('\n') || 'None';
+    // Check if we need to compress reasoning
+    const needsCompression = assistantResponse.length > 1000;
+    const compressionInstruction = needsCompression
+        ? `\n  "step_reasoning": "compressed summary of assistant's actions and reasoning (max 800 chars)"`
+        : '';
+    const compressionRule = needsCompression
+        ? '\n- step_reasoning: Summarize what the assistant did and WHY in a concise way (max 800 chars)'
+        : '';
+    // Extract topic keywords from goal for comparison
+    const currentGoalKeywords = currentSession?.original_goal
+        ? currentSession.original_goal.toLowerCase().match(/\b\w{4,}\b/g)?.slice(0, 10).join(', ') || ''
+        : '';
+    const prompt = `You are a task orchestrator. Your PRIMARY job is to detect when the user starts a NEW, DIFFERENT task.
+
+CURRENT SESSION:
+- Current Goal: "${currentSession?.original_goal || 'No active task'}"
+- Goal Keywords: [${currentGoalKeywords}]
+
+LATEST USER MESSAGE:
+"${latestUserMessage.substring(0, 500)}"
+
+RECENT ACTIONS (last 5):
+${stepsText}
+
+ASSISTANT RESPONSE (truncated):
+"${assistantResponse.substring(0, 1500)}${assistantResponse.length > 1500 ? '...' : ''}"
+
+═══════════════════════════════════════════════════════════════
+CRITICAL: Compare the TOPIC of "Current Goal" vs "Latest User Message"
+═══════════════════════════════════════════════════════════════
+
+Ask yourself:
+1. Is the user message about the SAME subject/feature/file as the current goal?
+2. Or is it about something COMPLETELY DIFFERENT?
+
+EXAMPLES of NEW_TASK (different topic):
+- Goal: "implement authentication" → User: "fix the database migration" → NEW_TASK
+- Goal: "analyze security layer" → User: "create hello.ts script" → NEW_TASK
+- Goal: "refactor user service" → User: "add dark mode to UI" → NEW_TASK
+- Goal: "fix login bug" → User: "write unit tests for payments" → NEW_TASK
+
+EXAMPLES of CONTINUE (same topic):
+- Goal: "implement authentication" → User: "now add the logout button" → CONTINUE
+- Goal: "fix login bug" → User: "also check the session timeout" → CONTINUE
+- Goal: "analyze security" → User: "what about rate limiting?" → CONTINUE
+
+Return JSON:
 {
-  "goal": "The main objective the user wants to achieve (1 sentence)",
-  "expected_scope": ["List of files, directories, or components that should be touched"],
-  "constraints": ["Any constraints or requirements mentioned"],
-  "success_criteria": ["How to know when the task is complete"],
-  "keywords": ["Important technical terms from the prompt"]
+  "action": "continue|new_task|subtask|parallel_task|task_complete|subtask_complete",
+  "topic_match": "YES if same topic, NO if different topic",
+  "task_id": "existing session_id or 'NEW' for new task",
+  "current_goal": "the goal based on LATEST user message",
+  "reasoning": "1 sentence explaining topic comparison"${compressionInstruction}
 }
 
-Return ONLY valid JSON.`
-            }
-        ]
+DECISION RULES:
+1. NO current session → "new_task"
+2. topic_match=NO (different subject) → "new_task"
+3. topic_match=YES + user following up → "continue"
+4. Claude said "done/complete/finished" → "task_complete"
+5. Prerequisite work identified → "subtask"${compressionRule}
+
+RESPONSE RULES:
+- English only (translate if input is in other language)
+- No emojis
+- Valid JSON only`;
+    debugLLM('analyzeTaskContext', `Calling Haiku for task analysis (needsCompression=${needsCompression})`);
+    const response = await client.messages.create({
+        model: 'claude-haiku-4-5-20251001',
+        max_tokens: needsCompression ? 600 : 300,
+        messages: [{ role: 'user', content: prompt }],
     });
-    // Extract text content from response
-    const content = response.content[0];
-    if (content.type !== 'text') {
-        throw new Error('Unexpected response type from Anthropic');
+    const text = response.content[0].type === 'text' ? response.content[0].text : '';
+    try {
+        // Try to parse JSON from response (may have extra text)
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            throw new Error('No JSON found in response');
+        }
+        const analysis = JSON.parse(jsonMatch[0]);
+        // If we didn't need compression but have short response, use it directly
+        if (!needsCompression && assistantResponse.length > 0) {
+            analysis.step_reasoning = assistantResponse.substring(0, 1000);
+        }
+        debugLLM('analyzeTaskContext', `Result: action=${analysis.action}, topic_match=${analysis.topic_match}, goal=${analysis.current_goal.substring(0, 50)}`);
+        return analysis;
+    }
+    catch (parseError) {
+        debugLLM('analyzeTaskContext', `Parse error: ${String(parseError)}, using fallback`);
+        // Fallback: continue existing session or create new
+        return {
+            action: currentSession ? 'continue' : 'new_task',
+            task_id: currentSession?.session_id || 'NEW',
+            current_goal: latestUserMessage.substring(0, 200),
+            reasoning: 'Fallback due to parse error',
+            step_reasoning: assistantResponse.substring(0, 1000),
+        };
     }
-    const parsed = JSON.parse(content.text);
-    return {
-        goal: parsed.goal || prompt.substring(0, 100),
-        expected_scope: parsed.expected_scope || [],
-        constraints: parsed.constraints || [],
-        success_criteria: parsed.success_criteria || [],
-        keywords: parsed.keywords || extractKeywordsBasic(prompt)
-    };
 }
 /**
- * Basic intent extraction without LLM
+ * Check if reasoning extraction is available
  */
-function extractIntentBasic(prompt) {
-    return {
-        goal: prompt.substring(0, 200),
-        expected_scope: extractFilesFromPrompt(prompt),
-        constraints: [],
-        success_criteria: [],
-        keywords: extractKeywordsBasic(prompt)
-    };
+export function isReasoningExtractionAvailable() {
+    return !!process.env.ANTHROPIC_API_KEY || !!process.env.GROV_API_KEY;
 }
 /**
- * Extract file paths from prompt text
+ * Extract reasoning trace and decisions from steps
+ * Called at task_complete to populate team memory with rich context
  */
-function extractFilesFromPrompt(prompt) {
-    const patterns = [
-        /(?:^|\s)(\/[\w\-\.\/]+\.\w+)/g,
-        /(?:^|\s)(\.\/[\w\-\.\/]+\.\w+)/g,
-        /(?:^|\s)([\w\-]+\/[\w\-\.\/]+\.\w+)/g,
-        /(?:^|\s|['"`])([\w\-]+\.\w{1,5})(?:\s|$|,|:|['"`])/g,
-    ];
-    const files = new Set();
-    for (const pattern of patterns) {
-        const matches = prompt.matchAll(pattern);
-        for (const match of matches) {
-            const file = match[1].trim();
-            if (file && !file.match(/^(http|https|ftp|mailto)/) && !file.match(/^\d+\.\d+/)) {
-                files.add(file);
-            }
-        }
+export async function extractReasoningAndDecisions(stepsReasoning, originalGoal) {
+    const client = getAnthropicClient();
+    // Combine all steps reasoning into one text
+    const combinedReasoning = stepsReasoning
+        .filter(r => r && r.length > 10)
+        .join('\n\n---\n\n')
+        .substring(0, 8000);
+    if (combinedReasoning.length < 50) {
+        return { reasoning_trace: [], decisions: [] };
     }
-    return [...files];
+    const prompt = `Analyze Claude's work session and extract structured reasoning and decisions.
+
+ORIGINAL GOAL:
+${originalGoal || 'Not specified'}
+
+CLAUDE'S WORK (reasoning from each step):
+${combinedReasoning}
+
+═══════════════════════════════════════════════════════════════
+EXTRACT TWO THINGS:
+═══════════════════════════════════════════════════════════════
+
+1. REASONING TRACE (what was done and WHY):
+   - Each entry: "[ACTION] [target] because/to [reason]"
+   - Include specific file names, function names when mentioned
+   - Focus on WHY decisions were made, not just what
+   - Max 10 entries, most important first
+
+2. DECISIONS (choices made between alternatives):
+   - Only include actual choices/tradeoffs
+   - Each must have: what was chosen, why it was chosen
+   - Examples: "Chose X over Y because Z"
+   - Max 5 decisions
+
+Return JSON:
+{
+  "reasoning_trace": [
+    "Created auth/token-store.ts to separate storage logic from validation",
+    "Used Map instead of Object for O(1) lookup performance",
+    "Added expiry check in validateToken to prevent stale token usage"
+  ],
+  "decisions": [
+    {"choice": "Used SHA256 for token hashing", "reason": "Fast, secure enough for this use case, no external deps"},
+    {"choice": "Split into separate files", "reason": "Better testability and single responsibility"}
+  ]
 }
-/**
- * Extract keywords from prompt (basic)
- */
-function extractKeywordsBasic(prompt) {
-    const stopWords = new Set([
-        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
-        'to', 'for', 'and', 'or', 'in', 'on', 'at', 'of', 'with',
-        'this', 'that', 'it', 'i', 'you', 'we', 'they', 'my', 'your',
-        'can', 'could', 'would', 'should', 'will', 'do', 'does', 'did',
-        'have', 'has', 'had', 'not', 'but', 'if', 'then', 'when', 'where',
-        'how', 'what', 'why', 'which', 'who', 'all', 'some', 'any', 'no',
-        'from', 'by', 'as', 'so', 'too', 'also', 'just', 'only', 'now',
-        'please', 'help', 'me', 'make', 'get', 'add', 'fix', 'update', 'change'
-    ]);
-    const words = prompt.toLowerCase()
-        .replace(/[^\w\s]/g, ' ')
-        .split(/\s+/)
-        .filter(w => w.length > 2 && !stopWords.has(w));
-    return [...new Set(words)].slice(0, 15);
+
+RESPONSE RULES:
+- English only
+- No emojis
+- Valid JSON only
+- Be specific, not vague (bad: "Fixed bug", good: "Fixed null check in validateToken")`;
+    debugLLM('extractReasoningAndDecisions', `Analyzing ${stepsReasoning.length} steps, ${combinedReasoning.length} chars`);
+    try {
+        const response = await client.messages.create({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 800,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const text = response.content[0].type === 'text' ? response.content[0].text : '';
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            debugLLM('extractReasoningAndDecisions', 'No JSON found in response');
+            return { reasoning_trace: [], decisions: [] };
+        }
+        const result = JSON.parse(jsonMatch[0]);
+        debugLLM('extractReasoningAndDecisions', `Extracted ${result.reasoning_trace?.length || 0} traces, ${result.decisions?.length || 0} decisions`);
+        return {
+            reasoning_trace: result.reasoning_trace || [],
+            decisions: result.decisions || [],
+        };
+    }
+    catch (error) {
+        debugLLM('extractReasoningAndDecisions', `Error: ${String(error)}`);
+        return { reasoning_trace: [], decisions: [] };
+    }
 }