grov 0.1.1 → 0.2.2

package/README.md

@@ -1,15 +1,25 @@
+<p align="center">
+  <img src="landing/public/images/logos/grov-nobg.png" alt="grov logo" width="120">
+</p>
+
 <h1 align="center">grov</h1>
 
 <p align="center"><strong>Collective AI memory for engineering teams.</strong></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>
+</p>
+
 <p align="center">
   <a href="https://grov.dev">Website</a> •
   <a href="#quick-start">Quick Start</a> •
-  <a href="#roadmap">Roadmap</a> •
+  <a href="#advanced-features">Advanced</a> •
   <a href="#contributing">Contributing</a>
 </p>
 
-Grov automatically captures reasoning from your Claude Code sessions and injects relevant context into future sessions. Your AI remembers what it learned.
+Grov captures reasoning from your Claude Code sessions and injects it into future sessions. Your AI remembers what it learned.
 
 ## The Problem
 
@@ -19,7 +29,7 @@ Every time you start a new Claude Code session:
 - 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.
+**Measured impact:** A typical task takes 10+ minutes, 7%+ token usage, and 3+ explore agents just to understand the codebase.*
 
 ## The Solution
 
@@ -27,6 +37,18 @@ 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.
 
+<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>
+
+## Quick Start
+
+```bash
+npm install -g grov   # Install
+grov init             # Configure (one-time)
+grov proxy            # Start (keep running)
+```
+
+Then use Claude Code normally in another terminal. That's it.
+
 ## How It Works
 
 ```
@@ -42,83 +64,60 @@ Session 2: User asks about related feature
         Claude skips exploration, reads files directly
 ```
 
-**Zero friction.** You don't change anything about how you use Claude Code.
-
-## Quick Start
-
-```bash
-# Install globally
-npm install -g grov
-
-# One-time setup (registers hooks in Claude Code)
-grov init
-
-# Done. Use Claude Code normally.
-claude
-```
-
-That's it. Grov works invisibly in the background.
-
 ## Commands
 
 ```bash
-grov init        # Register hooks (run once)
-grov status      # Show captured tasks for current project
-grov status -a   # Show all tasks (including partial/abandoned)
-grov unregister  # Disable grov
-grov drift-test  # Test drift detection (debug)
+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 disable      # Disable grov
 ```
 
-## How It Actually Works
+## Data Storage
 
-1. **SessionStart hook** fires when you run `claude`
-   - Grov queries its database for relevant past reasoning
-   - Outputs context that Claude Code injects into the session
+- **Database:** `~/.grov/memory.db` (SQLite)
+- **Per-project:** Context is filtered by project path
+- **Local only:** Nothing leaves your machine
 
-2. **UserPromptSubmit hook** fires on every prompt
-   - Monitors Claude's actions (files touched, commands run)
-   - Detects scope drift and injects corrections if needed
-   - Smart filtering skips simple prompts ("yes", "ok", "continue")
+## Requirements
 
-3. **You work normally** with Claude Code
+- Node.js 18+
+- Claude Code
 
-4. **Stop hook** fires when the session ends
-   - Grov parses the session's JSONL file
-   - Extracts reasoning via LLM (Claude Haiku 4.5)
-   - Stores structured summary in SQLite
+---
 
-5. **Next session**, Claude has context and skips re-exploration
+## Advanced Features
 
-## Anti-Drift Detection
+### Anti-Drift Detection
 
-Grov monitors what Claude **does** (not what you ask) and warns if it drifts from your original goal.
+Grov monitors what Claude **does** (not what you ask) and corrects if it drifts from your goal.
 
-**How it works:**
 - Extracts your intent from the first prompt
 - Monitors Claude's actions (file edits, commands, explorations)
-- Uses Claude Haiku 4.5 to score alignment (1-10)
-- Injects corrections at 5 levels: nudge → correct → intervene → halt
-
-**Key principle:** You can explore freely. Grov watches Claude's actions, not your prompts.
+- Uses Claude Haiku to score alignment (1-10)
+- Injects corrections at 4 levels: nudge → correct → intervene → halt
 
 ```bash
-# Test drift detection manually
+# Test drift detection
 grov drift-test "refactor the auth system" --goal "fix login bug"
 ```
 
-## Environment Variables
+### Environment Variables
 
 ```bash
 # Required for drift detection and LLM extraction
 export ANTHROPIC_API_KEY=sk-ant-...
 
-# Optional: Override drift model (default: claude-haiku-4-5)
-export GROV_DRIFT_MODEL=claude-sonnet-4-20250514
+# Optional
+export GROV_DRIFT_MODEL=claude-sonnet-4-20250514  # Override model
+export PROXY_HOST=127.0.0.1                        # Proxy host
+export PROXY_PORT=8080                             # Proxy port
 ```
 
-Without an API key, grov uses basic extraction (files touched, tool usage counts) and disables drift detection.
+Without an API key, grov uses basic extraction and disables drift detection.
 
-## What Gets Stored
+### What Gets Stored
 
 ```json
 {
@@ -130,12 +129,11 @@ Without an API key, grov uses basic extraction (files touched, tool usage counts
     "Found refresh window was too short",
     "Extended from 5min to 15min"
   ],
-  "status": "complete",
-  "tags": ["auth", "session", "token"]
+  "status": "complete"
 }
 ```
 
-## What Gets Injected
+### What Gets Injected
 
 ```
 VERIFIED CONTEXT FROM PREVIOUS SESSIONS:
@@ -146,26 +144,24 @@ VERIFIED CONTEXT FROM PREVIOUS SESSIONS:
 - Reason: Users were getting logged out during long forms
 
 YOU MAY SKIP EXPLORE AGENTS for files mentioned above.
-Read them directly if relevant to the current task.
 ```
 
-## Data Storage
-
-- **Database:** `~/.grov/memory.db` (SQLite)
-- **Per-project:** Context is filtered by project path
-- **Local only:** Nothing leaves your machine (unless you add cloud sync)
+### How the Proxy Works
 
-## Requirements
+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
 
-- Node.js 18+
-- Claude Code v2.0+
+---
 
 ## Roadmap
 
 - [x] Local capture & inject
-- [x] LLM-powered extraction (Claude Haiku 4.5)
-- [x] Zero-friction hooks
-- [x] Per-prompt context injection
+- [x] LLM-powered extraction
+- [x] Local proxy with real-time monitoring
 - [x] Anti-drift detection & correction
 - [ ] Team sync (cloud backend)
 - [ ] Web dashboard
@@ -173,34 +169,17 @@ Read them directly if relevant to the current task.
 
 ## Contributing
 
-We welcome contributions! Here's how to get started:
-
 1. **Fork the repo** and clone locally
 2. **Install dependencies:** `npm install`
 3. **Build:** `npm run build`
 4. **Test locally:** `node dist/cli.js --help`
 
-### Development
-
 ```bash
-# Watch mode for development
-npm run dev
-
-# Test the CLI
-node dist/cli.js init
-node dist/cli.js status
+npm run dev              # Watch mode
+node dist/cli.js init    # Test CLI
 ```
 
-### Guidelines
-
-- Keep PRs focused on a single change
-- Follow existing code style
-- Update tests if applicable
-- Update docs if adding features
-
-### Reporting Issues
-
-Found a bug or have a feature request? [Open an issue](https://github.com/TonyStef/Grov/issues).
+Found a bug? [Open an issue](https://github.com/TonyStef/Grov/issues).
 
 ## License
 

package/dist/cli.js

@@ -36,43 +36,21 @@ program
     .name('grov')
     .description('Collective AI memory for engineering teams')
     .version('0.1.0');
-// grov init - Register hooks in Claude Code
+// grov init - Configure Claude Code to use grov proxy
 program
     .command('init')
-    .description('Register grov hooks in Claude Code settings')
+    .description('Configure Claude Code to use grov proxy (run once)')
     .action(safeAction(async () => {
     const { init } = await import('./commands/init.js');
     await init();
 }));
-// grov capture - Called by Stop hook, extracts and stores reasoning
+// grov disable - Remove proxy configuration
 program
-    .command('capture')
-    .description('Capture reasoning from current session (called by Stop hook)')
-    .option('--session-dir <path>', 'Path to session directory')
-    .action(safeAction(async (options) => {
-    // SECURITY: Validate session-dir doesn't contain path traversal
-    if (options.sessionDir && options.sessionDir.includes('..')) {
-        throw new Error('Invalid session directory path');
-    }
-    const { capture } = await import('./commands/capture.js');
-    await capture(options);
-}));
-// grov inject - Called by SessionStart hook, outputs context JSON
-program
-    .command('inject')
-    .description('Inject relevant context for new session (called by SessionStart hook)')
-    .option('--task <description>', 'Task description from user prompt')
-    .action(safeAction(async (options) => {
-    const { inject } = await import('./commands/inject.js');
-    await inject(options);
-}));
-// grov prompt-inject - Called by UserPromptSubmit hook, outputs context JSON per-turn
-program
-    .command('prompt-inject')
-    .description('Inject context before each prompt (called by UserPromptSubmit hook)')
+    .command('disable')
+    .description('Disable grov and restore direct Anthropic connection')
     .action(safeAction(async () => {
-    const { promptInject } = await import('./commands/prompt-inject.js');
-    await promptInject({});
+    const { disable } = await import('./commands/disable.js');
+    await disable();
 }));
 // grov status - Show stored reasoning for current project
 program
@@ -83,14 +61,6 @@ program
     const { status } = await import('./commands/status.js');
     await status(options);
 }));
-// grov unregister - Remove hooks from Claude Code
-program
-    .command('unregister')
-    .description('Remove grov hooks from Claude Code settings')
-    .action(safeAction(async () => {
-    const { unregister } = await import('./commands/unregister.js');
-    await unregister();
-}));
 // grov drift-test - Test drift detection on a prompt
 program
     .command('drift-test')
@@ -103,4 +73,20 @@ program
     const { driftTest } = await import('./commands/drift-test.js');
     await driftTest(prompt, options);
 });
+// grov proxy - Start the proxy server
+program
+    .command('proxy')
+    .description('Start the Grov proxy server (intercepts Claude API calls)')
+    .action(async () => {
+    const { startServer } = await import('./proxy/server.js');
+    await startServer();
+});
+// grov proxy-status - Show active proxy sessions
+program
+    .command('proxy-status')
+    .description('Show active proxy sessions')
+    .action(safeAction(async () => {
+    const { proxyStatus } = await import('./commands/proxy-status.js');
+    await proxyStatus();
+}));
 program.parse();

package/dist/commands/capture.js

@@ -114,7 +114,7 @@ export async function capture(options) {
             if (sessionState) {
                 updateSessionState(sessionId, {
                     status: finalStatus === 'complete' ? 'completed' : 'abandoned',
-                    files_explored: [...new Set([...sessionState.files_explored, ...filesTouched])],
+                    files_explored: [...new Set([...(sessionState.files_explored || []), ...filesTouched])],
                     original_goal: goal,
                 });
                 debugCapture('Updated session state: %s...', sessionId.substring(0, 8));

package/dist/commands/disable.d.ts

@@ -0,0 +1 @@
+export declare function disable(): Promise<void>;

package/dist/commands/disable.js

@@ -0,0 +1,14 @@
+// grov disable - Remove proxy configuration and restore direct Anthropic connection
+import { setProxyEnv, getSettingsPath } from '../lib/settings.js';
+export async function disable() {
+    const result = setProxyEnv(false);
+    if (result.action === 'removed') {
+        console.log('Grov disabled.');
+        console.log('  - ANTHROPIC_BASE_URL removed from settings');
+    }
+    else {
+        console.log('Grov was not configured.');
+    }
+    console.log(`\nSettings file: ${getSettingsPath()}`);
+    console.log('\nClaude will now connect directly to Anthropic.');
+}

package/dist/commands/drift-test.js

@@ -1,17 +1,17 @@
 // grov drift-test - Debug command for testing drift detection
 // Usage: grov drift-test "your prompt here" [--session <id>] [--goal "original goal"]
 //
-// NOTE: This command creates mock ACTIONS from the prompt for testing.
-// In real usage, actions are parsed from Claude's JSONL session file.
+// NOTE: This command creates mock STEPS from the prompt for testing.
+// In real usage, steps are tracked by the proxy from Claude's actions.
 import 'dotenv/config';
 import { getSessionState, createSessionState } from '../lib/store.js';
-import { extractIntent, isAnthropicAvailable } from '../lib/llm-extractor.js';
-import { buildDriftCheckInput, checkDrift, checkDriftBasic, DRIFT_CONFIG } from '../lib/drift-checker.js';
-import { determineCorrectionLevel, buildCorrection } from '../lib/correction-builder.js';
+import { extractIntent } from '../lib/llm-extractor.js';
+import { checkDrift, checkDriftBasic, isDriftCheckAvailable, scoreToCorrectionLevel } from '../lib/drift-checker-proxy.js';
+import { buildCorrection, formatCorrectionForInjection } from '../lib/correction-builder-proxy.js';
 export async function driftTest(prompt, options) {
     console.log('=== GROV DRIFT TEST ===\n');
     // Check API availability
-    const llmAvailable = isAnthropicAvailable();
+    const llmAvailable = isDriftCheckAvailable();
     console.log(`Anthropic API: ${llmAvailable ? 'AVAILABLE' : 'NOT AVAILABLE (using fallback)'}`);
     console.log('');
     // Get or create session state
@@ -27,52 +27,21 @@ export async function driftTest(prompt, options) {
         console.log(`Constraints: ${intent.constraints.join(', ') || 'none'}`);
         console.log(`Keywords: ${intent.keywords.join(', ')}`);
         console.log('');
-        // Create temporary session state in memory (not persisted unless session ID provided)
-        sessionState = {
-            session_id: options.session || 'test-session',
+        // Create temporary session state
+        sessionState = createSessionState({
+            session_id: options.session || 'test-session-' + Date.now(),
             project_path: process.cwd(),
             original_goal: intent.goal,
-            actions_taken: [],
-            files_explored: [],
-            current_intent: undefined,
-            drift_warnings: [],
-            start_time: new Date().toISOString(),
-            last_update: new Date().toISOString(),
-            status: 'active',
             expected_scope: intent.expected_scope,
             constraints: intent.constraints,
-            success_criteria: intent.success_criteria,
             keywords: intent.keywords,
-            last_drift_score: undefined,
-            escalation_count: 0,
-            pending_recovery_plan: undefined,
-            drift_history: [],
-            last_checked_at: 0 // New field for action tracking
-        };
-        // Persist if session ID was provided
-        if (options.session) {
-            try {
-                createSessionState({
-                    session_id: options.session,
-                    project_path: process.cwd(),
-                    original_goal: intent.goal,
-                    expected_scope: intent.expected_scope,
-                    constraints: intent.constraints,
-                    success_criteria: intent.success_criteria,
-                    keywords: intent.keywords
-                });
-                console.log(`Session state persisted: ${options.session}`);
-            }
-            catch {
-                // Might already exist, ignore
-            }
-        }
+            task_type: 'main',
+        });
     }
     else {
         console.log(`Using existing session: ${options.session}`);
         console.log(`Original goal: ${sessionState.original_goal}`);
         console.log(`Escalation count: ${sessionState.escalation_count}`);
-        console.log(`Drift history: ${sessionState.drift_history.length} events`);
         console.log('');
     }
     // Ensure sessionState is not null at this point
@@ -80,23 +49,42 @@ export async function driftTest(prompt, options) {
         console.error('Failed to create session state');
         process.exit(1);
     }
-    // Create mock actions from prompt for testing
-    // In real usage, actions are parsed from Claude's JSONL session file
+    // Create mock steps from prompt for testing
     const mockFiles = extractFilesFromPrompt(prompt);
-    const mockActions = mockFiles.length > 0
+    const mockSteps = mockFiles.length > 0
         ? mockFiles.map((file, i) => ({
-            type: 'edit',
+            id: `step-${i}`,
+            session_id: sessionState.session_id,
+            action_type: 'edit',
             files: [file],
-            timestamp: Date.now() + i * 1000
+            folders: [],
+            timestamp: Date.now() + i * 1000,
+            is_validated: true,
+            is_key_decision: false,
+            keywords: [],
         }))
-        : [{ type: 'edit', files: ['mock-file.ts'], timestamp: Date.now() }];
-    console.log('--- Mock Actions (from prompt) ---');
+        : [{
+                id: 'step-0',
+                session_id: sessionState.session_id,
+                action_type: 'edit',
+                files: ['mock-file.ts'],
+                folders: [],
+                timestamp: Date.now(),
+                is_validated: true,
+                is_key_decision: false,
+                keywords: [],
+            }];
+    console.log('--- Mock Steps (from prompt) ---');
     console.log(`Files detected: ${mockFiles.join(', ') || 'none (using mock-file.ts)'}`);
     console.log('');
-    // Build drift check input using ACTIONS (not prompt!)
-    const driftInput = buildDriftCheckInput(mockActions, sessionState.session_id, sessionState);
+    // Build drift check input
+    const driftInput = {
+        sessionState,
+        recentSteps: mockSteps,
+        latestUserMessage: prompt,
+    };
     console.log('--- Drift Check Input ---');
-    console.log(`Actions: ${mockActions.map(a => `${a.type}:${a.files.join(',')}`).join(' | ')}`);
+    console.log(`Steps: ${mockSteps.map(s => `${s.action_type}:${s.files.join(',')}`).join(' | ')}`);
     console.log('');
     // Run drift check
     console.log('--- Running Drift Check ---');
@@ -112,37 +100,37 @@ export async function driftTest(prompt, options) {
     console.log('');
     console.log('--- Drift Check Result ---');
     console.log(`Score: ${result.score}/10`);
-    console.log(`Type: ${result.type}`);
+    console.log(`Type: ${result.driftType}`);
     console.log(`Diagnostic: ${result.diagnostic}`);
-    if (result.boundaries.length > 0) {
-        console.log(`Boundaries: ${result.boundaries.join(', ')}`);
+    if (result.suggestedAction) {
+        console.log(`Suggested Action: ${result.suggestedAction}`);
     }
-    if (result.recoveryPlan?.steps) {
+    if (result.recoverySteps && result.recoverySteps.length > 0) {
         console.log('Recovery steps:');
-        for (const step of result.recoveryPlan.steps) {
-            const file = step.file ? `[${step.file}] ` : '';
-            console.log(`  - ${file}${step.action}`);
+        for (const step of result.recoverySteps) {
+            console.log(`  - ${step}`);
         }
     }
     console.log('');
     // Determine correction level
-    const level = determineCorrectionLevel(result.score, sessionState.escalation_count);
+    const level = scoreToCorrectionLevel(result.score);
     console.log('--- Correction Level ---');
     console.log(`Level: ${level || 'NONE (no correction needed)'}`);
     console.log('');
     // Show thresholds
-    console.log('--- Thresholds (with escalation=%d) ---', sessionState.escalation_count);
-    console.log(`>= ${DRIFT_CONFIG.SCORE_NO_INJECTION - sessionState.escalation_count}: No correction`);
-    console.log(`>= ${DRIFT_CONFIG.SCORE_NUDGE - sessionState.escalation_count}: Nudge`);
-    console.log(`>= ${DRIFT_CONFIG.SCORE_CORRECT - sessionState.escalation_count}: Correct`);
-    console.log(`>= ${DRIFT_CONFIG.SCORE_INTERVENE - sessionState.escalation_count}: Intervene`);
-    console.log(`< ${DRIFT_CONFIG.SCORE_INTERVENE - sessionState.escalation_count}: Halt`);
+    console.log('--- Thresholds ---');
+    console.log(`>= 8: No correction`);
+    console.log(`= 7: Nudge`);
+    console.log(`5-6: Correct`);
+    console.log(`3-4: Intervene`);
+    console.log(`< 3: Halt`);
     console.log('');
     // Build and show correction if applicable
     if (level) {
         console.log('--- Correction Output ---');
         const correction = buildCorrection(result, sessionState, level);
-        console.log(correction);
+        const formatted = formatCorrectionForInjection(correction);
+        console.log(formatted);
     }
     else {
         console.log('No correction needed for this prompt.');
@@ -150,7 +138,7 @@ export async function driftTest(prompt, options) {
     console.log('\n=== END DRIFT TEST ===');
 }
 /**
- * Extract file paths from a prompt for mock action creation
+ * Extract file paths from a prompt for mock step creation
  */
 function extractFilesFromPrompt(prompt) {
     const patterns = [

package/dist/commands/init.js

@@ -1,27 +1,39 @@
-// grov init - Register hooks in Claude Code settings
-import { registerGrovHooks, getSettingsPath } from '../lib/hooks.js';
+// grov init - Configure Claude Code to use grov proxy
+import { setProxyEnv, getSettingsPath } from '../lib/settings.js';
 export async function init() {
-    console.log('Registering grov hooks in Claude Code...\n');
+    console.log('Configuring grov...\n');
     try {
-        const { added, alreadyExists } = registerGrovHooks();
-        if (added.length > 0) {
-            console.log('Added hooks:');
-            added.forEach(hook => console.log(`  + ${hook}`));
+        // Set up proxy URL in settings so users just type 'claude'
+        const result = setProxyEnv(true);
+        if (result.action === 'added') {
+            console.log('  + ANTHROPIC_BASE_URL → http://127.0.0.1:8080');
         }
-        if (alreadyExists.length > 0) {
-            console.log('Already registered:');
-            alreadyExists.forEach(hook => console.log(`  = ${hook}`));
+        else if (result.action === 'unchanged') {
+            console.log('  = ANTHROPIC_BASE_URL already configured');
         }
         console.log(`\nSettings file: ${getSettingsPath()}`);
-        console.log('\nGrov is now active! Your Claude Code sessions will automatically:');
-        console.log('  - Capture reasoning after each task (Stop hook)');
-        console.log('  - Inject relevant context at session start (SessionStart hook)');
-        console.log('  - Inject targeted context before each prompt (UserPromptSubmit hook)');
-        console.log('\nJust use Claude Code normally. Grov works in the background.');
+        // Check for API key and provide helpful instructions
+        if (!process.env.ANTHROPIC_API_KEY) {
+            console.log('\n' + '='.repeat(50));
+            console.log('  ANTHROPIC_API_KEY not found');
+            console.log('='.repeat(50));
+            console.log('\nTo enable drift detection and smart extraction:\n');
+            console.log('  1. Get your API key at:');
+            console.log('     https://console.anthropic.com/settings/keys\n');
+            console.log('  2. Add to your shell profile (~/.zshrc or ~/.bashrc):');
+            console.log('     export ANTHROPIC_API_KEY=sk-ant-...\n');
+            console.log('  3. Restart terminal or run: source ~/.zshrc\n');
+        }
+        else {
+            console.log('\n  ANTHROPIC_API_KEY found');
+        }
+        console.log('\n--- Next Steps ---');
+        console.log('1. Terminal 1: grov proxy');
+        console.log('2. Terminal 2: claude');
+        console.log('\nGrov will automatically capture reasoning and inject context.');
     }
     catch (error) {
-        // SECURITY: Only show error message, not full stack trace with paths
-        console.error('Failed to register hooks:', error instanceof Error ? error.message : 'Unknown error');
+        console.error('Failed to configure grov:', error instanceof Error ? error.message : 'Unknown error');
         process.exit(1);
     }
 }

package/dist/commands/proxy-status.d.ts

@@ -0,0 +1 @@
+export declare function proxyStatus(): Promise<void>;

package/dist/commands/proxy-status.js

@@ -0,0 +1,32 @@
+// grov proxy-status - Show active proxy sessions
+import { getActiveSessionsForStatus } from '../lib/store.js';
+export async function proxyStatus() {
+    const sessions = getActiveSessionsForStatus();
+    if (sessions.length === 0) {
+        console.log('No active proxy sessions.');
+        return;
+    }
+    console.log(`\n=== Active Proxy Sessions (${sessions.length}) ===\n`);
+    for (const session of sessions) {
+        const elapsed = getElapsedTime(session.start_time);
+        const goal = session.original_goal || 'No goal set';
+        console.log(`Session: ${session.session_id.substring(0, 8)}...`);
+        console.log(`  Status: ${session.status}`);
+        console.log(`  Mode: ${session.session_mode || 'normal'}`);
+        console.log(`  Goal: ${goal.substring(0, 60)}${goal.length > 60 ? '...' : ''}`);
+        console.log(`  Drift: ${session.escalation_count} escalations`);
+        console.log(`  Started: ${elapsed} ago`);
+        console.log('');
+    }
+}
+function getElapsedTime(startTime) {
+    const start = new Date(startTime).getTime();
+    const now = Date.now();
+    const diff = now - start;
+    const minutes = Math.floor(diff / 60000);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    return `${minutes}m`;
+}