grov 0.6.16 → 0.6.18

package/dist/core/cloud/api-client.d.ts

@@ -1,4 +1,4 @@
-import type { Team, Memory, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse, ReasoningTraceEntry } from '@grov/shared';
+import type { Team, Memory, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse, ReasoningTraceEntry, RecordInjectionRequest, RecordInjectionResponse } from '@grov/shared';
 export interface ApiResponse<T> {
     data?: T;
     error?: string;
@@ -88,6 +88,7 @@ export interface MatchResponse {
  * @returns Match response with memory and score
  */
 export declare function fetchMatch(teamId: string, data: MatchInput): Promise<MatchResponse>;
+export declare function reportInjection(event: RecordInjectionRequest): Promise<RecordInjectionResponse | null>;
 /**
  * Sleep helper for polling
  */

package/dist/core/cloud/api-client.js

@@ -148,6 +148,12 @@ export async function fetchTeamMemories(teamId, projectPath, options) {
         if (!response.data || !response.data.memories) {
             return [];
         }
+        // Check if blocked due to quota
+        if (response.data.blocked) {
+            console.log('\n[grov] \x1b[33m⚠️  Free quota exceeded (110%). Upgrade to continue using memory injection.\x1b[0m');
+            console.log('[grov]    Manage plan: https://app.grov.dev/settings\n');
+            return [];
+        }
         return response.data.memories;
     }
     catch (err) {
@@ -186,6 +192,16 @@ export async function fetchMatch(teamId, data) {
         return { match: null };
     }
 }
+// ============= Usage Tracking =============
+export async function reportInjection(event) {
+    try {
+        const response = await apiRequest('POST', '/usage/injection', event);
+        return response.data || null;
+    }
+    catch {
+        return null;
+    }
+}
 // ============= Utility Functions =============
 /**
  * Sleep helper for polling

package/dist/core/cloud/cloud-sync.d.ts

@@ -36,18 +36,12 @@ export interface UpdateMemoryInput extends CreateMemoryInput {
 /**
  * Convert local Task to CreateMemoryInput for API
  */
-export declare function taskToMemory(task: Task): CreateMemoryInput;
+export declare function taskToMemory(task: Task, taskType?: 'information' | 'planning' | 'implementation'): CreateMemoryInput;
 /**
  * Prepare sync payload for UPDATE path
  * Merges existing memory with new data based on shouldUpdateMemory result
- *
- * @param existingMemory - The memory that was matched
- * @param newData - Extracted reasoning and decisions from current session
- * @param updateResult - Result from shouldUpdateMemory Haiku call
- * @param task - The current task being synced
- * @returns Payload ready for sync with memory_id for UPDATE
  */
-export declare function prepareSyncPayload(existingMemory: Memory, newData: ExtractedReasoningAndDecisions, updateResult: ShouldUpdateResult, task: Task): UpdateMemoryInput;
+export declare function prepareSyncPayload(existingMemory: Memory, newData: ExtractedReasoningAndDecisions, updateResult: ShouldUpdateResult, task: Task, taskType?: 'information' | 'planning' | 'implementation'): UpdateMemoryInput;
 /**
  * Check if sync is enabled and configured
  */

package/dist/core/cloud/cloud-sync.js

@@ -12,13 +12,13 @@ const SYNC_CONFIG = {
 /**
  * Convert local Task to CreateMemoryInput for API
  */
-export function taskToMemory(task) {
+export function taskToMemory(task, taskType) {
     return {
         client_task_id: task.id,
         project_path: task.project_path,
         original_query: task.original_query,
         goal: task.goal,
-        system_name: task.system_name, // Parent anchor for semantic search
+        system_name: task.system_name,
         summary: task.summary,
         reasoning_trace: task.reasoning_trace,
         files_touched: task.files_touched,
@@ -26,6 +26,7 @@ export function taskToMemory(task) {
         constraints: task.constraints,
         tags: task.tags,
         status: task.status,
+        task_type: taskType,
         linked_commit: task.linked_commit,
     };
 }
@@ -38,14 +39,8 @@ function getToday() {
 /**
  * Prepare sync payload for UPDATE path
  * Merges existing memory with new data based on shouldUpdateMemory result
- *
- * @param existingMemory - The memory that was matched
- * @param newData - Extracted reasoning and decisions from current session
- * @param updateResult - Result from shouldUpdateMemory Haiku call
- * @param task - The current task being synced
- * @returns Payload ready for sync with memory_id for UPDATE
  */
-export function prepareSyncPayload(existingMemory, newData, updateResult, task) {
+export function prepareSyncPayload(existingMemory, newData, updateResult, task, taskType) {
     const today = getToday();
     // 1. Get existing decisions with proper typing
     const existingDecisions = (existingMemory.decisions || []);
@@ -109,18 +104,19 @@ export function prepareSyncPayload(existingMemory, newData, updateResult, task)
     const finalReasoningEvolution = reasoningEvolution.slice(-MAX_REASONING_EVOLUTION);
     // 8. Build final payload
     return {
-        memory_id: existingMemory.id, // Triggers UPDATE path in API
+        memory_id: existingMemory.id,
         client_task_id: task.id,
         project_path: task.project_path,
         original_query: task.original_query,
         goal: task.goal,
-        system_name: newData.system_name || task.system_name, // Parent anchor for semantic search
-        reasoning_trace: newData.reasoning_trace, // OVERWRITE with new
+        system_name: newData.system_name || task.system_name,
+        reasoning_trace: newData.reasoning_trace,
         files_touched: task.files_touched,
         decisions: finalDecisions,
         constraints: task.constraints,
         tags: task.tags,
         status: task.status,
+        task_type: taskType,
         linked_commit: task.linked_commit,
         evolution_steps: finalEvolutionSteps,
         reasoning_evolution: finalReasoningEvolution,
@@ -188,7 +184,7 @@ export async function syncTask(task, extractedData, taskType, headers) {
         });
         // Step 2: If no match, INSERT as new memory
         if (!matchResult.match) {
-            const memory = taskToMemory(task);
+            const memory = taskToMemory(task, taskType);
             const result = await syncMemories(teamId, { memories: [memory] });
             console.log(`[SYNC TO CLOUD] ${taskId} -> INSERT (${taskType || 'unknown'})`);
             return result.synced === 1;
@@ -197,7 +193,7 @@ export async function syncTask(task, extractedData, taskType, headers) {
         const score = matchResult.combined_score?.toFixed(3) || '-';
         // If no extracted data, INSERT anyway
         if (!effectiveExtractedData) {
-            const memory = taskToMemory(task);
+            const memory = taskToMemory(task, taskType);
             const result = await syncMemories(teamId, { memories: [memory] });
             console.log(`[SYNC TO CLOUD] ${taskId} -> INSERT (${taskType || 'unknown'})`);
             return result.synced === 1;
@@ -223,7 +219,7 @@ export async function syncTask(task, extractedData, taskType, headers) {
             return true;
         }
         // Prepare payload for UPDATE
-        const payload = prepareSyncPayload(matchResult.match, effectiveExtractedData, updateResult, task);
+        const payload = prepareSyncPayload(matchResult.match, effectiveExtractedData, updateResult, task, taskType);
         // Sync with memory_id for UPDATE path
         const result = await syncMemories(teamId, { memories: [payload] });
         console.log(`[SYNC TO CLOUD] ${taskId} -> UPDATE (${taskType || 'unknown'}) [matched: ${matchedId}]`);
@@ -269,7 +265,7 @@ export async function syncTasks(tasks) {
         };
     }
     // Convert tasks to memories
-    const memories = tasks.map(taskToMemory);
+    const memories = tasks.map(t => taskToMemory(t));
     // Batch and sync
     const batches = [];
     for (let i = 0; i < memories.length; i += SYNC_CONFIG.batchSize) {

package/dist/integrations/proxy/handlers/preprocess.js

@@ -4,7 +4,10 @@ import { extractFilesFromMessages } from '../request-processor.js';
 import { fetchTeamMemories } from '../../../core/cloud/api-client.js';
 import { getSessionState, updateSessionState, markCleared, } from '../../../core/store/store.js';
 import { isSyncEnabled, getSyncTeamId } from '../../../core/cloud/cloud-sync.js';
+import { getCurrentUser } from '../../../core/cloud/credentials.js';
+import { reportInjection } from '../../../core/cloud/api-client.js';
 import { clearSessionState, cacheMemories, buildMemoryPreview, buildToolDescription, buildDriftRecoveryInjection, reconstructMessages, addInjectionRecord, commitPendingRecords, setCachedPreview, getCachedPreview, } from '../injection/memory-injection.js';
+import { handleInjectionResponse } from '../utils/usage-warnings.js';
 let pendingPlanClear = null;
 export function getPendingPlanClear() {
     return pendingPlanClear;
@@ -141,6 +144,20 @@ export async function preProcessRequest(adapter, body, sessionInfo, logger, dete
                         previewSize: preview?.length || 0,
                         hasDriftRecovery: !!driftRecovery,
                     });
+                    const user = getCurrentUser();
+                    if (user && teamId) {
+                        reportInjection({
+                            team_id: teamId,
+                            user_id: user.id,
+                            session_id: sessionInfo.sessionId,
+                            event_id: `${sessionInfo.sessionId}:${Date.now()}:preview`,
+                            injection_type: 'preview',
+                            memory_ids: memories.map(m => m.id),
+                            timestamp: new Date().toISOString(),
+                        })
+                            .then(res => handleInjectionResponse(res, teamId))
+                            .catch(() => { });
+                    }
                 }
                 else {
                     // No memories found - inject explicit "no entries" so Claude doesn't use old previews

package/dist/integrations/proxy/orchestrator.js

@@ -2,6 +2,9 @@
 // Handles session management, task orchestration, drift detection, and memory injection
 import { randomUUID } from 'crypto';
 import { config, buildSafeHeaders } from './config.js';
+import { getSyncTeamId } from '../../core/cloud/cloud-sync.js';
+import { getCurrentUser } from '../../core/cloud/credentials.js';
+import { reportInjection } from '../../core/cloud/api-client.js';
 import { extendedCache, evictOldestCacheEntry } from './cache/extended-cache.js';
 import { getNextRequestId, taskLog, proxyLog, logTokenUsage } from './utils/logging.js';
 import { preProcessRequest, setPendingPlanClear } from './handlers/preprocess.js';
@@ -11,6 +14,7 @@ import { buildCorrection, formatCorrectionForInjection } from '../../core/extrac
 import { generateSessionSummary, analyzeTaskContext, } from '../../core/extraction/llm-extractor.js';
 import { saveToTeamMemory } from './response-processor.js';
 import { getCachedMemoryById, buildExpandedMemory, addInjectionRecord, hasToolCycleAtPosition, } from './injection/memory-injection.js';
+import { handleInjectionResponse } from './utils/usage-warnings.js';
 // In-memory state
 const lastDriftResults = new Map();
 const lastMessageCount = new Map();
@@ -180,6 +184,24 @@ export async function handleAgentRequest(context) {
                     if (ids.length > 0) {
                         const expandedCount = expandedParts.filter(p => !p.includes('not found')).length;
                         console.log(`[MEMORY] Expanded ${expandedCount}/${ids.length} memories`);
+                        const teamId = getSyncTeamId();
+                        const user = getCurrentUser();
+                        if (teamId && user && expandedCount > 0) {
+                            const expandedIds = ids.filter((_, i) => !expandedParts[i].includes('not found'));
+                            for (const memoryId of expandedIds) {
+                                reportInjection({
+                                    team_id: teamId,
+                                    user_id: user.id,
+                                    session_id: sessionInfo.sessionId,
+                                    event_id: `${sessionInfo.sessionId}:${Date.now()}:expand:${memoryId}`,
+                                    injection_type: 'expand',
+                                    memory_ids: [memoryId],
+                                    timestamp: new Date().toISOString(),
+                                })
+                                    .then(res => handleInjectionResponse(res, teamId))
+                                    .catch(() => { });
+                            }
+                        }
                     }
                     grovExpandResult = expandedParts.join('\n\n');
                     toolResultBlocks.push({

package/dist/integrations/proxy/utils/usage-warnings.d.ts

@@ -0,0 +1,2 @@
+import type { RecordInjectionResponse } from '@grov/shared';
+export declare function handleInjectionResponse(response: RecordInjectionResponse | null, teamId: string): void;

package/dist/integrations/proxy/utils/usage-warnings.js

@@ -0,0 +1,40 @@
+// Usage warning display for CLI
+// Shows warnings when approaching or exceeding monthly quota
+const SEVERITY = {
+    normal: 0,
+    warning_80: 1,
+    warning_100: 2,
+    overage: 3,
+};
+// Cache: teamId -> last warned status (prevents duplicate warnings)
+const warnedStatus = new Map();
+export function handleInjectionResponse(response, teamId) {
+    if (!response)
+        return;
+    // Period reset - clear cache
+    if (response.status === 'normal') {
+        warnedStatus.delete(teamId);
+        return;
+    }
+    const lastSeverity = SEVERITY[warnedStatus.get(teamId) ?? 'normal'];
+    const currentSeverity = SEVERITY[response.status];
+    // Only warn on escalation
+    if (currentSeverity <= lastSeverity)
+        return;
+    warnedStatus.set(teamId, response.status);
+    const percent = Math.round((response.current_count / response.quota) * 100);
+    const usage = `${response.current_count}/${response.quota}`;
+    switch (response.status) {
+        case 'warning_80':
+            console.log(`[grov] ⚠️  Usage at ${percent}% of monthly quota (${usage} injections)`);
+            break;
+        case 'warning_100':
+            console.log(`[grov] ⚠️  Monthly quota reached (${usage} injections)`);
+            console.log(`[grov]    Overage charges apply after 110% usage`);
+            break;
+        case 'overage':
+            console.log(`[grov] ⚠️  Overage billing now active (${usage} injections)`);
+            console.log(`[grov]    Manage usage: https://grov.dev/settings`);
+            break;
+    }
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "grov",
-  "version": "0.6.16",
+  "version": "0.6.18",
+
   "description": "Collective AI memory for Coding Agents - captures reasoning from sessions and injects context into future sessions",
   "type": "module",
   "main": "dist/cli/index.js",