grov 0.5.11 → 0.6.13

package/dist/{lib → core/extraction}/llm-extractor.js

@@ -1,174 +1,50 @@
 // LLM-based extraction using Anthropic Claude Haiku for drift detection
-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';
-// 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 anthropicClient = null;
-/**
- * Initialize the Anthropic client
- */
-function getAnthropicClient() {
-    if (!anthropicClient) {
-        const apiKey = process.env.ANTHROPIC_API_KEY;
-        if (!apiKey) {
-            throw new Error('ANTHROPIC_API_KEY environment variable is required for drift detection');
-        }
-        anthropicClient = new Anthropic({ apiKey });
-    }
-    return anthropicClient;
-}
-/**
- * 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);
-    }
+import { debugLLM } from '../../utils/debug.js';
+import { forwardToAnthropic } from '../../integrations/proxy/agents/claude/forwarder.js';
+import { buildSafeHeaders } from '../../integrations/proxy/config.js';
+import { isDebugMode } from '../../integrations/proxy/utils/logging.js';
+// Haiku model constant
+// Model list: https://docs.anthropic.com/en/docs/about-claude/models
+const HAIKU_MODEL = 'claude-haiku-4-5-20251001';
+async function callHaiku(maxTokens, prompt, headers, context = 'unknown') {
+    if (isDebugMode())
+        console.log(`[HAIKU] ${context} started`);
+    // Use same header filtering as proxy forward - includes all Claude Code headers
+    const safeHeaders = buildSafeHeaders(headers);
     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": "A single, high-density sentence describing the technical intent. RULES: 1. No bullet points, no newlines. 2. Must include the main Technology Name (e.g. 'Prometheus', 'React', 'AWS') if inferred. 3. If the user provided a list, synthesize it into one summary statement. Example: 'Implement Prometheus metrics collection with counter and gauge primitives' instead of 'Add metrics: - counters - gauges'.",
-  "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,
+        const result = await forwardToAnthropic({
+            model: HAIKU_MODEL,
+            max_tokens: maxTokens,
             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 : '', // Don't fallback to prompt
-                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);
+        }, safeHeaders);
+        // Check for error response
+        if (result.statusCode >= 400) {
+            const errorBody = result.body;
+            throw new Error(errorBody.error?.message || `HTTP ${result.statusCode}`);
         }
+        // Parse response
+        const body = result.body;
+        const text = body.content?.[0]?.type === 'text' ? body.content[0].text || '' : '';
+        if (isDebugMode())
+            console.log(`[HAIKU] ${context} success`);
+        return { text, success: true };
     }
-    catch {
-        // Outer catch - API errors, network issues, etc.
-        return createFallbackIntent(firstPrompt);
+    catch (err) {
+        // Always log errors
+        console.error(`[HAIKU] ${context} error:`, err.message);
+        return { text: '', success: false };
     }
 }
-/**
- * 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: '', // Empty - don't copy user prompt as goal; goal should be synthesized only
-        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);
-}
 // ============================================
 // SESSION SUMMARY FOR CLEAR OPERATION
 // Reference: plan_proxy_local.md Section 2.3, 4.5
 // ============================================
-/**
- * Check if session summary generation is available
- */
-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, maxTokens = 800 // Default 800, CLEAR mode uses 15000
-) {
-    const client = getAnthropicClient();
+export async function generateSessionSummary(sessionState, steps, maxTokens = 800, // Default 800, CLEAR mode uses 15000
+headers) {
     // For larger summaries, include more steps
     const stepLimit = maxTokens > 5000 ? 50 : 20;
     const wordLimit = Math.min(Math.floor(maxTokens / 2), 10000); // ~2 tokens per word
@@ -193,8 +69,6 @@ export async function generateSessionSummary(sessionState, steps, maxTokens = 80
 
 ORIGINAL GOAL: ${sessionState.original_goal || 'Not specified'}
 
-EXPECTED SCOPE: ${sessionState.expected_scope.join(', ') || 'Not specified'}
-
 CONSTRAINTS: ${sessionState.constraints.join(', ') || 'None'}
 
 ACTIONS TAKEN:
@@ -210,18 +84,13 @@ Create a summary with these sections (keep total under ${wordLimit} words):
 ${maxTokens > 5000 ? '7. IMPORTANT CONTEXT: (any critical information that must not be lost)' : ''}
 
 Format as plain text, not JSON.`;
-    const response = await client.messages.create({
-        model: 'claude-haiku-4-5-20251001',
-        max_tokens: maxTokens,
-        messages: [{ role: 'user', content: prompt }],
-    });
-    const content = response.content?.[0];
-    if (!content || content.type !== 'text') {
+    const haikuResult = await callHaiku(maxTokens, prompt, headers, 'generateSessionSummary');
+    if (!haikuResult.success || !haikuResult.text) {
         return createFallbackSummary(sessionState, steps);
     }
     return `PREVIOUS SESSION CONTEXT (auto-generated after context limit):
 
-${content.text}`;
+${haikuResult.text}`;
 }
 /**
  * Create fallback summary without LLM
@@ -239,12 +108,6 @@ ${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);
-}
 /**
  * Format conversation messages for prompt
  */
@@ -280,8 +143,7 @@ function formatToolCalls(steps) {
  * 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, conversationHistory) {
-    const client = getAnthropicClient();
+export async function analyzeTaskContext(currentSession, latestUserMessage, recentSteps, assistantResponse, conversationHistory, headers) {
     // Check if we need to compress reasoning
     const needsCompression = assistantResponse.length > 1000;
     const compressionInstruction = needsCompression
@@ -309,10 +171,13 @@ ${toolCallsText}
 <output>
 Return a JSON object with these fields:
 - task_type: one of "information", "planning", or "implementation"
-- action: one of "continue", "task_complete", "new_task", or "subtask_complete"
+- action: one of "continue", "task_complete", "new_task", "subtask", "parallel_task", or "subtask_complete"
 - task_id: existing session_id "${currentSession?.session_id || 'NEW'}" or "NEW" for new task
 - current_goal: "SYNTHESIZE a concise goal (max 150 chars). RULES: 1. If original_goal is empty, SYNTHESIZE from user messages. 2. DO NOT copy the user's request verbatim - summarize it. 3. Start with Technology/Component name. 4. One sentence, no newlines. Example: 'TypeScript Logger with level filtering and JSON output' NOT 'Create a structured logger in /home/... with debug, info...'"
 - reasoning: brief explanation of why you made this decision${compressionInstruction}
+
+CONDITIONAL FIELD (only include when action is "new_task", "subtask", or "parallel_task"):
+- constraints: array of explicit restrictions from user (see step_4_extract_constraints). If no restrictions found, use empty array [].
 </output>
 
 <step_1_identify_task_type>
@@ -471,6 +336,57 @@ Reason: The new task was requested AND completed. Use task_complete so it gets s
 The key insight: task_complete saves the memory. If you return new_task, the work won't be saved until a FUTURE completion. If Claude already finished the work, use task_complete.
 </step_3_detect_new_task>
 
+<step_4_extract_constraints>
+ONLY perform this step if action is "new_task", "subtask", or "parallel_task".
+If action is "continue" or "task_complete", skip this and set constraints to empty array [].
+
+WHAT IS A CONSTRAINT?
+A constraint is an EXPLICIT restriction the user stated about HOW to do the task.
+It is NOT the task itself - it is a LIMIT on how the task should be done.
+
+TWO TYPES:
+
+1. NEGATIVE CONSTRAINTS - Things Claude must NOT do:
+   Pattern: "don't", "do not", "never", "no", "without", "except", "avoid"
+
+   Examples:
+   - "Don't modify files outside src/" becomes "DO NOT modify files outside src/"
+   - "No external dependencies" becomes "DO NOT add external dependencies"
+   - "Just plan, don't code yet" becomes "DO NOT write code"
+
+2. POSITIVE CONSTRAINTS - Things Claude MUST do or ONLY do:
+   Pattern: "only", "must", "always", "keep", "use only"
+
+   Examples:
+   - "Only modify the auth module" becomes "ONLY modify auth module"
+   - "Must use TypeScript" becomes "MUST use TypeScript"
+   - "Keep backward compatible" becomes "MUST keep backward compatible"
+
+WHAT IS NOT A CONSTRAINT:
+- The task itself: "Fix the bug" is the goal, not a constraint
+- General preferences: "Make it fast" is too vague, not an explicit restriction
+- Questions: "Should I use Redis?" is not a restriction
+
+OUTPUT FORMAT:
+- Start each constraint with "DO NOT", "ONLY", or "MUST"
+- Be specific and actionable
+- If no constraints found, return empty array []
+
+EXAMPLES:
+
+User message: "Fix the auth bug. Don't touch the database code."
+constraints: ["DO NOT modify database code"]
+
+User message: "Add caching. Only use Redis, must be async."
+constraints: ["ONLY use Redis", "MUST be async"]
+
+User message: "Explain how auth works"
+constraints: []
+
+User message: "Implement feature X"
+constraints: []
+</step_4_extract_constraints>
+
 <important_notes>
 Do not rely on specific keywords in any language. The same intent can be expressed many different ways across languages and phrasings. Always understand the intent from the full context.
 
@@ -490,12 +406,21 @@ RESPONSE RULES:
 - No markdown formatting, no emojis
 </important_notes>`;
     debugLLM('analyzeTaskContext', `Calling Haiku for task analysis (needsCompression=${needsCompression})`);
-    const response = await client.messages.create({
-        model: 'claude-haiku-4-5-20251001',
-        max_tokens: needsCompression ? 800 : 400,
-        messages: [{ role: 'user', content: prompt }],
-    });
-    const text = response.content[0].type === 'text' ? response.content[0].text : '';
+    const haikuResult = await callHaiku(needsCompression ? 800 : 400, prompt, headers, 'analyzeTaskContext');
+    if (!haikuResult.success) {
+        // Fallback on error
+        const fallbackGoal = currentSession?.original_goal || '';
+        return {
+            task_type: 'implementation',
+            action: currentSession ? 'continue' : 'new_task',
+            task_id: currentSession?.session_id || 'NEW',
+            current_goal: fallbackGoal,
+            reasoning: 'Fallback due to Haiku error',
+            step_reasoning: assistantResponse.substring(0, 1000),
+            constraints: [],
+        };
+    }
+    const text = haikuResult.text;
     try {
         // Try to parse JSON from response (may have extra text)
         const jsonMatch = text.match(/\{[\s\S]*\}/);
@@ -511,7 +436,16 @@ RESPONSE RULES:
         if (!needsCompression && assistantResponse.length > 0) {
             analysis.step_reasoning = assistantResponse.substring(0, 1000);
         }
-        debugLLM('analyzeTaskContext', `Result: task_type=${analysis.task_type}, action=${analysis.action}, goal="${analysis.current_goal?.substring(0, 50) || 'N/A'}" reasoning="${analysis.reasoning?.substring(0, 150) || 'none'}"`);
+        // Parse constraints (only for new_task/subtask/parallel_task actions)
+        if (analysis.constraints) {
+            analysis.constraints = Array.isArray(analysis.constraints)
+                ? analysis.constraints.filter((c) => typeof c === 'string')
+                : [];
+        }
+        else {
+            analysis.constraints = [];
+        }
+        debugLLM('analyzeTaskContext', `Result: task_type=${analysis.task_type}, action=${analysis.action}, goal="${analysis.current_goal?.substring(0, 50) || 'N/A'}" constraints=${analysis.constraints.length} reasoning="${analysis.reasoning?.substring(0, 150) || 'none'}"`);
         return analysis;
     }
     catch (parseError) {
@@ -528,15 +462,10 @@ RESPONSE RULES:
             current_goal: fallbackGoal,
             reasoning: 'Fallback due to parse error',
             step_reasoning: assistantResponse.substring(0, 1000),
+            constraints: [],
         };
     }
 }
-/**
- * Check if reasoning extraction is available
- */
-export function isReasoningExtractionAvailable() {
-    return !!process.env.ANTHROPIC_API_KEY || !!process.env.GROV_API_KEY;
-}
 /**
  * Extract reasoning trace and decisions from steps
  * Called at task_complete to populate team memory with rich context
@@ -544,8 +473,7 @@ export function isReasoningExtractionAvailable() {
  * @param formattedSteps - Pre-formatted XML string with grouped steps and actions
  * @param originalGoal - The original task goal
  */
-export async function extractReasoningAndDecisions(formattedSteps, originalGoal) {
-    const client = getAnthropicClient();
+export async function extractReasoningAndDecisions(formattedSteps, originalGoal, headers) {
     if (formattedSteps.length < 50) {
         return { system_name: null, summary: null, reasoning_trace: [], decisions: [] };
     }
@@ -900,16 +828,14 @@ Before responding, verify:
 
 Return ONLY valid JSON, no markdown code blocks, no explanation.`;
     debugLLM('extractReasoningAndDecisions', `Analyzing formatted steps, ${formattedSteps.length} chars`);
+    const haikuResult = await callHaiku(1500, prompt, headers, 'extractReasoningAndDecisions');
+    if (!haikuResult.success) {
+        return { system_name: null, summary: null, reasoning_trace: [], decisions: [] };
+    }
     try {
-        const response = await client.messages.create({
-            model: 'claude-haiku-4-5-20251001',
-            max_tokens: 1500,
-            messages: [{ role: 'user', content: prompt }],
-        });
-        const text = response.content[0].type === 'text' ? response.content[0].text : '';
+        const text = haikuResult.text;
         const jsonMatch = text.match(/\{[\s\S]*\}/);
         if (!jsonMatch) {
-            console.error('[LLM-EXTRACTOR] No JSON in response');
             return { system_name: null, summary: null, reasoning_trace: [], decisions: [] };
         }
         // Try to parse JSON, with repair attempts for common Haiku formatting issues
@@ -938,13 +864,11 @@ Return ONLY valid JSON, no markdown code blocks, no explanation.`;
                         const extractedSystemName = systemMatch ? systemMatch[1] : undefined;
                         result = { system_name: extractedSystemName, knowledge_pairs: pairs, decisions: [] };
                     }
-                    catch (fallbackError) {
-                        console.error('[LLM-EXTRACTOR] JSON parse failed');
+                    catch {
                         throw parseError;
                     }
                 }
                 else {
-                    console.error('[LLM-EXTRACTOR] JSON parse failed');
                     throw parseError;
                 }
             }
@@ -984,12 +908,6 @@ Return ONLY valid JSON, no markdown code blocks, no explanation.`;
         return { system_name: null, summary: null, reasoning_trace: [], decisions: [] };
     }
 }
-/**
- * Check if shouldUpdateMemory is available
- */
-export function isShouldUpdateAvailable() {
-    return !!process.env.ANTHROPIC_API_KEY || !!process.env.GROV_API_KEY;
-}
 /**
  * Decide if a memory should be updated based on new session data
  * Called when a match is found before sync
@@ -1447,25 +1365,21 @@ Input: task_type=information, query="Ok I understand now", files_touched=[]
 Output: {"should_update": false, "reason": "User acknowledged explanation but did not confirm any change", "superseded_mapping": [], "condensed_old_reasoning": null, "evolution_summary": null}
 </examples>`;
 }
-export async function shouldUpdateMemory(existingMemory, newData, sessionContext) {
-    const client = getAnthropicClient();
+export async function shouldUpdateMemory(existingMemory, newData, sessionContext, headers) {
     // Check if evolution_steps consolidation is needed
     const evolutionCount = existingMemory.evolution_steps?.length || 0;
     const needsConsolidation = evolutionCount > 10;
     // Build the prompt with all context
     const prompt = buildShouldUpdatePrompt(existingMemory, newData, sessionContext, needsConsolidation, evolutionCount);
     debugLLM('shouldUpdateMemory', `Analyzing memory update (needsConsolidation=${needsConsolidation})`);
+    const haikuResult = await callHaiku(needsConsolidation ? 1500 : 800, prompt, headers, 'shouldUpdateMemory');
+    if (!haikuResult.success) {
+        return createFallbackResult(sessionContext);
+    }
     try {
-        const response = await client.messages.create({
-            model: 'claude-haiku-4-5-20251001',
-            max_tokens: needsConsolidation ? 1500 : 800,
-            messages: [{ role: 'user', content: prompt }],
-        });
-        const text = response.content[0].type === 'text' ? response.content[0].text : '';
-        // Try to parse JSON from response
+        const text = haikuResult.text;
         const jsonMatch = text.match(/\{[\s\S]*\}/);
         if (!jsonMatch) {
-            console.error('[HAIKU] No JSON in response');
             return createFallbackResult(sessionContext);
         }
         // Parse and validate response
@@ -1473,8 +1387,7 @@ export async function shouldUpdateMemory(existingMemory, newData, sessionContext
         try {
             result = JSON.parse(jsonMatch[0]);
         }
-        catch (parseErr) {
-            console.error('[HAIKU] JSON parse failed');
+        catch {
             return createFallbackResult(sessionContext);
         }
         // Ensure required fields have defaults
@@ -1487,8 +1400,7 @@ export async function shouldUpdateMemory(existingMemory, newData, sessionContext
         debugLLM('shouldUpdateMemory', `Result: should_update=${result.should_update}, reason="${result.reason.substring(0, 50)}"`);
         return result;
     }
-    catch (error) {
-        console.error('[HAIKU] Error:', String(error));
+    catch {
         return createFallbackResult(sessionContext);
     }
 }

package/dist/{lib → core}/store/sessions.js

@@ -11,9 +11,7 @@ function rowToSessionState(row) {
         project_path: row.project_path,
         original_goal: row.original_goal,
         raw_user_prompt: row.raw_user_prompt,
-        expected_scope: safeJsonParse(row.expected_scope, []),
         constraints: safeJsonParse(row.constraints, []),
-        keywords: safeJsonParse(row.keywords, []),
         escalation_count: row.escalation_count || 0,
         last_checked_at: row.last_checked_at || 0,
         start_time: row.start_time,
@@ -47,8 +45,6 @@ function rowToSessionState(row) {
  * Uses INSERT OR IGNORE to handle race conditions safely.
  */
 export function createSessionState(input) {
-    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-    // console.log(`[DEBUG-DB] createSessionState called with raw_user_prompt="${input.raw_user_prompt?.substring(0, 50)}"`);
     const database = getDb();
     const now = new Date().toISOString();
     const sessionState = {
@@ -58,9 +54,7 @@ export function createSessionState(input) {
         project_path: input.project_path,
         original_goal: input.original_goal,
         raw_user_prompt: input.raw_user_prompt,
-        expected_scope: input.expected_scope || [],
         constraints: input.constraints || [],
-        keywords: input.keywords || [],
         escalation_count: 0,
         last_checked_at: 0,
         start_time: now,
@@ -87,18 +81,16 @@ export function createSessionState(input) {
     const stmt = database.prepare(`
     INSERT OR IGNORE INTO session_states (
       session_id, user_id, project_path, original_goal, raw_user_prompt,
-      expected_scope, constraints, keywords,
+      constraints,
       token_count, escalation_count, session_mode,
       waiting_for_recovery, last_checked_at, last_clear_at,
       start_time, last_update, status,
       parent_session_id, task_type,
       success_criteria, last_drift_score, pending_recovery_plan, drift_history,
       completed_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
-    stmt.run(sessionState.session_id, sessionState.user_id || null, sessionState.project_path, sessionState.original_goal || null, sessionState.raw_user_prompt || null, JSON.stringify(sessionState.expected_scope), JSON.stringify(sessionState.constraints), JSON.stringify(sessionState.keywords), sessionState.token_count, sessionState.escalation_count, sessionState.session_mode, sessionState.waiting_for_recovery ? 1 : 0, sessionState.last_checked_at, sessionState.last_clear_at || null, sessionState.start_time, sessionState.last_update, sessionState.status, sessionState.parent_session_id || null, sessionState.task_type, JSON.stringify(sessionState.success_criteria || []), sessionState.last_drift_score || null, sessionState.pending_recovery_plan ? JSON.stringify(sessionState.pending_recovery_plan) : null, JSON.stringify(sessionState.drift_history || []), sessionState.completed_at || null);
-    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
-    // console.log(`[DEBUG-DB] INSERT done. sessionState.raw_user_prompt="${sessionState.raw_user_prompt?.substring(0, 50)}"`);
+    stmt.run(sessionState.session_id, sessionState.user_id || null, sessionState.project_path, sessionState.original_goal || null, sessionState.raw_user_prompt || null, JSON.stringify(sessionState.constraints), sessionState.token_count, sessionState.escalation_count, sessionState.session_mode, sessionState.waiting_for_recovery ? 1 : 0, sessionState.last_checked_at, sessionState.last_clear_at || null, sessionState.start_time, sessionState.last_update, sessionState.status, sessionState.parent_session_id || null, sessionState.task_type, JSON.stringify(sessionState.success_criteria || []), sessionState.last_drift_score || null, sessionState.pending_recovery_plan ? JSON.stringify(sessionState.pending_recovery_plan) : null, JSON.stringify(sessionState.drift_history || []), sessionState.completed_at || null);
     return sessionState;
 }
 /**
@@ -130,18 +122,10 @@ export function updateSessionState(sessionId, updates) {
         setClauses.push('original_goal = ?');
         params.push(updates.original_goal || null);
     }
-    if (updates.expected_scope !== undefined) {
-        setClauses.push('expected_scope = ?');
-        params.push(JSON.stringify(updates.expected_scope));
-    }
     if (updates.constraints !== undefined) {
         setClauses.push('constraints = ?');
         params.push(JSON.stringify(updates.constraints));
     }
-    if (updates.keywords !== undefined) {
-        setClauses.push('keywords = ?');
-        params.push(JSON.stringify(updates.keywords));
-    }
     if (updates.token_count !== undefined) {
         setClauses.push('token_count = ?');
         params.push(updates.token_count);

package/dist/core/store/store.d.ts

@@ -0,0 +1 @@
+export * from './index.js';

package/dist/{lib → core/store}/store.js

@@ -1,2 +1,2 @@
 // Re-export from modular store for backward compatibility
-export * from './store/index.js';
+export * from './index.js';

package/dist/{lib → core}/store/types.d.ts

@@ -72,9 +72,7 @@ interface SessionStateBase {
     project_path: string;
     original_goal?: string;
     raw_user_prompt?: string;
-    expected_scope: string[];
     constraints: string[];
-    keywords: string[];
     escalation_count: number;
     last_checked_at: number;
     start_time: string;
@@ -113,9 +111,7 @@ export interface CreateSessionStateInput {
     project_path: string;
     original_goal?: string;
     raw_user_prompt?: string;
-    expected_scope?: string[];
     constraints?: string[];
-    keywords?: string[];
     success_criteria?: string[];
     parent_session_id?: string;
     task_type?: TaskType;

package/dist/integrations/mcp/cache.d.ts

@@ -0,0 +1,27 @@
+import type { Memory } from '@grov/shared';
+/**
+ * Get current project path
+ * Used as cache key and for API filtering
+ *
+ * Cursor sets WORKSPACE_FOLDER_PATHS env var with the open workspace path.
+ * We extract just the folder name to match how proxy stores project_path.
+ */
+export declare function getProjectPath(): string;
+/**
+ * Store memories from preview call
+ * Indexes by 8-char ID prefix for fast lookup
+ */
+export declare function setPreviewCache(memories: Memory[]): void;
+/**
+ * Get memory by 8-char ID
+ * Handles both 8-char and full UUID (extracts first 8 chars)
+ */
+export declare function getMemoryById(id: string): Memory | null;
+/**
+ * Get list of cached IDs (for error messages)
+ */
+export declare function getCachedIds(): string[];
+/**
+ * Clear preview cache (e.g., when project changes)
+ */
+export declare function clearPreviewCache(): void;