grov 0.2.2 → 0.2.3

package/README.md

@@ -35,9 +35,15 @@ Every time you start a new Claude Code session:
 
 Grov captures what Claude learns and injects it back on the next session.
 
-**With grov:** Same task takes ~1-2 minutes, <2% tokens, 0 explore agents. Claude reads files directly because it already has context.
+![grov status](docs/grov-status.jpeg)
 
-<sub>*Based on controlled testing: Auth file modification task without grov launched 3+ subagents and read ~10 files for exploration. With grov (after initial memory capture), an adjacent task went directly to reading relevant files with full context.</sub>
+### What Gets Captured
+
+Real reasoning, not just file lists:
+
+![captured reasoning](docs/reasoning-output.jpeg)
+
+*Architectural decisions, patterns, and rationale - automatically extracted.*
 
 ## Quick Start
 

package/dist/lib/llm-extractor.js

@@ -544,10 +544,10 @@ export async function analyzeTaskContext(currentSession, latestUserMessage, rece
     // 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)"`
+        ? `\n  "step_reasoning": "Extract CONCLUSIONS and SPECIFIC RECOMMENDATIONS only. Include: exact file paths (e.g., src/lib/utils.ts), function/component names, architectural patterns discovered, and WHY decisions were made. DO NOT write process descriptions like 'explored' or 'analyzed'. Max 800 chars."`
         : '';
     const compressionRule = needsCompression
-        ? '\n- step_reasoning: Summarize what the assistant did and WHY in a concise way (max 800 chars)'
+        ? '\n- step_reasoning: Extract CONCLUSIONS (specific files, patterns, decisions) NOT process descriptions. Example GOOD: "Utilities belong in src/lib/utils.ts alongside cn(), formatDate()". Example BAD: "Explored codebase structure".'
         : '';
     // Extract topic keywords from goal for comparison
     const currentGoalKeywords = currentSession?.original_goal
@@ -660,40 +660,51 @@ export async function extractReasoningAndDecisions(stepsReasoning, originalGoal)
     if (combinedReasoning.length < 50) {
         return { reasoning_trace: [], decisions: [] };
     }
-    const prompt = `Analyze Claude's work session and extract structured reasoning and decisions.
+    const prompt = `Extract CONCLUSIONS and KNOWLEDGE from Claude's work - NOT process descriptions.
 
 ORIGINAL GOAL:
 ${originalGoal || 'Not specified'}
 
-CLAUDE'S WORK (reasoning from each step):
+CLAUDE'S RESPONSE:
 ${combinedReasoning}
 
 ═══════════════════════════════════════════════════════════════
-EXTRACT TWO THINGS:
+EXTRACT ACTIONABLE CONCLUSIONS - NOT PROCESS
 ═══════════════════════════════════════════════════════════════
 
-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"
+GOOD examples (specific, reusable knowledge):
+- "Utility functions belong in frontend/lib/utils.ts - existing utils: cn(), formatDate(), debounce()"
+- "Auth tokens stored in localStorage with 15min expiry for long form sessions"
+- "API routes follow REST pattern in /api/v1/ with Zod validation"
+- "Database migrations go in prisma/migrations/ using prisma migrate"
+
+BAD examples (process descriptions - DO NOT EXTRACT THESE):
+- "Explored the codebase structure"
+- "Analyzed several approaches"
+- "Searched for utility directories"
+- "Looked at the file organization"
+
+1. REASONING TRACE (conclusions and recommendations):
+   - WHAT was discovered or decided (specific file paths, patterns)
+   - WHY this is the right approach
+   - WHERE this applies in the codebase
+   - Max 10 entries, prioritize specific file/function recommendations
+
+2. DECISIONS (architectural choices):
+   - Only significant choices that affect future work
+   - What was chosen and why
    - 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"
+    "Utility functions belong in frontend/lib/utils.ts alongside cn(), formatDate(), debounce(), generateId()",
+    "Backend utilities go in backend/app/utils/ with domain-specific files like validation.py",
+    "The @/lib/utils import alias is configured for frontend utility access"
   ],
   "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"}
+    {"choice": "Add to existing utils.ts rather than new file", "reason": "Maintains established pattern, easier discoverability"},
+    {"choice": "Use frontend/lib/ over src/utils/", "reason": "Follows Next.js conventions used throughout project"}
   ]
 }
 
@@ -701,7 +712,8 @@ RESPONSE RULES:
 - English only
 - No emojis
 - Valid JSON only
-- Be specific, not vague (bad: "Fixed bug", good: "Fixed null check in validateToken")`;
+- Extract WHAT and WHERE, not just WHAT was done
+- If no specific conclusions found, return empty arrays`;
     debugLLM('extractReasoningAndDecisions', `Analyzing ${stepsReasoning.length} steps, ${combinedReasoning.length} chars`);
     try {
         const response = await client.messages.create({

package/dist/proxy/request-processor.d.ts

@@ -4,7 +4,7 @@
  */
 export declare function buildTeamMemoryContext(projectPath: string, mentionedFiles: string[]): string | null;
 /**
- * Extract file paths from messages
+ * Extract file paths from messages (user messages only, clean text)
  */
 export declare function extractFilesFromMessages(messages: Array<{
     role: string;

package/dist/proxy/request-processor.js

@@ -32,7 +32,10 @@ export function buildTeamMemoryContext(projectPath, mentionedFiles) {
  */
 function formatTeamMemoryContext(tasks, fileReasonings, files) {
     const lines = [];
-    lines.push('[GROV CONTEXT - Relevant past reasoning]');
+    lines.push('=== VERIFIED TEAM KNOWLEDGE (from previous sessions) ===');
+    lines.push('');
+    lines.push('IMPORTANT: This context has been verified. USE IT to answer directly.');
+    lines.push('DO NOT launch Explore agents or re-investigate files mentioned below.');
     lines.push('');
     // File-level context
     if (fileReasonings.length > 0) {
@@ -67,21 +70,44 @@ function formatTeamMemoryContext(tasks, fileReasonings, files) {
         lines.push('');
     }
     if (files.length > 0) {
-        lines.push(`You may already have context for: ${files.join(', ')}`);
+        lines.push(`Files with existing context: ${files.join(', ')}`);
     }
-    lines.push('[END GROV CONTEXT]');
+    lines.push('');
+    lines.push('Answer the user\'s question using the knowledge above. Skip exploration.');
+    lines.push('=== END VERIFIED TEAM KNOWLEDGE ===');
     return lines.join('\n');
 }
 /**
- * Extract file paths from messages
+ * Extract file paths from messages (user messages only, clean text)
  */
 export function extractFilesFromMessages(messages) {
     const files = [];
-    const filePattern = /(?:^|\s|["'`])([\/\w.-]+\.[a-zA-Z]{1,10})(?:["'`]|\s|$|:|\))/g;
+    // Pattern matches filenames with extensions, allowing common punctuation after
+    const filePattern = /(?:^|\s|["'`])([\/\w.-]+\.[a-zA-Z]{1,10})(?:["'`]|\s|$|[:)\]?!,;])/g;
     for (const msg of messages) {
+        // Only scan user messages for file mentions
+        if (msg.role !== 'user')
+            continue;
+        let textContent = '';
+        // Handle string content
         if (typeof msg.content === 'string') {
+            textContent = msg.content;
+        }
+        // Handle array content (Claude Code API format)
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block && typeof block === 'object' && 'type' in block && block.type === 'text' && 'text' in block && typeof block.text === 'string') {
+                    textContent += block.text + '\n';
+                }
+            }
+        }
+        // Strip system-reminder tags to get clean user content
+        const cleanContent = textContent
+            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            .trim();
+        if (cleanContent) {
             let match;
-            while ((match = filePattern.exec(msg.content)) !== null) {
+            while ((match = filePattern.exec(cleanContent)) !== null) {
                 const path = match[1];
                 // Filter out common false positives
                 if (!path.includes('http') && !path.startsWith('.') && path.length > 3) {

package/dist/proxy/response-processor.js

@@ -24,8 +24,18 @@ export async function saveToTeamMemory(sessionId, triggerReason) {
  * Build task data from session state and steps
  */
 async function buildTaskFromSession(sessionState, steps, triggerReason) {
-    // Aggregate files from steps
-    const filesTouched = [...new Set(steps.flatMap(s => s.files))];
+    // Aggregate files from steps (tool_use actions)
+    const stepFiles = steps.flatMap(s => s.files);
+    // Also extract file paths mentioned in reasoning text (Claude's text responses)
+    const reasoningFiles = steps
+        .filter(s => s.reasoning)
+        .flatMap(s => {
+        // Match common code file extensions
+        const matches = s.reasoning?.match(/[\w\/.-]+\.(ts|js|tsx|jsx|py|go|rs|java|css|html|md|json|yaml|yml)/g) || [];
+        // Filter out obvious non-paths (urls, version numbers)
+        return matches.filter(m => !m.includes('://') && !m.match(/^\d+\.\d+/));
+    });
+    const filesTouched = [...new Set([...stepFiles, ...reasoningFiles])];
     // Build basic reasoning trace from steps (fallback)
     const basicReasoningTrace = steps
         .filter(s => s.is_key_decision || s.action_type === 'edit' || s.action_type === 'write')

package/dist/proxy/server.js

@@ -51,9 +51,7 @@ const activeSessions = new Map();
  */
 export function createServer() {
     const fastify = Fastify({
-        logger: {
-            level: 'error', // Only errors in console, details in file
-        },
+        logger: false, // Disabled - all debug goes to ~/.grov/debug.log
         bodyLimit: config.BODY_LIMIT,
     });
     // Health check endpoint
@@ -227,9 +225,16 @@ async function getOrCreateSession(request, logger) {
  */
 async function preProcessRequest(body, sessionInfo, logger) {
     const modified = { ...body };
+    // FIRST: Always inject team memory context (doesn't require sessionState)
+    const mentionedFiles = extractFilesFromMessages(modified.messages || []);
+    const teamContext = buildTeamMemoryContext(sessionInfo.projectPath, mentionedFiles);
+    if (teamContext) {
+        appendToSystemPrompt(modified, '\n\n' + teamContext);
+    }
+    // THEN: Session-specific operations
     const sessionState = getSessionState(sessionInfo.sessionId);
     if (!sessionState) {
-        return modified;
+        return modified; // Injection already happened above!
     }
     // Extract latest user message for drift checking
     const latestUserMessage = extractGoalFromMessages(body.messages) || '';
@@ -298,18 +303,8 @@ Please continue from where you left off.`;
             }
         }
     }
-    // Inject context from team memory
-    const mentionedFiles = extractFilesFromMessages(modified.messages || []);
-    const teamContext = buildTeamMemoryContext(sessionInfo.projectPath, mentionedFiles);
-    if (teamContext) {
-        appendToSystemPrompt(modified, '\n\n' + teamContext);
-        logger.info({
-            msg: 'Injected team memory context',
-            filesMatched: mentionedFiles.length,
-        });
-    }
-    // Log final system prompt size
-    const finalSystemSize = getSystemPromptText(modified).length;
+    // Note: Team memory context injection is now at the TOP of preProcessRequest()
+    // so it runs even when sessionState is null (new sessions)
     return modified;
 }
 /**
@@ -820,36 +815,34 @@ function extractProjectPath(body) {
     return null;
 }
 /**
- * Extract goal from LATEST user message (not first!)
- * Filters out system-reminder tags to get the actual user prompt
+ * Extract goal from FIRST user message with text content
+ * Skips tool_result blocks, filters out system-reminder tags
  */
 function extractGoalFromMessages(messages) {
-    // Find the LAST user message (most recent prompt)
     const userMessages = messages?.filter(m => m.role === 'user') || [];
-    const lastUser = userMessages[userMessages.length - 1];
-    if (!lastUser)
-        return undefined;
-    let rawContent = '';
-    // Handle string content
-    if (typeof lastUser.content === 'string') {
-        rawContent = lastUser.content;
-    }
-    // Handle array content (new API format)
-    if (Array.isArray(lastUser.content)) {
-        const textBlocks = lastUser.content
-            .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
-            .map(block => block.text);
-        rawContent = textBlocks.join('\n');
-    }
-    // Remove <system-reminder>...</system-reminder> tags
-    const cleanContent = rawContent
-        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
-        .trim();
-    // If nothing left after removing reminders, return undefined
-    if (!cleanContent || cleanContent.length < 5) {
-        return undefined;
-    }
-    return cleanContent.substring(0, 500);
+    for (const userMsg of userMessages) {
+        let rawContent = '';
+        // Handle string content
+        if (typeof userMsg.content === 'string') {
+            rawContent = userMsg.content;
+        }
+        // Handle array content - look for text blocks (skip tool_result)
+        if (Array.isArray(userMsg.content)) {
+            const textBlocks = userMsg.content
+                .filter((block) => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string')
+                .map(block => block.text);
+            rawContent = textBlocks.join('\n');
+        }
+        // Remove <system-reminder>...</system-reminder> tags
+        const cleanContent = rawContent
+            .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            .trim();
+        // If we found valid text content, return it
+        if (cleanContent && cleanContent.length >= 5) {
+            return cleanContent.substring(0, 500);
+        }
+    }
+    return undefined;
 }
 /**
  * Filter response headers for forwarding to client

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grov",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Collective AI memory for Claude Code - captures reasoning from sessions and injects context into future sessions",
   "type": "module",
   "main": "dist/cli.js",