grov 0.2.3 → 0.5.3

package/dist/proxy/handlers/preprocess.js

@@ -0,0 +1,169 @@
+// Pre-process requests before forwarding to Anthropic
+import { config } from '../config.js';
+import { extractLastUserPrompt, extractFilesFromMessages, buildTeamMemoryContextCloud } from '../request-processor.js';
+import { getSessionState, updateSessionState, markCleared, } from '../../lib/store.js';
+import { isSyncEnabled, getSyncTeamId } from '../../lib/cloud-sync.js';
+import { globalTeamMemoryCache, setTeamMemoryCache, invalidateTeamMemoryCache } from '../cache.js';
+import { buildDynamicInjection, clearSessionTracking } from '../injection/delta-tracking.js';
+import { appendToSystemPrompt } from '../injection/injectors.js';
+// Pending plan summary state - triggers CLEAR-like reset after planning task completes
+let pendingPlanClear = null;
+export function getPendingPlanClear() {
+    return pendingPlanClear;
+}
+export function setPendingPlanClear(value) {
+    pendingPlanClear = value;
+}
+export function clearPendingPlan() {
+    pendingPlanClear = null;
+}
+export async function preProcessRequest(body, sessionInfo, logger, detectRequestType) {
+    const modified = { ...body };
+    // Skip warmup requests - Claude Code sends "Warmup" as health check
+    // No need to do semantic search or cache operations for these
+    const earlyUserPrompt = extractLastUserPrompt(modified.messages || []);
+    if (earlyUserPrompt === 'Warmup') {
+        console.log('[INJECT] Skipping warmup request (no search, no cache)');
+        return modified;
+    }
+    // Detect request type: first, continuation, or retry
+    const requestType = detectRequestType(modified.messages || [], sessionInfo.projectPath);
+    // === NEW ARCHITECTURE: Separate static and dynamic injection ===
+    //
+    // STATIC (system prompt, cached):
+    //   - Team memory from PAST sessions only
+    //   - CLEAR summary when triggered
+    //   -> Uses __grovInjection + injectIntoRawBody()
+    //
+    // DYNAMIC (user message, delta only):
+    //   - Files edited in current session
+    //   - Key decisions with reasoning
+    //   - Drift correction, forced recovery
+    //   -> Uses __grovUserMsgInjection + appendToLastUserMessage()
+    // Get session state
+    const sessionState = getSessionState(sessionInfo.sessionId);
+    // === PLANNING CLEAR: Reset after planning task completes ===
+    // This ensures implementation phase starts fresh with planning context from team memory
+    if (pendingPlanClear && pendingPlanClear.projectPath === sessionInfo.projectPath) {
+        // 1. Empty messages array (fresh start)
+        modified.messages = [];
+        // 2. Inject planning summary into system prompt
+        appendToSystemPrompt(modified, pendingPlanClear.summary);
+        // 3. Rebuild team memory NOW (includes the just-saved planning task)
+        const mentionedFiles = extractFilesFromMessages(modified.messages || []);
+        const userPrompt = extractLastUserPrompt(modified.messages || []);
+        // Use cloud-first approach if sync is enabled
+        let teamContext = null;
+        const teamId = getSyncTeamId();
+        if (isSyncEnabled() && teamId) {
+            console.log(`[INJECT] PLANNING_CLEAR: Using cloud team memory (teamId=${teamId.substring(0, 8)}...)`);
+            teamContext = await buildTeamMemoryContextCloud(teamId, sessionInfo.projectPath, mentionedFiles, userPrompt // For hybrid semantic search
+            );
+        }
+        else {
+            // Sync not enabled - no injection (cloud-first approach)
+            console.log('[INJECT] Sync not enabled. Enable sync for team memory injection.');
+            teamContext = null;
+        }
+        if (teamContext) {
+            modified.__grovInjection = teamContext;
+            modified.__grovInjectionCached = false;
+            // Update cache with fresh team memory
+            setTeamMemoryCache(sessionInfo.projectPath, teamContext);
+        }
+        // 4. Clear the pending plan (one-time use)
+        pendingPlanClear = null;
+        // 5. Clear tracking (fresh start)
+        clearSessionTracking(sessionInfo.sessionId);
+        return modified; // Skip other injections - this is a complete reset
+    }
+    // === CLEAR MODE (100% threshold) ===
+    // If token count exceeds threshold AND we have a pre-computed summary, apply CLEAR
+    if (sessionState) {
+        const currentTokenCount = sessionState.token_count || 0;
+        if (currentTokenCount > config.TOKEN_CLEAR_THRESHOLD &&
+            sessionState.pending_clear_summary) {
+            logger.info({
+                msg: 'CLEAR MODE ACTIVATED - resetting conversation',
+                tokenCount: currentTokenCount,
+                threshold: config.TOKEN_CLEAR_THRESHOLD,
+                summaryLength: sessionState.pending_clear_summary.length,
+            });
+            // 1. Empty messages array (fundamental reset)
+            modified.messages = [];
+            // 2. Inject summary into system prompt (this will cause cache miss - intentional)
+            appendToSystemPrompt(modified, sessionState.pending_clear_summary);
+            // 3. Mark session as cleared
+            markCleared(sessionInfo.sessionId);
+            // 4. Clear pending summary and invalidate GLOBAL team memory cache (new baseline)
+            updateSessionState(sessionInfo.sessionId, { pending_clear_summary: undefined });
+            invalidateTeamMemoryCache(); // Force recalculation on next request (CLEAR mode)
+            // 5. Clear tracking (fresh start after CLEAR)
+            clearSessionTracking(sessionInfo.sessionId);
+            logger.info({ msg: 'CLEAR complete - conversation reset with summary' });
+            return modified; // Skip other injections - this is a complete reset
+        }
+    }
+    // === STATIC INJECTION: Team memory (PAST sessions only) ===
+    // Cached per session - identical across all requests for cache preservation
+    // GLOBAL cache: same team memory for ALL requests (regardless of sessionId changes)
+    // Only recalculate on: first request ever, CLEAR/Summary, project change, proxy restart
+    const isSameProject = globalTeamMemoryCache?.projectPath === sessionInfo.projectPath;
+    if (globalTeamMemoryCache && isSameProject) {
+        // Reuse GLOBAL cached team memory (constant for entire conversation)
+        modified.__grovInjection = globalTeamMemoryCache.content;
+        modified.__grovInjectionCached = true;
+        console.log(`[CACHE] Using global team memory cache, size=${globalTeamMemoryCache.content.length}`);
+    }
+    else {
+        // First request OR project changed OR cache was invalidated: compute team memory
+        const mentionedFiles = extractFilesFromMessages(modified.messages || []);
+        const userPrompt = extractLastUserPrompt(modified.messages || []);
+        // Use cloud-first approach if sync is enabled
+        let teamContext = null;
+        const teamId = getSyncTeamId();
+        if (isSyncEnabled() && teamId) {
+            console.log(`[INJECT] First/cache miss: Using cloud team memory (teamId=${teamId.substring(0, 8)}...)`);
+            teamContext = await buildTeamMemoryContextCloud(teamId, sessionInfo.projectPath, mentionedFiles, userPrompt // For hybrid semantic search
+            );
+        }
+        else {
+            // Sync not enabled - no injection (cloud-first approach)
+            console.log('[INJECT] Sync not enabled. Enable sync for team memory injection.');
+            teamContext = null;
+        }
+        console.log(`[CACHE] Computing team memory (first/new), files=${mentionedFiles.length}, result=${teamContext ? teamContext.length : 'null'}`);
+        if (teamContext) {
+            modified.__grovInjection = teamContext;
+            modified.__grovInjectionCached = false;
+            // Store in GLOBAL cache - stays constant until CLEAR or restart
+            setTeamMemoryCache(sessionInfo.projectPath, teamContext);
+        }
+        else {
+            // No team memory available - clear global cache for this project
+            if (isSameProject) {
+                invalidateTeamMemoryCache();
+            }
+        }
+    }
+    // SKIP dynamic injection for retries and continuations
+    if (requestType !== 'first') {
+        return modified;
+    }
+    // === DYNAMIC INJECTION: User message (delta only) ===
+    // Includes: edited files, key decisions, drift correction, forced recovery
+    // This goes into the LAST user message, not system prompt
+    const dynamicInjection = buildDynamicInjection(sessionInfo.sessionId, sessionState, logger);
+    if (dynamicInjection) {
+        modified.__grovUserMsgInjection = dynamicInjection;
+        logger.info({ msg: 'Dynamic injection ready for user message', size: dynamicInjection.length });
+        // Clear pending corrections after building injection
+        if (sessionState?.pending_correction || sessionState?.pending_forced_recovery) {
+            updateSessionState(sessionInfo.sessionId, {
+                pending_correction: undefined,
+                pending_forced_recovery: undefined,
+            });
+        }
+    }
+    return modified;
+}

package/dist/proxy/injection/delta-tracking.d.ts

@@ -0,0 +1,11 @@
+import type { SessionState } from '../../lib/store.js';
+export interface SessionInjectionTracking {
+    files: Set<string>;
+    decisionIds: Set<string>;
+    reasonings: Set<string>;
+}
+export declare function getOrCreateTracking(sessionId: string): SessionInjectionTracking;
+export declare function clearSessionTracking(sessionId: string): void;
+export declare function buildDynamicInjection(sessionId: string, sessionState: SessionState | null, logger?: {
+    info: (data: Record<string, unknown>) => void;
+}): string | null;

package/dist/proxy/injection/delta-tracking.js

@@ -0,0 +1,93 @@
+// Delta tracking - avoid duplicate injections across requests
+import { getEditedFiles, getKeyDecisions } from '../../lib/store.js';
+import { smartTruncate } from '../../lib/utils.js';
+const sessionInjectionTracking = new Map();
+export function getOrCreateTracking(sessionId) {
+    if (!sessionInjectionTracking.has(sessionId)) {
+        sessionInjectionTracking.set(sessionId, {
+            files: new Set(),
+            decisionIds: new Set(),
+            reasonings: new Set(),
+        });
+    }
+    return sessionInjectionTracking.get(sessionId);
+}
+export function clearSessionTracking(sessionId) {
+    sessionInjectionTracking.delete(sessionId);
+}
+export function buildDynamicInjection(sessionId, sessionState, logger) {
+    const tracking = getOrCreateTracking(sessionId);
+    const parts = [];
+    const debugInfo = {};
+    // 1. Get edited files (delta - not already injected)
+    const allEditedFiles = getEditedFiles(sessionId);
+    const newFiles = allEditedFiles.filter(f => !tracking.files.has(f));
+    debugInfo.totalEditedFiles = allEditedFiles.length;
+    debugInfo.newEditedFiles = newFiles.length;
+    debugInfo.alreadyTrackedFiles = tracking.files.size;
+    if (newFiles.length > 0) {
+        // Track and add to injection
+        newFiles.forEach(f => tracking.files.add(f));
+        const fileNames = newFiles.slice(0, 5).map(f => f.split('/').pop());
+        parts.push(`[EDITED: ${fileNames.join(', ')}]`);
+        debugInfo.editedFilesInjected = fileNames;
+    }
+    // 2. Get key decisions with reasoning (delta - not already injected)
+    const keyDecisions = getKeyDecisions(sessionId, 5);
+    debugInfo.totalKeyDecisions = keyDecisions.length;
+    debugInfo.alreadyTrackedDecisions = tracking.decisionIds.size;
+    const newDecisions = keyDecisions.filter(d => !tracking.decisionIds.has(d.id) &&
+        d.reasoning &&
+        !tracking.reasonings.has(d.reasoning));
+    debugInfo.newKeyDecisions = newDecisions.length;
+    for (const decision of newDecisions.slice(0, 3)) {
+        tracking.decisionIds.add(decision.id);
+        tracking.reasonings.add(decision.reasoning);
+        const truncated = smartTruncate(decision.reasoning, 120);
+        parts.push(`[DECISION: ${truncated}]`);
+        // Log the original and truncated reasoning for debugging
+        if (logger) {
+            logger.info({
+                msg: 'Key decision reasoning extracted',
+                originalLength: decision.reasoning.length,
+                truncatedLength: truncated.length,
+                original: decision.reasoning.substring(0, 200) + (decision.reasoning.length > 200 ? '...' : ''),
+                truncated,
+            });
+        }
+    }
+    debugInfo.decisionsInjected = newDecisions.slice(0, 3).length;
+    // 3. Add drift correction if pending
+    if (sessionState?.pending_correction) {
+        parts.push(`[DRIFT: ${sessionState.pending_correction}]`);
+        debugInfo.hasDriftCorrection = true;
+        debugInfo.driftCorrectionLength = sessionState.pending_correction.length;
+    }
+    // 4. Add forced recovery if pending
+    if (sessionState?.pending_forced_recovery) {
+        parts.push(`[RECOVERY: ${sessionState.pending_forced_recovery}]`);
+        debugInfo.hasForcedRecovery = true;
+        debugInfo.forcedRecoveryLength = sessionState.pending_forced_recovery.length;
+    }
+    // Log debug info
+    if (logger) {
+        logger.info({
+            msg: 'Dynamic injection build details',
+            ...debugInfo,
+            partsCount: parts.length,
+        });
+    }
+    if (parts.length === 0) {
+        return null;
+    }
+    const injection = '---\n[GROV CONTEXT]\n' + parts.join('\n');
+    // Log final injection content
+    if (logger) {
+        logger.info({
+            msg: 'Dynamic injection content',
+            size: injection.length,
+            content: injection,
+        });
+    }
+    return injection;
+}

package/dist/proxy/injection/injectors.d.ts

@@ -0,0 +1,7 @@
+import type { MessagesRequestBody } from '../types.js';
+export declare function appendToLastUserMessage(rawBody: string, injection: string): string;
+export declare function appendToSystemPrompt(body: MessagesRequestBody, textToAppend: string): void;
+export declare function injectIntoRawBody(rawBody: string, injectionText: string): {
+    modified: string;
+    success: boolean;
+};

package/dist/proxy/injection/injectors.js

@@ -0,0 +1,139 @@
+// Injection helpers for modifying request bodies
+export function appendToLastUserMessage(rawBody, injection) {
+    // Find the last occurrence of "role":"user" followed by content
+    // We need to find the content field of the last user message and append to it
+    // Strategy: Find all user messages, get the last one, append to its content
+    // This is tricky because content can be string or array
+    // Simpler approach: Find the last user message's closing content
+    // Look for pattern: "role":"user","content":"..." or "role":"user","content":[...]
+    // Find last "role":"user"
+    const userRolePattern = /"role"\s*:\s*"user"/g;
+    let lastUserMatch = null;
+    let match;
+    while ((match = userRolePattern.exec(rawBody)) !== null) {
+        lastUserMatch = match;
+    }
+    if (!lastUserMatch) {
+        // No user message found, can't inject
+        return rawBody;
+    }
+    // From lastUserMatch position, find the content field
+    const afterRole = rawBody.slice(lastUserMatch.index);
+    // Find "content" field after role
+    const contentMatch = afterRole.match(/"content"\s*:\s*/);
+    if (!contentMatch || contentMatch.index === undefined) {
+        return rawBody;
+    }
+    const contentStartGlobal = lastUserMatch.index + contentMatch.index + contentMatch[0].length;
+    const afterContent = rawBody.slice(contentStartGlobal);
+    // Determine if content is string or array
+    if (afterContent.startsWith('"')) {
+        // String content - find closing quote (handling escapes)
+        let i = 1; // Skip opening quote
+        while (i < afterContent.length) {
+            if (afterContent[i] === '\\') {
+                i += 2; // Skip escaped char
+            }
+            else if (afterContent[i] === '"') {
+                // Found closing quote
+                const insertPos = contentStartGlobal + i;
+                // Insert before closing quote, escape the injection for JSON
+                const escapedInjection = injection
+                    .replace(/\\/g, '\\\\')
+                    .replace(/"/g, '\\"')
+                    .replace(/\n/g, '\\n');
+                return rawBody.slice(0, insertPos) + '\\n\\n' + escapedInjection + rawBody.slice(insertPos);
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    else if (afterContent.startsWith('[')) {
+        // Array content - find last text block and append, or add new text block
+        // Find the closing ] of the content array
+        let depth = 1;
+        let i = 1;
+        while (i < afterContent.length && depth > 0) {
+            const char = afterContent[i];
+            if (char === '[')
+                depth++;
+            else if (char === ']')
+                depth--;
+            else if (char === '"') {
+                // Skip string
+                i++;
+                while (i < afterContent.length && afterContent[i] !== '"') {
+                    if (afterContent[i] === '\\')
+                        i++;
+                    i++;
+                }
+            }
+            i++;
+        }
+        if (depth === 0) {
+            // Found closing bracket at position i-1
+            const insertPos = contentStartGlobal + i - 1;
+            // Add new text block before closing bracket
+            const escapedInjection = injection
+                .replace(/\\/g, '\\\\')
+                .replace(/"/g, '\\"')
+                .replace(/\n/g, '\\n');
+            const newBlock = `,{"type":"text","text":"\\n\\n${escapedInjection}"}`;
+            return rawBody.slice(0, insertPos) + newBlock + rawBody.slice(insertPos);
+        }
+    }
+    // Fallback: couldn't parse, return unchanged
+    return rawBody;
+}
+export function appendToSystemPrompt(body, textToAppend) {
+    if (typeof body.system === 'string') {
+        body.system = body.system + textToAppend;
+    }
+    else if (Array.isArray(body.system)) {
+        // Append as new text block WITHOUT cache_control
+        // Anthropic allows max 4 cache blocks - Claude Code already uses 2+
+        // Grov's injections are small (~2KB) so uncached is fine
+        body.system.push({
+            type: 'text',
+            text: textToAppend,
+        });
+    }
+    else {
+        // No system prompt yet, create as string
+        body.system = textToAppend;
+    }
+}
+export function injectIntoRawBody(rawBody, injectionText) {
+    // Find the system array in the raw JSON
+    // Pattern: "system": [....]
+    const systemMatch = rawBody.match(/"system"\s*:\s*\[/);
+    if (!systemMatch || systemMatch.index === undefined) {
+        return { modified: rawBody, success: false };
+    }
+    // Find the matching closing bracket for the system array
+    const startIndex = systemMatch.index + systemMatch[0].length;
+    let bracketCount = 1;
+    let endIndex = startIndex;
+    for (let i = startIndex; i < rawBody.length && bracketCount > 0; i++) {
+        const char = rawBody[i];
+        if (char === '[')
+            bracketCount++;
+        else if (char === ']')
+            bracketCount--;
+        if (bracketCount === 0) {
+            endIndex = i;
+            break;
+        }
+    }
+    if (bracketCount !== 0) {
+        return { modified: rawBody, success: false };
+    }
+    // Escape the injection text for JSON
+    const escapedText = JSON.stringify(injectionText).slice(1, -1); // Remove outer quotes
+    // Create the new block (without cache_control - will be cache_creation)
+    const newBlock = `,{"type":"text","text":"${escapedText}"}`;
+    // Insert before the closing bracket
+    const modified = rawBody.slice(0, endIndex) + newBlock + rawBody.slice(endIndex);
+    return { modified, success: true };
+}

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

@@ -1,8 +1,15 @@
 /**
- * Build context from team memory for injection
- * Queries tasks and file_reasoning tables
+ * Build context from CLOUD team memory for injection
+ * Fetches memories from Supabase via API (cloud-first approach)
+ * Uses hybrid search (semantic + lexical) when userPrompt is provided
+ *
+ * @param teamId - Team UUID from sync configuration
+ * @param projectPath - Project path to filter by
+ * @param mentionedFiles - Files mentioned in user messages (for boost)
+ * @param userPrompt - User's prompt for semantic search (optional)
+ * @returns Formatted context string or null if no memories found
  */
-export declare function buildTeamMemoryContext(projectPath: string, mentionedFiles: string[]): string | null;
+export declare function buildTeamMemoryContextCloud(teamId: string, projectPath: string, mentionedFiles: string[], userPrompt?: string): Promise<string | null>;
 /**
  * Extract file paths from messages (user messages only, clean text)
  */
@@ -10,3 +17,11 @@ export declare function extractFilesFromMessages(messages: Array<{
     role: string;
     content: unknown;
 }>): string[];
+/**
+ * Extract the last user prompt from messages for semantic search
+ * Returns clean text without system tags
+ */
+export declare function extractLastUserPrompt(messages: Array<{
+    role: string;
+    content: unknown;
+}>): string | undefined;

package/dist/proxy/request-processor.js

@@ -1,31 +1,98 @@
 // Request processor - handles context injection from team memory
 // Reference: plan_proxy_local.md Section 2.1
-import { getTasksForProject, getTasksByFiles, getStepsReasoningByPath, } from '../lib/store.js';
 import { truncate } from '../lib/utils.js';
+import { fetchTeamMemories } from '../lib/api-client.js';
 /**
- * Build context from team memory for injection
- * Queries tasks and file_reasoning tables
+ * Build context from CLOUD team memory for injection
+ * Fetches memories from Supabase via API (cloud-first approach)
+ * Uses hybrid search (semantic + lexical) when userPrompt is provided
+ *
+ * @param teamId - Team UUID from sync configuration
+ * @param projectPath - Project path to filter by
+ * @param mentionedFiles - Files mentioned in user messages (for boost)
+ * @param userPrompt - User's prompt for semantic search (optional)
+ * @returns Formatted context string or null if no memories found
  */
-export function buildTeamMemoryContext(projectPath, mentionedFiles) {
-    // Get recent completed tasks for this project
-    const tasks = getTasksForProject(projectPath, {
-        status: 'complete',
-        limit: 10,
-    });
-    // Get tasks that touched mentioned files
-    const fileTasks = mentionedFiles.length > 0
-        ? getTasksByFiles(projectPath, mentionedFiles, { status: 'complete', limit: 5 })
-        : [];
-    // Get file-level reasoning from steps table (proxy version)
-    const fileReasonings = mentionedFiles.length > 0
-        ? mentionedFiles.flatMap(f => getStepsReasoningByPath(f, 3))
-        : [];
-    // Combine unique tasks
-    const allTasks = [...new Map([...tasks, ...fileTasks].map(t => [t.id, t])).values()];
-    if (allTasks.length === 0 && fileReasonings.length === 0) {
-        return null;
+export async function buildTeamMemoryContextCloud(teamId, projectPath, mentionedFiles, userPrompt) {
+    const startTime = Date.now();
+    const hasContext = userPrompt && userPrompt.trim().length > 0;
+    console.log(`[CLOUD] ═══════════════════════════════════════════════════════════`);
+    console.log(`[CLOUD] buildTeamMemoryContextCloud START`);
+    console.log(`[CLOUD] Team: ${teamId.substring(0, 8)}...`);
+    console.log(`[CLOUD] Project: ${projectPath}`);
+    console.log(`[CLOUD] Prompt: "${hasContext ? userPrompt.substring(0, 60) + '...' : 'N/A'}"`);
+    console.log(`[CLOUD] Files for boost: ${mentionedFiles.length > 0 ? mentionedFiles.join(', ') : 'none'}`);
+    try {
+        // Fetch memories from cloud API (hybrid search if context provided)
+        const fetchStart = Date.now();
+        const memories = await fetchTeamMemories(teamId, projectPath, {
+            status: 'complete',
+            limit: 5, // Max 5 memories for injection (Convex Combination scoring)
+            files: mentionedFiles.length > 0 ? mentionedFiles : undefined,
+            context: hasContext ? userPrompt : undefined,
+            current_files: mentionedFiles.length > 0 ? mentionedFiles : undefined,
+        });
+        const fetchTime = Date.now() - fetchStart;
+        if (memories.length === 0) {
+            console.log(`[CLOUD] No memories found (fetch took ${fetchTime}ms)`);
+            console.log(`[CLOUD] ═══════════════════════════════════════════════════════════`);
+            return null;
+        }
+        console.log(`[CLOUD] ───────────────────────────────────────────────────────────`);
+        console.log(`[CLOUD] Fetched ${memories.length} memories in ${fetchTime}ms`);
+        console.log(`[CLOUD] ───────────────────────────────────────────────────────────`);
+        // Log each memory with scores (if available from hybrid search)
+        for (let i = 0; i < memories.length; i++) {
+            const mem = memories[i];
+            const semScore = typeof mem.semantic_score === 'number' ? mem.semantic_score.toFixed(3) : '-';
+            const lexScore = typeof mem.lexical_score === 'number' ? mem.lexical_score.toFixed(3) : '-';
+            const combScore = typeof mem.combined_score === 'number' ? mem.combined_score.toFixed(3) : '-';
+            const boosted = mem.file_boost_applied ? '🚀' : '  ';
+            const query = String(memories[i].original_query || '').substring(0, 50);
+            const filesCount = memories[i].files_touched?.length || 0;
+            const reasoningCount = memories[i].reasoning_trace?.length || 0;
+            console.log(`[CLOUD] ${i + 1}. ${boosted} [${combScore}] sem=${semScore} lex=${lexScore} | files=${filesCount} reasoning=${reasoningCount}`);
+            console.log(`[CLOUD]    "${query}..."`);
+        }
+        console.log(`[CLOUD] ───────────────────────────────────────────────────────────`);
+        // Convert Memory[] to Task[] format for the existing formatter
+        const tasks = memories.map(memoryToTask);
+        // Reuse existing formatter (no file-level reasoning from cloud yet)
+        const context = formatTeamMemoryContext(tasks, [], mentionedFiles);
+        // Estimate tokens (~4 chars per token)
+        const estimatedTokens = Math.round(context.length / 4);
+        const totalTime = Date.now() - startTime;
+        console.log(`[CLOUD] Context built: ${context.length} chars (~${estimatedTokens} tokens)`);
+        console.log(`[CLOUD] Total time: ${totalTime}ms (fetch: ${fetchTime}ms, format: ${totalTime - fetchTime}ms)`);
+        console.log(`[CLOUD] ═══════════════════════════════════════════════════════════`);
+        return context;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : 'Unknown error';
+        console.error(`[CLOUD] buildTeamMemoryContextCloud failed: ${errorMsg}`);
+        return null; // Fail silent - don't block Claude Code
     }
-    return formatTeamMemoryContext(allTasks, fileReasonings, mentionedFiles);
+}
+/**
+ * Convert Memory (cloud format) to Task (local format)
+ * Used to reuse existing formatTeamMemoryContext function
+ */
+function memoryToTask(memory) {
+    return {
+        id: memory.id,
+        project_path: memory.project_path,
+        user: memory.user_id || undefined,
+        original_query: memory.original_query,
+        goal: memory.goal || undefined,
+        reasoning_trace: memory.reasoning_trace || [],
+        files_touched: memory.files_touched || [],
+        decisions: memory.decisions || [],
+        constraints: memory.constraints || [],
+        status: memory.status,
+        tags: memory.tags || [],
+        linked_commit: memory.linked_commit || undefined,
+        created_at: memory.created_at,
+    };
 }
 /**
  * Format team memory context for injection
@@ -46,21 +113,44 @@ function formatTeamMemoryContext(tasks, fileReasonings, files) {
         }
         lines.push('');
     }
-    // Task context with decisions and constraints
+    // Task context with knowledge pairs and decisions
+    // Inject up to 5 pairs (10 entries) per task for rich context
     if (tasks.length > 0) {
         lines.push('Related past tasks:');
-        for (const task of tasks.slice(0, 5)) {
+        for (const task of tasks.slice(0, 5)) { // Limit to 5 tasks (Convex Combination top results)
             lines.push(`- ${truncate(task.original_query, 60)}`);
             if (task.files_touched.length > 0) {
-                const fileList = task.files_touched.slice(0, 3).map(f => f.split('/').pop()).join(', ');
+                const fileList = task.files_touched.slice(0, 5).map(f => f.split('/').pop()).join(', ');
                 lines.push(`  Files: ${fileList}`);
             }
+            // Inject knowledge pairs (interleaved: conclusion, insight, conclusion, insight...)
+            // Take up to 5 pairs (10 entries) per task
             if (task.reasoning_trace.length > 0) {
-                lines.push(`  Key: ${truncate(task.reasoning_trace[0], 80)}`);
+                lines.push('  Knowledge:');
+                const maxPairs = 5;
+                const maxEntries = maxPairs * 2; // 10 entries
+                const entries = task.reasoning_trace.slice(0, maxEntries);
+                for (let i = 0; i < entries.length; i += 2) {
+                    const conclusion = entries[i];
+                    const insight = entries[i + 1];
+                    // Format conclusion (remove prefix for brevity)
+                    const cText = conclusion?.replace(/^CONCLUSION:\s*/i, '') || '';
+                    if (cText) {
+                        lines.push(`    • ${truncate(cText, 120)}`);
+                    }
+                    // Format insight (indented under conclusion)
+                    if (insight) {
+                        const iText = insight.replace(/^INSIGHT:\s*/i, '');
+                        lines.push(`      → ${truncate(iText, 100)}`);
+                    }
+                }
             }
-            // Include decisions if available
+            // Include decisions (up to 2 per task)
             if (task.decisions && task.decisions.length > 0) {
-                lines.push(`  Decision: ${task.decisions[0].choice} (${truncate(task.decisions[0].reason, 50)})`);
+                const decisionsToShow = task.decisions.slice(0, 2);
+                for (const decision of decisionsToShow) {
+                    lines.push(`  Decision: ${truncate(decision.choice, 60)} (${truncate(decision.reason, 50)})`);
+                }
             }
             // Include constraints if available
             if (task.constraints && task.constraints.length > 0) {
@@ -118,3 +208,36 @@ export function extractFilesFromMessages(messages) {
     }
     return [...new Set(files)];
 }
+/**
+ * Extract the last user prompt from messages for semantic search
+ * Returns clean text without system tags
+ */
+export function extractLastUserPrompt(messages) {
+    // Find last user message
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        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) {
+            return cleanContent;
+        }
+    }
+    return undefined;
+}