grov 0.5.3 → 0.5.5

package/README.md

@@ -6,45 +6,60 @@
 
 <p align="center"><strong>Collective AI memory for engineering teams.</strong></p>
 
+<p align="center"><em>When one dev's Claude figures something out, every dev's Claude knows it.</em></p>
+
 <p align="center">
   <a href="https://www.npmjs.com/package/grov"><img src="https://img.shields.io/npm/v/grov" alt="npm version"></a>
   <a href="https://www.npmjs.com/package/grov"><img src="https://img.shields.io/npm/dm/grov" alt="npm downloads"></a>
   <a href="https://github.com/TonyStef/Grov/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-blue" alt="license"></a>
+  <a href="https://app.grov.dev"><img src="https://img.shields.io/badge/Dashboard-app.grov.dev-22c55e" alt="dashboard"></a>
 </p>
 
 <p align="center">
   <a href="https://grov.dev">Website</a> •
   <a href="https://app.grov.dev">Dashboard</a> •
   <a href="#quick-start">Quick Start</a> •
-  <a href="#team-sync">Team Sync</a> •
+  <a href="#features">Features</a> •
   <a href="#contributing">Contributing</a>
 </p>
 
-Grov captures reasoning from your Claude Code sessions and injects it into future sessions. Your AI remembers what it learned.
+---
 
 ## The Problem
 
-Every time you start a new Claude Code session:
-- Claude re-explores your codebase from scratch
-- It reads the same files again
-- It rediscovers patterns you've already established
-- You burn tokens on redundant exploration
-
-**Measured impact:** A typical task takes 10+ minutes, 7%+ token usage, and 3+ explore agents just to understand the codebase.*
+Your team's AI agents are learning in silos.
 
-## The Solution
+- Dev A's Claude spends 10 minutes understanding your auth system
+- Dev B's Claude does the exact same exploration the next day
+- Dev C asks a question that was already answered last week
+- Every new session starts from zero
 
-Grov captures what Claude learns and injects it back on the next session.
+**The waste:** Redundant exploration, duplicate token spend, knowledge that disappears when sessions end.
 
-![grov demo](demo-converted.gif)
+## The Solution
 
-### What Gets Captured
+Grov captures what your team's AI learns and shares it automatically.
 
-Real reasoning, not just file lists:
+```
+Dev A: "How does auth work in this codebase?"
+        ↓
+     Claude investigates, figures it out
+        ↓
+     Grov captures the reasoning + decisions
+        ↓
+     Syncs to team dashboard
+        ↓
+Dev B: "Should we add password salting?"
+        ↓
+     Claude already knows: "Based on verified team knowledge,
+     no - this codebase uses OAuth-only, no passwords stored"
+        ↓
+     No exploration needed. Instant expert answer.
+```
 
-![captured reasoning](docs/reasoning-output.jpeg)
+**Measured impact:** Tasks drop from 10+ minutes to 1-2 minutes when team context is available.
 
-*Architectural decisions, patterns, and rationale - automatically extracted.*
+---
 
 ## Quick Start
 
@@ -56,72 +71,60 @@ grov proxy            # Start (keep running)
 
 Then use Claude Code normally in another terminal. That's it.
 
-## How It Works
-
-```
-Session 1: Claude learns about your auth system
-           ↓
-        grov captures: "Auth tokens refresh in middleware/token.ts:45,
-                        using 15-min window to handle long forms"
-           ↓
-Session 2: User asks about related feature
-           ↓
-        grov injects: Previous context about auth
-           ↓
-        Claude skips exploration, reads files directly
+For team sync:
+```bash
+grov login                    # Authenticate via GitHub
+grov sync --enable --team ID  # Enable sync for your team
 ```
 
-## Commands
+**Free for individuals and teams up to 3 developers.**
 
-```bash
-grov init         # Configure proxy URL (one-time)
-grov proxy        # Start the proxy (required)
-grov proxy-status # Show active sessions
-grov status       # Show captured tasks
-grov login        # Login to cloud dashboard
-grov sync         # Sync memories to team dashboard
-grov disable      # Disable grov
-```
+---
 
-## Data Storage
+## What Gets Captured
 
-- **Database:** `~/.grov/memory.db` (SQLite)
-- **Per-project:** Context is filtered by project path
-- **Local by default:** Memories stay on your machine unless you enable team sync
+Real reasoning, not just file lists:
 
-## Team Sync
+![Dashboard showing captured reasoning](dashboard-showcase.jpeg)
 
-Share memories across your engineering team with the cloud dashboard.
+*Architectural decisions, patterns, and rationale - automatically extracted and synced to your team.*
 
-```bash
-grov login                    # Authenticate via GitHub
-grov sync --enable --team ID  # Enable sync for a team
-```
+Every captured memory includes:
+- **Reasoning trace** - The WHY behind decisions (CONCLUSION/INSIGHT pairs)
+- **Key decisions** - What was chosen and why alternatives were rejected
+- **Files touched** - Which parts of the codebase are relevant
+- **Constraints discovered** - What can't break, what must stay compatible
 
-Once enabled, memories automatically sync to [app.grov.dev](https://app.grov.dev) where your team can:
-- Browse all captured reasoning
-- Search across sessions
-- Invite team members
-- See who learned what
+---
 
-Memories sync automatically when sessions complete - no manual intervention needed.
+## What Your Team Gets
 
-## Requirements
+When a teammate asks a related question, Claude already knows:
 
-- Node.js 18+
-- Claude Code
+![Claude using team knowledge](cli-showcase.jpeg)
+
+*No exploration. No re-investigation. Instant expert answers from team memory.*
+
+Claude receives verified context and skips the exploration phase entirely - no "let me investigate" or "I'll need to look at the codebase."
 
 ---
 
-## Advanced Features
+## Features
 
-### Anti-Drift Detection
+### Team Knowledge Sharing
+The core value: what one dev's AI learns, everyone's AI knows.
 
-Grov monitors what Claude **does** (not what you ask) and corrects if it drifts from your goal.
+- **Automatic capture** - Reasoning extracted when tasks complete
+- **Automatic sync** - Memories sync to your team in real-time
+- **Automatic injection** - Relevant context injected into new sessions
+- **Hybrid search** - Semantic (AI understands meaning) + lexical (keyword matching)
+
+### Anti-Drift Detection
+Grov monitors what Claude **does** (not what you ask) and corrects when it goes off-track.
 
 - Extracts your intent from the first prompt
 - Monitors Claude's actions (file edits, commands, explorations)
-- Uses Claude Haiku to score alignment (1-10)
+- Scores alignment (1-10) using Claude Haiku
 - Injects corrections at 4 levels: nudge → correct → intervene → halt
 
 ```bash
@@ -129,25 +132,85 @@ Grov monitors what Claude **does** (not what you ask) and corrects if it drifts
 grov drift-test "refactor the auth system" --goal "fix login bug"
 ```
 
-### Extended Cache (Experimental)
-
-Anthropic's prompt cache expires after 5 minutes of inactivity. If you pause to think between prompts, the cache expires and must be recreated (costs more, takes longer).
+### Extended Cache
+Anthropic's prompt cache expires after 5 minutes of inactivity. Grov keeps it warm.
 
 ```bash
 grov proxy --extended-cache
 ```
 
-**What this does:** Sends minimal keep-alive requests (~$0.002 each) during idle periods to preserve your cache.
+- Sends minimal keep-alive requests (~$0.002 each) during idle periods
+- Saves ~$0.18 per idle period by avoiding cache recreation
+- Your next prompt is faster and cheaper
+
+**Opt-in only.** By using `--extended-cache`, you consent to Grov making API requests on your behalf.
+
+### Auto-Compaction
+When your context window fills up, Grov automatically compacts while preserving what matters.
+
+- Pre-computes summary at 85% capacity
+- Preserves: original goal, key decisions with reasoning, current state, next steps
+- Drops: verbose exploration, redundant file reads, superseded reasoning
+- Claude continues seamlessly without losing important context
+
+No manual `/compact` needed. No lost reasoning.
+
+---
+
+## Commands
+
+```bash
+grov init         # Configure proxy URL (one-time)
+grov proxy        # Start the proxy (required)
+grov proxy-status # Show active sessions
+grov status       # Show captured tasks
+grov login        # Login to cloud dashboard
+grov sync         # Sync memories to team dashboard
+grov disable      # Disable grov
+grov drift-test   # Test drift detection
+```
+
+---
 
-**Important:** By using `--extended-cache`, you consent to Grov making API requests on your behalf to keep the cache active. These requests:
-- Use your Anthropic API key
-- Are sent automatically during idle periods (every ~4 minutes)
-- Cost approximately $0.002 per keep-alive
-- Are discarded (not added to your conversation)
+## How It Works
 
-This feature is **disabled by default** and requires explicit opt-in.
+```
+┌─────────────────────────────────────────────────────────────┐
+│  Claude Code                                                │
+│       │                                                     │
+│       ▼                                                     │
+│  Grov Proxy (localhost:8080)                                │
+│       │                                                     │
+│       ├──► Inject team memory from past sessions            │
+│       ├──► Forward to Anthropic API                         │
+│       ├──► Monitor for drift, inject corrections            │
+│       ├──► Track context usage, auto-compact if needed      │
+│       └──► Capture reasoning when task completes            │
+│                    │                                        │
+│                    ▼                                        │
+│              Team Dashboard (app.grov.dev)                  │
+│                    │                                        │
+│                    ▼                                        │
+│              Available to entire team                       │
+└─────────────────────────────────────────────────────────────┘
+```
 
-### Environment Variables
+**Local by default:** Memories stay on your machine in `~/.grov/memory.db` (SQLite) unless you enable team sync.
+
+---
+
+## Dashboard
+
+Browse, search, and manage your team's AI knowledge at [app.grov.dev](https://app.grov.dev).
+
+- **Search across all sessions** - Hybrid semantic + keyword search
+- **Browse reasoning traces** - See the WHY behind every decision
+- **Team visibility** - See who learned what, when
+- **Invite teammates** - Share knowledge automatically
+
+---
+
+## Environment Variables
 
 ```bash
 # Required for drift detection and LLM extraction
@@ -159,45 +222,21 @@ export PROXY_HOST=127.0.0.1                        # Proxy host
 export PROXY_PORT=8080                             # Proxy port
 ```
 
-Without an API key, grov uses basic extraction and disables drift detection.
-
-### What Gets Stored
-
-```json
-{
-  "task": "Fix auth logout bug",
-  "goal": "Prevent random user logouts",
-  "files_touched": ["src/auth/session.ts", "src/middleware/token.ts"],
-  "reasoning_trace": [
-    "Investigated token refresh logic",
-    "Found refresh window was too short",
-    "Extended from 5min to 15min"
-  ],
-  "status": "complete"
-}
-```
+Without an API key, Grov uses basic extraction and disables drift detection.
 
-### What Gets Injected
+---
 
-```
-VERIFIED CONTEXT FROM PREVIOUS SESSIONS:
+## Requirements
 
-[Task: Fix auth logout bug]
-- Files: session.ts, token.ts
-- Extended token refresh window from 5min to 15min
-- Reason: Users were getting logged out during long forms
+- Node.js 18+
+- Claude Code
 
-YOU MAY SKIP EXPLORE AGENTS for files mentioned above.
-```
+---
 
-### How the Proxy Works
+## Pricing
 
-1. **`grov init`** sets `ANTHROPIC_BASE_URL=http://127.0.0.1:8080` in Claude's settings
-2. **`grov proxy`** intercepts all API calls and:
-   - Extracts intent from first prompt
-   - Injects context from team memory
-   - Tracks actions and detects drift
-   - Saves reasoning when tasks complete
+- **Free** - Individuals and teams up to 3 developers
+- **Team** - Larger teams with additional features (coming soon)
 
 ---
 
@@ -209,9 +248,13 @@ YOU MAY SKIP EXPLORE AGENTS for files mentioned above.
 - [x] Anti-drift detection & correction
 - [x] Team sync (cloud backend)
 - [x] Web dashboard
-- [ ] Semantic search
+- [x] Hybrid search (semantic + lexical)
+- [x] Extended cache (keep prompt cache warm)
+- [x] Auto-compaction with reasoning preservation
 - [ ] VS Code extension
 
+---
+
 ## Contributing
 
 1. **Fork the repo** and clone locally
@@ -226,6 +269,8 @@ node dist/cli.js init    # Test CLI
 
 Found a bug? [Open an issue](https://github.com/TonyStef/Grov/issues).
 
+---
+
 ## License
 
 Apache License 2.0 - see [LICENSE](LICENSE) file for details.

package/dist/commands/login.js

@@ -1,8 +1,24 @@
 // Login command - Device authorization flow
 // Authenticates CLI with Grov cloud using OAuth-like device flow
 import open from 'open';
-import { writeCredentials, isAuthenticated, readCredentials } from '../lib/credentials.js';
-import { startDeviceFlow, pollDeviceFlow, sleep } from '../lib/api-client.js';
+import * as readline from 'readline';
+import { writeCredentials, isAuthenticated, readCredentials, setTeamId, setSyncEnabled } from '../lib/credentials.js';
+import { startDeviceFlow, pollDeviceFlow, sleep, fetchTeams } from '../lib/api-client.js';
+/**
+ * Prompt user for input
+ */
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase());
+        });
+    });
+}
 /**
  * Decode JWT payload to extract user info
  */
@@ -91,16 +107,54 @@ export async function login() {
                 email: userInfo.email,
                 sync_enabled: false,
             });
-            console.log('╔═════════════════════════════════════════╗');
-            console.log('║                                         ║');
-            console.log('║   Successfully logged in!               ║');
-            console.log('║                                         ║');
-            console.log('╚═════════════════════════════════════════╝');
-            console.log(`\nLogged in as: ${userInfo.email}\n`);
-            console.log('Next steps:');
-            console.log('  1. Run "grov sync --status" to check sync settings');
-            console.log('  2. Run "grov sync --enable --team <team-id>" to enable sync');
-            console.log('  3. Run "grov status" to view local memories\n');
+            console.log('\n✓ Logged in as:', userInfo.email);
+            // Auto-setup: Fetch teams and configure sync
+            console.log('\nSetting up cloud sync...');
+            try {
+                const teams = await fetchTeams();
+                if (teams.length === 0) {
+                    console.log('\n⚠ No teams found.');
+                    console.log('Create one at: https://app.grov.dev/team');
+                    console.log('Then run: grov sync --enable --team <team-id>\n');
+                    return;
+                }
+                let selectedTeam = teams[0];
+                // If multiple teams, let user choose
+                if (teams.length > 1) {
+                    console.log('\nYour teams:');
+                    teams.forEach((team, i) => {
+                        console.log(`  ${i + 1}. ${team.name} (${team.slug})`);
+                    });
+                    const choice = await prompt(`\nSelect team [1-${teams.length}] (default: 1): `);
+                    const index = parseInt(choice, 10) - 1;
+                    if (index >= 0 && index < teams.length) {
+                        selectedTeam = teams[index];
+                    }
+                }
+                // Ask to enable sync (default yes)
+                const enableSync = await prompt(`Enable cloud sync to "${selectedTeam.name}"? [Y/n]: `);
+                if (enableSync !== 'n' && enableSync !== 'no') {
+                    setTeamId(selectedTeam.id);
+                    setSyncEnabled(true);
+                    console.log('\n╔═════════════════════════════════════════╗');
+                    console.log('║                                         ║');
+                    console.log('║   ✓ Cloud sync enabled!                 ║');
+                    console.log('║                                         ║');
+                    console.log('╚═════════════════════════════════════════╝');
+                    console.log(`\nSyncing to: ${selectedTeam.name}`);
+                    console.log('\nYou\'re all set! Your AI sessions will now be saved.');
+                    console.log('View them at: https://app.grov.dev/memories\n');
+                }
+                else {
+                    console.log('\n✓ Logged in. Sync not enabled.');
+                    console.log('Run "grov sync --enable" later to start syncing.\n');
+                }
+            }
+            catch (err) {
+                console.log('\n⚠ Could not auto-configure sync.');
+                console.log('Run "grov sync --enable --team <team-id>" manually.');
+                console.log('Find your team ID at: https://app.grov.dev/team\n');
+            }
             return;
         }
         if (status === 'expired') {

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

@@ -32,7 +32,6 @@ export interface TaskAnalysis {
     task_type: 'information' | 'planning' | 'implementation';
     action: 'continue' | 'new_task' | 'subtask' | 'parallel_task' | 'task_complete' | 'subtask_complete';
     task_id: string;
-    current_goal: string;
     parent_task_id?: string;
     reasoning: string;
     step_reasoning?: string;

package/dist/lib/llm-extractor.js

@@ -311,7 +311,6 @@ 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"
 - task_id: existing session_id "${currentSession?.session_id || 'NEW'}" or "NEW" for new task
-- current_goal: the goal based on the latest user message
 - reasoning: brief explanation of why you made this decision${compressionInstruction}
 </output>
 
@@ -481,7 +480,7 @@ 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'}"`);
+        debugLLM('analyzeTaskContext', `Result: task_type=${analysis.task_type}, action=${analysis.action}, reasoning="${analysis.reasoning?.substring(0, 150) || 'none'}"`);
         return analysis;
     }
     catch (parseError) {
@@ -491,7 +490,6 @@ RESPONSE RULES:
             task_type: 'implementation',
             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),
         };

package/dist/proxy/server.js

@@ -406,10 +406,21 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
         else if (!activeSession) {
             // First request, create session without task analysis
             const newSessionId = randomUUID();
+            // Extract clean goal summary instead of using raw text
+            let goalSummary = latestUserMessage.substring(0, 500) || 'Task in progress';
+            if (isIntentExtractionAvailable() && latestUserMessage.length > 10) {
+                try {
+                    const intentData = await extractIntent(latestUserMessage);
+                    goalSummary = intentData.goal;
+                }
+                catch {
+                    // Keep fallback goalSummary
+                }
+            }
             activeSession = createSessionState({
                 session_id: newSessionId,
                 project_path: sessionInfo.projectPath,
-                original_goal: latestUserMessage.substring(0, 500) || 'Task in progress',
+                original_goal: goalSummary,
                 task_type: 'main',
             });
             activeSessionId = newSessionId;
@@ -432,7 +443,6 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 msg: 'Task analysis',
                 action: taskAnalysis.action,
                 task_type: taskAnalysis.task_type,
-                goal: taskAnalysis.current_goal?.substring(0, 50),
                 reasoning: taskAnalysis.reasoning,
             });
             // TASK LOG: Analysis result
@@ -440,7 +450,6 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 sessionId: sessionInfo.sessionId,
                 action: taskAnalysis.action,
                 task_type: taskAnalysis.task_type,
-                goal: taskAnalysis.current_goal || '',
                 reasoning: taskAnalysis.reasoning || '',
                 userMessage: latestUserMessage.substring(0, 80),
                 hasCurrentSession: !!sessionInfo.currentSession,
@@ -464,22 +473,11 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     if (sessionInfo.currentSession) {
                         activeSessionId = sessionInfo.currentSession.session_id;
                         activeSession = sessionInfo.currentSession;
-                        // Update goal if Haiku detected a new instruction from user
-                        // (same task/topic, but new specific instruction)
-                        if (taskAnalysis.current_goal &&
-                            taskAnalysis.current_goal !== activeSession.original_goal &&
-                            latestUserMessage.length > 30) {
-                            updateSessionState(activeSessionId, {
-                                original_goal: taskAnalysis.current_goal,
-                            });
-                            activeSession.original_goal = taskAnalysis.current_goal;
-                        }
                         // TASK LOG: Continue existing session
                         taskLog('ORCHESTRATION_CONTINUE', {
                             sessionId: activeSessionId,
                             source: 'current_session',
                             goal: activeSession.original_goal,
-                            goalUpdated: taskAnalysis.current_goal !== activeSession.original_goal,
                         });
                     }
                     else if (sessionInfo.completedSession) {
@@ -488,7 +486,6 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         activeSession = sessionInfo.completedSession;
                         updateSessionState(activeSessionId, {
                             status: 'active',
-                            original_goal: taskAnalysis.current_goal || activeSession.original_goal,
                         });
                         activeSession.status = 'active';
                         activeSessions.set(activeSessionId, {
@@ -513,7 +510,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     }
                     // Extract full intent for new task (goal, scope, constraints, keywords)
                     let intentData = {
-                        goal: taskAnalysis.current_goal,
+                        goal: latestUserMessage.substring(0, 500),
                         expected_scope: [],
                         constraints: [],
                         keywords: [],
@@ -600,7 +597,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 case 'subtask': {
                     // Extract intent for subtask
                     let intentData = {
-                        goal: taskAnalysis.current_goal,
+                        goal: latestUserMessage.substring(0, 500),
                         expected_scope: [],
                         constraints: [],
                         keywords: [],
@@ -650,7 +647,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 case 'parallel_task': {
                     // Extract intent for parallel task
                     let intentData = {
-                        goal: taskAnalysis.current_goal,
+                        goal: latestUserMessage.substring(0, 500),
                         expected_scope: [],
                         constraints: [],
                         keywords: [],
@@ -748,10 +745,21 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         // Example: user asks clarification question, answer is provided in single turn
                         try {
                             const newSessionId = randomUUID();
+                            // Extract clean goal summary instead of using raw text
+                            let goalSummary = latestUserMessage.substring(0, 500);
+                            if (isIntentExtractionAvailable() && latestUserMessage.length > 10) {
+                                try {
+                                    const intentData = await extractIntent(latestUserMessage);
+                                    goalSummary = intentData.goal;
+                                }
+                                catch {
+                                    // Keep fallback goalSummary
+                                }
+                            }
                             const instantSession = createSessionState({
                                 session_id: newSessionId,
                                 project_path: sessionInfo.projectPath,
-                                original_goal: taskAnalysis.current_goal || latestUserMessage.substring(0, 500),
+                                original_goal: goalSummary,
                                 task_type: 'main',
                             });
                             // Set final_response for reasoning extraction
@@ -764,7 +772,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                             // TASK LOG: Instant complete (new task that finished in one turn)
                             taskLog('ORCHESTRATION_TASK_COMPLETE', {
                                 sessionId: newSessionId,
-                                goal: taskAnalysis.current_goal || latestUserMessage.substring(0, 80),
+                                goal: goalSummary,
                                 source: 'instant_complete',
                             });
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grov",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "Collective AI memory for Claude Code - captures reasoning from sessions and injects context into future sessions",
   "type": "module",
   "main": "dist/cli.js",
@@ -13,6 +13,7 @@
     "dist/**/*.d.ts",
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
+    "postinstall.js",
     "README.md",
     "LICENSE"
   ],
@@ -34,6 +35,7 @@
     "test:watch": "vitest",
     "test:all": "turbo run test",
     "typecheck": "turbo run typecheck",
+    "postinstall": "node postinstall.js",
     "prepublishOnly": "npm run build && npm test && npm run security:scan",
     "prepare": "husky",
     "security:scan": "./scripts/scan-secrets.sh"

package/postinstall.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+const green = '\x1b[32m';
+const cyan = '\x1b[36m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+const bold = '\x1b[1m';
+
+console.log(`
+${green}✓${reset} ${bold}grov installed successfully${reset}
+
+${dim}Sync your AI memories across your team:${reset}
+  ${cyan}https://app.grov.dev${reset}
+
+${dim}Quick start:${reset}
+  ${green}grov init${reset}      Configure proxy
+  ${green}grov proxy${reset}     Start capturing
+  ${green}grov login${reset}     Connect to dashboard
+`);