grov 0.5.9 → 0.5.10

package/dist/lib/api-client.d.ts

@@ -1,4 +1,4 @@
-import type { Team, Memory, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse } from '@grov/shared';
+import type { Team, Memory, MemorySyncRequest, MemorySyncResponse, DeviceFlowStartResponse, DeviceFlowPollResponse, ReasoningTraceEntry } from '@grov/shared';
 export interface ApiResponse<T> {
     data?: T;
     error?: string;
@@ -47,6 +47,47 @@ export declare function fetchTeamMemories(teamId: string, projectPath: string, o
     context?: string;
     current_files?: string[];
 }): Promise<Memory[]>;
+/**
+ * Input data for match endpoint (memory content for embedding generation)
+ */
+export interface MatchInput {
+    project_path: string;
+    goal?: string;
+    system_name?: string;
+    original_query: string;
+    reasoning_trace?: ReasoningTraceEntry[];
+    decisions?: Array<{
+        aspect?: string;
+        tags?: string;
+        choice: string;
+        reason: string;
+    }>;
+    evolution_steps?: Array<{
+        summary: string;
+        date: string;
+    }>;
+    task_type?: 'information' | 'planning' | 'implementation';
+}
+/**
+ * Response type for match endpoint
+ * Note: Embeddings are now chunk-based and generated in SYNC (not passed from MATCH)
+ */
+export interface MatchResponse {
+    match: Memory | null;
+    combined_score?: number;
+}
+/**
+ * Fetch best matching memory for UPDATE decision
+ * Used by CLI before sync to check if a similar memory exists
+ *
+ * API generates chunks for multi-vector search against stored memory chunks.
+ * SYNC will regenerate chunks when saving (chunks not passed between endpoints).
+ *
+ * @param teamId - Team UUID
+ * @param data - Memory data for chunk generation and search
+ * @returns Match response with memory and score
+ */
+export declare function fetchMatch(teamId: string, data: MatchInput): Promise<MatchResponse>;
 /**
  * Sleep helper for polling
  */

package/dist/lib/api-client.js

@@ -139,26 +139,53 @@ export async function fetchTeamMemories(teamId, projectPath, options) {
         params.set('current_files', files.join(','));
     }
     const url = `/teams/${teamId}/memories?${params.toString()}`;
-    console.log(`[API] fetchTeamMemories: GET ${url}`);
     try {
         const response = await apiRequest('GET', url);
         if (response.error) {
-            console.warn(`[API] fetchTeamMemories failed: ${response.error} (status: ${response.status})`);
+            console.error(`[API-CLIENT] FAILED: ${response.error}`);
             return []; // Fail silent - don't block Claude Code
         }
         if (!response.data || !response.data.memories) {
-            console.log('[API] fetchTeamMemories: No memories returned');
             return [];
         }
-        console.log(`[API] fetchTeamMemories: Got ${response.data.memories.length} memories`);
         return response.data.memories;
     }
     catch (err) {
-        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
-        console.error(`[API] fetchTeamMemories exception: ${errorMsg}`);
+        // const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        // console.error(`[API] fetchTeamMemories exception: ${errorMsg}`);
         return []; // Fail silent - don't block Claude Code
     }
 }
+/**
+ * Fetch best matching memory for UPDATE decision
+ * Used by CLI before sync to check if a similar memory exists
+ *
+ * API generates chunks for multi-vector search against stored memory chunks.
+ * SYNC will regenerate chunks when saving (chunks not passed between endpoints).
+ *
+ * @param teamId - Team UUID
+ * @param data - Memory data for chunk generation and search
+ * @returns Match response with memory and score
+ */
+export async function fetchMatch(teamId, data) {
+    const url = `/teams/${teamId}/memories/match`;
+    try {
+        const response = await apiRequest('POST', url, data);
+        if (response.error) {
+            console.error(`[MATCH-API] FAILED: ${response.error}`);
+            return { match: null };
+        }
+        if (!response.data) {
+            return { match: null };
+        }
+        return response.data;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`[MATCH-API] FAILED: ${errorMsg}`);
+        return { match: null };
+    }
+}
 // ============= Utility Functions =============
 /**
  * Sleep helper for polling

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

@@ -1,9 +1,53 @@
-import type { CreateMemoryInput } from '@grov/shared';
+import type { CreateMemoryInput, Memory } from '@grov/shared';
 import type { Task } from './store.js';
+import type { ExtractedReasoningAndDecisions, ShouldUpdateResult } from './llm-extractor.js';
+/**
+ * Evolution step in memory history
+ */
+export interface EvolutionStep {
+    summary: string;
+    date: string;
+}
+/**
+ * Decision with tracking metadata
+ */
+export interface TrackedDecision {
+    choice: string;
+    reason: string;
+    date?: string;
+    active?: boolean;
+    superseded_by?: {
+        choice: string;
+        reason: string;
+        date: string;
+    };
+}
+/**
+ * Extended memory input with fields for UPDATE path
+ */
+export interface UpdateMemoryInput extends CreateMemoryInput {
+    memory_id?: string;
+    evolution_steps?: EvolutionStep[];
+    reasoning_evolution?: Array<{
+        content: string;
+        date: string;
+    }>;
+}
 /**
  * Convert local Task to CreateMemoryInput for API
  */
 export declare function taskToMemory(task: Task): 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;
 /**
  * Check if sync is enabled and configured
  */
@@ -13,10 +57,20 @@ export declare function isSyncEnabled(): boolean;
  */
 export declare function getSyncTeamId(): string | null;
 /**
- * Sync a single task to the cloud
+ * Sync a single task to the cloud with memory editing support
  * Called when a task is completed
+ *
+ * Flow:
+ * 1. Check for existing match via /match endpoint
+ * 2. If match found: shouldUpdateMemory() decides UPDATE or SKIP
+ * 3. If UPDATE: prepareSyncPayload() merges data
+ * 4. If no match: INSERT new memory
+ *
+ * @param task - The task to sync
+ * @param extractedData - Optional pre-extracted reasoning and decisions
+ * @param taskType - Optional task type for shouldUpdateMemory context
  */
-export declare function syncTask(task: Task): Promise<boolean>;
+export declare function syncTask(task: Task, extractedData?: ExtractedReasoningAndDecisions, taskType?: 'information' | 'planning' | 'implementation'): Promise<boolean>;
 /**
  * Sync multiple tasks with batching and retry
  */

package/dist/lib/cloud-sync.js

@@ -1,7 +1,8 @@
 // Cloud sync logic - Upload memories from local database to API
 // Handles batching, retries, and conversion from Task to Memory format
 import { getSyncStatus, getAccessToken } from './credentials.js';
-import { syncMemories, sleep, getApiUrl } from './api-client.js';
+import { syncMemories, sleep, getApiUrl, fetchMatch } from './api-client.js';
+import { shouldUpdateMemory, isShouldUpdateAvailable } from './llm-extractor.js';
 // Sync configuration
 const SYNC_CONFIG = {
     batchSize: 10, // Number of memories per batch
@@ -17,6 +18,8 @@ export function taskToMemory(task) {
         project_path: task.project_path,
         original_query: task.original_query,
         goal: task.goal,
+        system_name: task.system_name, // Parent anchor for semantic search
+        summary: task.summary,
         reasoning_trace: task.reasoning_trace,
         files_touched: task.files_touched,
         decisions: task.decisions,
@@ -26,6 +29,103 @@ export function taskToMemory(task) {
         linked_commit: task.linked_commit,
     };
 }
+/**
+ * Get today's date in ISO format (full timestamp)
+ */
+function getToday() {
+    return new Date().toISOString();
+}
+/**
+ * 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) {
+    const today = getToday();
+    // 1. Get existing decisions with proper typing
+    const existingDecisions = (existingMemory.decisions || []);
+    // 2. Build lookup for superseded decisions from mapping
+    const supersededMap = new Map(updateResult.superseded_mapping.map(m => [
+        m.old_index,
+        {
+            choice: m.replaced_by_choice,
+            reason: m.replaced_by_reason,
+            date: today,
+        },
+    ]));
+    // 3. Mark superseded decisions as inactive and add superseded_by info
+    const updatedDecisions = existingDecisions.map((d, i) => {
+        const replacement = supersededMap.get(i);
+        if (replacement) {
+            return {
+                ...d,
+                active: false,
+                superseded_by: replacement,
+            };
+        }
+        return {
+            ...d,
+            active: d.active !== false,
+        };
+    });
+    // 4. Append new decisions with date and active flag
+    const newDecisions = newData.decisions.map(d => ({
+        ...d,
+        date: today,
+        active: true,
+    }));
+    const allDecisions = [...updatedDecisions, ...newDecisions];
+    // 4. Handle evolution_steps - use consolidated or existing
+    const existingEvolutionSteps = (existingMemory.evolution_steps || []);
+    const baseEvolutionSteps = updateResult.consolidated_evolution_steps || existingEvolutionSteps;
+    // 5. Append new evolution step if summary provided
+    const evolutionSteps = [...baseEvolutionSteps];
+    if (updateResult.evolution_summary) {
+        evolutionSteps.push({
+            summary: updateResult.evolution_summary,
+            date: today,
+        });
+    }
+    // 6. Handle reasoning_evolution - append condensed old reasoning
+    const existingReasoningEvolution = (existingMemory.reasoning_evolution || []);
+    const reasoningEvolution = [...existingReasoningEvolution];
+    if (updateResult.condensed_old_reasoning) {
+        reasoningEvolution.push({
+            content: updateResult.condensed_old_reasoning,
+            date: today,
+        });
+    }
+    // 7. Truncate arrays to max limits
+    const MAX_DECISIONS = 20;
+    const MAX_EVOLUTION_STEPS = 10;
+    const MAX_REASONING_EVOLUTION = 5;
+    const finalDecisions = allDecisions.slice(-MAX_DECISIONS);
+    const finalEvolutionSteps = evolutionSteps.slice(-MAX_EVOLUTION_STEPS);
+    const finalReasoningEvolution = reasoningEvolution.slice(-MAX_REASONING_EVOLUTION);
+    // 8. Build final payload
+    return {
+        memory_id: existingMemory.id, // Triggers UPDATE path in API
+        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
+        files_touched: task.files_touched,
+        decisions: finalDecisions,
+        constraints: task.constraints,
+        tags: task.tags,
+        status: task.status,
+        linked_commit: task.linked_commit,
+        evolution_steps: finalEvolutionSteps,
+        reasoning_evolution: finalReasoningEvolution,
+    };
+}
 /**
  * Check if sync is enabled and configured
  */
@@ -41,10 +141,20 @@ export function getSyncTeamId() {
     return status?.teamId || null;
 }
 /**
- * Sync a single task to the cloud
+ * Sync a single task to the cloud with memory editing support
  * Called when a task is completed
+ *
+ * Flow:
+ * 1. Check for existing match via /match endpoint
+ * 2. If match found: shouldUpdateMemory() decides UPDATE or SKIP
+ * 3. If UPDATE: prepareSyncPayload() merges data
+ * 4. If no match: INSERT new memory
+ *
+ * @param task - The task to sync
+ * @param extractedData - Optional pre-extracted reasoning and decisions
+ * @param taskType - Optional task type for shouldUpdateMemory context
  */
-export async function syncTask(task) {
+export async function syncTask(task, extractedData, taskType) {
     if (!isSyncEnabled()) {
         return false;
     }
@@ -57,11 +167,71 @@ export async function syncTask(task) {
         return false;
     }
     try {
-        const memory = taskToMemory(task);
-        const result = await syncMemories(teamId, { memories: [memory] });
+        const taskId = task.id.substring(0, 8);
+        // Build effective extracted data from task if not provided
+        const effectiveExtractedData = extractedData || ((task.reasoning_trace.length > 0 || task.decisions.length > 0)
+            ? {
+                system_name: task.system_name || null,
+                summary: task.summary || null,
+                reasoning_trace: task.reasoning_trace,
+                decisions: task.decisions,
+            }
+            : undefined);
+        // Step 1: Check for existing match
+        const matchResult = await fetchMatch(teamId, {
+            project_path: task.project_path,
+            goal: task.goal,
+            original_query: task.original_query,
+            reasoning_trace: effectiveExtractedData?.reasoning_trace || task.reasoning_trace,
+            decisions: effectiveExtractedData?.decisions || task.decisions,
+            task_type: taskType,
+        });
+        // Step 2: If no match, INSERT as new memory
+        if (!matchResult.match) {
+            const memory = taskToMemory(task);
+            const result = await syncMemories(teamId, { memories: [memory] });
+            console.log(`[SYNC] ${taskId} -> INSERT ${result.synced === 1 ? 'OK' : 'FAILED'}`);
+            return result.synced === 1;
+        }
+        const matchedId = matchResult.match.id.substring(0, 8);
+        const score = matchResult.combined_score?.toFixed(3) || '-';
+        // If shouldUpdateMemory is not available or no extracted data, INSERT anyway
+        if (!isShouldUpdateAvailable() || !effectiveExtractedData) {
+            const memory = taskToMemory(task);
+            const result = await syncMemories(teamId, { memories: [memory] });
+            console.log(`[SYNC] ${taskId} -> INSERT (no haiku) ${result.synced === 1 ? 'OK' : 'FAILED'}`);
+            return result.synced === 1;
+        }
+        // Build session context for shouldUpdateMemory
+        const sessionContext = {
+            task_type: taskType || 'implementation',
+            original_query: task.original_query,
+            files_touched: task.files_touched,
+        };
+        // Call shouldUpdateMemory to decide
+        const updateResult = await shouldUpdateMemory({
+            id: matchResult.match.id,
+            goal: matchResult.match.goal,
+            decisions: matchResult.match.decisions || [],
+            reasoning_trace: matchResult.match.reasoning_trace || [],
+            evolution_steps: (matchResult.match.evolution_steps || []),
+            files_touched: matchResult.match.files_touched || [],
+        }, effectiveExtractedData, sessionContext);
+        // If should NOT update, skip sync entirely
+        if (!updateResult.should_update) {
+            console.log(`[SYNC] ${taskId} -> SKIP (matched ${matchedId}, score=${score})`);
+            return true;
+        }
+        // Prepare payload for UPDATE
+        const payload = prepareSyncPayload(matchResult.match, effectiveExtractedData, updateResult, task);
+        // Sync with memory_id for UPDATE path
+        const result = await syncMemories(teamId, { memories: [payload] });
+        console.log(`[SYNC] ${taskId} -> UPDATE ${matchedId} (score=${score}) ${result.synced === 1 ? 'OK' : 'FAILED'}`);
         return result.synced === 1;
     }
-    catch {
+    catch (err) {
+        const msg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`[SYNC] Error: ${msg}`);
         return false;
     }
 }

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

@@ -1,4 +1,5 @@
 import type { SessionState, StepRecord } from './store.js';
+import type { ReasoningTraceEntry } from '@grov/shared';
 export interface ExtractedIntent {
     goal: string;
     expected_scope: string[];
@@ -32,6 +33,7 @@ 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;
@@ -54,8 +56,12 @@ export declare function isTaskAnalysisAvailable(): boolean;
  */
 export declare function analyzeTaskContext(currentSession: SessionState | null, latestUserMessage: string, recentSteps: StepRecord[], assistantResponse: string, conversationHistory?: ConversationMessage[]): Promise<TaskAnalysis>;
 export interface ExtractedReasoningAndDecisions {
-    reasoning_trace: string[];
+    system_name: string | null;
+    summary: string | null;
+    reasoning_trace: ReasoningTraceEntry[];
     decisions: Array<{
+        aspect?: string;
+        tags?: string;
         choice: string;
         reason: string;
     }>;
@@ -72,3 +78,59 @@ export declare function isReasoningExtractionAvailable(): boolean;
  * @param originalGoal - The original task goal
  */
 export declare function extractReasoningAndDecisions(formattedSteps: string, originalGoal: string): Promise<ExtractedReasoningAndDecisions>;
+/**
+ * Evolution step in memory history
+ */
+export interface EvolutionStep {
+    summary: string;
+    date: string;
+}
+/**
+ * Mapping entry for superseded decisions
+ */
+export interface SupersededMapping {
+    old_index: number;
+    replaced_by_choice: string;
+    replaced_by_reason: string;
+}
+/**
+ * Result from shouldUpdateMemory decision
+ */
+export interface ShouldUpdateResult {
+    should_update: boolean;
+    reason: string;
+    superseded_mapping: SupersededMapping[];
+    condensed_old_reasoning: string | null;
+    evolution_summary: string | null;
+    consolidated_evolution_steps?: EvolutionStep[];
+}
+/**
+ * Existing memory structure (from API match response)
+ */
+export interface ExistingMemory {
+    id: string;
+    goal?: string | null;
+    decisions: Array<{
+        tags?: string;
+        choice: string;
+        reason: string;
+        date?: string;
+        active?: boolean;
+    }>;
+    reasoning_trace: ReasoningTraceEntry[];
+    evolution_steps: EvolutionStep[];
+    files_touched: string[];
+}
+/**
+ * Session context for update decision
+ */
+export interface SessionContext {
+    task_type: 'information' | 'planning' | 'implementation';
+    original_query: string;
+    files_touched: string[];
+}
+/**
+ * Check if shouldUpdateMemory is available
+ */
+export declare function isShouldUpdateAvailable(): boolean;
+export declare function shouldUpdateMemory(existingMemory: ExistingMemory, newData: ExtractedReasoningAndDecisions, sessionContext: SessionContext): Promise<ShouldUpdateResult>;