grov 0.5.9 → 0.5.10

package/dist/proxy/request-processor.js

@@ -2,6 +2,7 @@
 // Reference: plan_proxy_local.md Section 2.1
 import { truncate } from '../lib/utils.js';
 import { fetchTeamMemories } from '../lib/api-client.js';
+import { isDebugMode } from './utils/logging.js';
 /**
  * Build context from CLOUD team memory for injection
  * Fetches memories from Supabase via API (cloud-first approach)
@@ -14,62 +15,36 @@ import { fetchTeamMemories } from '../lib/api-client.js';
  * @returns Formatted context string or null if no memories found
  */
 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)
+            limit: 5,
             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}..."`);
+        // Log injected memories (debug mode only)
+        if (isDebugMode()) {
+            for (const m of memories) {
+                const label = m.goal || m.original_query;
+                const sem = m.semantic_score?.toFixed(2) || '-';
+                const lex = m.lexical_score?.toFixed(2) || '-';
+                const comb = m.combined_score?.toFixed(2) || '-';
+                console.log(`[INJECT] ${label.substring(0, 50)}... (${comb}|${sem}|${lex})`);
+            }
         }
-        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)
+        // Reuse existing formatter
         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
     }
 }
@@ -123,25 +98,32 @@ function formatTeamMemoryContext(tasks, fileReasonings, files) {
                 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
+            // Inject knowledge pairs - handle both formats:
+            // Old format: string[] interleaved (conclusion, insight, conclusion, insight...)
+            // New format: Array<{ tags?, conclusion, insight? }> objects
             if (task.reasoning_trace.length > 0) {
                 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)}`);
+                const entries = task.reasoning_trace.slice(0, maxPairs);
+                for (const entry of entries) {
+                    if (typeof entry === 'string') {
+                        // Old format: plain string - just remove prefix and show
+                        const text = entry.replace(/^(CONCLUSION|INSIGHT):\s*/i, '');
+                        if (text) {
+                            lines.push(`    • ${truncate(text, 120)}`);
+                        }
                     }
-                    // Format insight (indented under conclusion)
-                    if (insight) {
-                        const iText = insight.replace(/^INSIGHT:\s*/i, '');
-                        lines.push(`      → ${truncate(iText, 100)}`);
+                    else if (typeof entry === 'object' && entry !== null) {
+                        // New format: object with tags, conclusion, insight
+                        const cText = entry.conclusion?.replace(/^CONCLUSION:\s*/i, '') || '';
+                        if (cText) {
+                            const prefix = entry.tags ? `[${entry.tags}] ` : '';
+                            lines.push(`    • ${prefix}${truncate(cText, 110)}`);
+                        }
+                        if (entry.insight) {
+                            const iText = entry.insight.replace(/^INSIGHT:\s*/i, '');
+                            lines.push(`      → ${truncate(iText, 100)}`);
+                        }
                     }
                 }
             }
@@ -231,11 +213,19 @@ export function extractLastUserPrompt(messages) {
                 }
             }
         }
-        // Strip system-reminder tags to get clean user content
+        // Strip system-reminder tags and continuation artifacts to get clean user content
         const cleanContent = textContent
+            // Remove actual system-reminder tags
             .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '')
+            // Remove escaped/broken system-reminder artifacts from continuation summaries
+            .replace(/\\n["']?\s*<\/system-reminder>/g, '')
+            .replace(/<\/system-reminder>/g, '')
+            // Remove continuation summary header if it's the entire content
+            .replace(/^This session is being continued from a previous conversation[\s\S]*?Summary:/gi, '')
+            // Clean up leading noise (newlines, quotes, whitespace)
+            .replace(/^[\s\n"'\\]+/, '')
             .trim();
-        if (cleanContent) {
+        if (cleanContent && cleanContent.length > 5) {
             return cleanContent;
         }
     }

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

@@ -2,8 +2,12 @@ import { type TriggerReason } from '../lib/store.js';
 /**
  * Save session to team memory
  * Called on: task complete, subtask complete, session abandoned
+ *
+ * @param sessionId - Session to save
+ * @param triggerReason - Why the save was triggered
+ * @param taskType - Task type for shouldUpdateMemory context (information/planning/implementation)
  */
-export declare function saveToTeamMemory(sessionId: string, triggerReason: TriggerReason): Promise<void>;
+export declare function saveToTeamMemory(sessionId: string, triggerReason: TriggerReason, taskType?: 'information' | 'planning' | 'implementation'): Promise<void>;
 /**
  * Clean up session data after save
  */
@@ -11,4 +15,4 @@ export declare function cleanupSession(sessionId: string): void;
 /**
  * Save and cleanup session (for session end)
  */
-export declare function saveAndCleanupSession(sessionId: string, triggerReason: TriggerReason): Promise<void>;
+export declare function saveAndCleanupSession(sessionId: string, triggerReason: TriggerReason, taskType?: 'information' | 'planning' | 'implementation'): Promise<void>;

package/dist/proxy/response-processor.js

@@ -79,8 +79,12 @@ ${actionLines}
 /**
  * Save session to team memory
  * Called on: task complete, subtask complete, session abandoned
+ *
+ * @param sessionId - Session to save
+ * @param triggerReason - Why the save was triggered
+ * @param taskType - Task type for shouldUpdateMemory context (information/planning/implementation)
  */
-export async function saveToTeamMemory(sessionId, triggerReason) {
+export async function saveToTeamMemory(sessionId, triggerReason, taskType) {
     const sessionState = getSessionState(sessionId);
     if (!sessionState) {
         return;
@@ -98,11 +102,11 @@ export async function saveToTeamMemory(sessionId, triggerReason) {
     // Fire-and-forget cloud sync; never block capture path
     // NOTE: Do NOT invalidate cache after sync - cache persists until CLEAR/Summary/restart
     // Next SESSION will get fresh data, current session keeps its context
-    syncTask(task)
+    syncTask(task, undefined, taskType)
         .then((success) => {
         if (success) {
             markTaskSynced(task.id);
-            console.log(`[SYNC] Task ${task.id.substring(0, 8)} synced to cloud`);
+            console.log(`[SYNC] Task ${task.id.substring(0, 8)} synced to cloud (type=${taskType || 'unknown'})`);
         }
         else {
             setTaskSyncError(task.id, 'Sync not enabled or team not configured');
@@ -120,8 +124,11 @@ export async function saveToTeamMemory(sessionId, triggerReason) {
  * Build task data from session state and steps
  */
 async function buildTaskFromSession(sessionState, steps, triggerReason) {
-    // Aggregate files from steps (tool_use actions)
-    const stepFiles = steps.flatMap(s => s.files);
+    // Aggregate files from steps - ONLY edit/write actions, not read
+    // For shouldUpdateMemory: "files modified" means actual changes, not reads
+    const stepFiles = steps
+        .filter(s => s.action_type === 'edit' || s.action_type === 'write')
+        .flatMap(s => s.files);
     // Also extract file paths mentioned in reasoning text (Claude's text responses)
     const reasoningFiles = steps
         .filter(s => s.reasoning)
@@ -146,9 +153,11 @@ async function buildTaskFromSession(sessionState, steps, triggerReason) {
         return `${s.action_type}: ${s.files.length} files`;
     });
     // Try to use Anthropic Haiku for better reasoning & decisions extraction
-    let reasoningTrace = basicReasoningTrace;
+    let reasoningTrace = basicReasoningTrace; // strings are valid ReasoningTraceEntry
     let decisions = [];
     let constraints = sessionState.constraints || [];
+    let summary = undefined;
+    let systemName = undefined; // Parent system anchor for semantic search
     if (isReasoningExtractionAvailable()) {
         try {
             // Group steps by reasoning to avoid duplicates and preserve action context
@@ -166,6 +175,12 @@ async function buildTaskFromSession(sessionState, steps, triggerReason) {
             }
             if (formattedSteps.length > 50) {
                 const extracted = await extractReasoningAndDecisions(formattedSteps, sessionState.original_goal || '');
+                if (extracted.system_name) {
+                    systemName = extracted.system_name;
+                }
+                if (extracted.summary) {
+                    summary = extracted.summary;
+                }
                 if (extracted.reasoning_trace.length > 0) {
                     reasoningTrace = extracted.reasoning_trace;
                 }
@@ -178,11 +193,14 @@ async function buildTaskFromSession(sessionState, steps, triggerReason) {
             // Fall back to basic extraction
         }
     }
+    const original_query = sessionState.raw_user_prompt || sessionState.original_goal || 'Unknown task';
     return {
         project_path: sessionState.project_path,
         user: sessionState.user_id,
-        original_query: sessionState.original_goal || 'Unknown task',
+        original_query,
         goal: sessionState.original_goal,
+        system_name: systemName, // Parent system anchor for semantic search
+        summary,
         reasoning_trace: reasoningTrace,
         files_touched: filesTouched,
         decisions,
@@ -201,7 +219,7 @@ export function cleanupSession(sessionId) {
 /**
  * Save and cleanup session (for session end)
  */
-export async function saveAndCleanupSession(sessionId, triggerReason) {
-    await saveToTeamMemory(sessionId, triggerReason);
+export async function saveAndCleanupSession(sessionId, triggerReason, taskType) {
+    await saveToTeamMemory(sessionId, triggerReason, taskType);
     cleanupSession(sessionId);
 }

package/dist/proxy/server.js

@@ -358,6 +358,8 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
     const textContent = extractTextContent(response);
     // Extract latest user message from request
     const latestUserMessage = extractGoalFromMessages(requestBody.messages) || '';
+    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
+    // console.log(`[DEBUG] latestUserMessage extracted: "${latestUserMessage.substring(0, 80)}..." (${latestUserMessage.length} chars)`);
     // Get recent steps for context
     const recentSteps = sessionInfo.currentSession
         ? getRecentSteps(sessionInfo.currentSession.session_id, 5)
@@ -394,7 +396,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
             timestamp: Date.now(),
             keepAliveCount: 0,
         });
-        log(`Extended cache: CAPTURE project=${cacheKey.split('/').pop()} size=${rawStr.length} sys=${hasSystem} tools=${hasTools} cache_ctrl=${hasCacheCtrl} msg_pos=${msgPos}`);
+        // Cache entry captured silently
     }
     // If not end_turn (tool_use in progress), skip task orchestration but keep session
     if (!isEndTurn) {
@@ -402,27 +404,22 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
         if (sessionInfo.currentSession) {
             activeSessionId = sessionInfo.currentSession.session_id;
             activeSession = sessionInfo.currentSession;
+            // console.log(`[DEBUG] PATH A: Reusing existing session ${activeSessionId}, raw_user_prompt="${activeSession.raw_user_prompt?.substring(0, 50)}"`);
         }
         else if (!activeSession) {
             // First request, create session without task analysis
+            // NOTE: Don't set original_goal to user prompt - let analyzeTaskContext synthesize it
+            // If we set it here, Haiku will "keep it stable" instead of synthesizing
             const newSessionId = randomUUID();
-            // Extract clean goal summary instead of using raw text
-            let goalSummary = latestUserMessage.substring(0, 500) || 'Task in progress';
-            if (isIntentExtractionAvailable() && latestUserMessage.length > 10) {
-                try {
-                    const intentData = await extractIntent(latestUserMessage);
-                    goalSummary = intentData.goal;
-                }
-                catch {
-                    // Keep fallback goalSummary
-                }
-            }
+            // console.log(`[DEBUG] PATH B: Creating NEW session, raw_user_prompt will be: "${latestUserMessage.substring(0, 50)}"`);
             activeSession = createSessionState({
                 session_id: newSessionId,
                 project_path: sessionInfo.projectPath,
-                original_goal: goalSummary,
+                original_goal: '', // Empty - will be synthesized by analyzeTaskContext later
+                raw_user_prompt: latestUserMessage.substring(0, 500),
                 task_type: 'main',
             });
+            // console.log(`[DEBUG] PATH B: Session created, raw_user_prompt="${activeSession.raw_user_prompt?.substring(0, 50)}"`);
             activeSessionId = newSessionId;
             activeSessions.set(newSessionId, {
                 sessionId: newSessionId,
@@ -443,6 +440,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 msg: 'Task analysis',
                 action: taskAnalysis.action,
                 task_type: taskAnalysis.task_type,
+                goal: taskAnalysis.current_goal?.substring(0, 50),
                 reasoning: taskAnalysis.reasoning,
             });
             // TASK LOG: Analysis result
@@ -450,6 +448,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 sessionId: sessionInfo.sessionId,
                 action: taskAnalysis.action,
                 task_type: taskAnalysis.task_type,
+                goal: taskAnalysis.current_goal || '',
                 reasoning: taskAnalysis.reasoning || '',
                 userMessage: latestUserMessage.substring(0, 80),
                 hasCurrentSession: !!sessionInfo.currentSession,
@@ -473,11 +472,22 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     if (sessionInfo.currentSession) {
                         activeSessionId = sessionInfo.currentSession.session_id;
                         activeSession = sessionInfo.currentSession;
+                        // Update goal if Haiku detected a new instruction from user
+                        // (same task/topic, but new specific instruction)
+                        if (taskAnalysis.current_goal &&
+                            taskAnalysis.current_goal !== activeSession.original_goal &&
+                            latestUserMessage.length > 30) {
+                            updateSessionState(activeSessionId, {
+                                original_goal: taskAnalysis.current_goal,
+                            });
+                            activeSession.original_goal = taskAnalysis.current_goal;
+                        }
                         // TASK LOG: Continue existing session
                         taskLog('ORCHESTRATION_CONTINUE', {
                             sessionId: activeSessionId,
                             source: 'current_session',
                             goal: activeSession.original_goal,
+                            goalUpdated: taskAnalysis.current_goal !== activeSession.original_goal,
                         });
                     }
                     else if (sessionInfo.completedSession) {
@@ -486,6 +496,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         activeSession = sessionInfo.completedSession;
                         updateSessionState(activeSessionId, {
                             status: 'active',
+                            original_goal: taskAnalysis.current_goal || activeSession.original_goal,
                         });
                         activeSession.status = 'active';
                         activeSessions.set(activeSessionId, {
@@ -510,7 +521,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     }
                     // Extract full intent for new task (goal, scope, constraints, keywords)
                     let intentData = {
-                        goal: latestUserMessage.substring(0, 500),
+                        goal: taskAnalysis.current_goal,
                         expected_scope: [],
                         constraints: [],
                         keywords: [],
@@ -540,15 +551,19 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         }
                     }
                     const newSessionId = randomUUID();
+                    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
+                    // console.log(`[DEBUG] PATH C (new_task): Creating session, latestUserMessage="${latestUserMessage.substring(0, 50)}", intentData.goal="${intentData.goal?.substring(0, 50)}"`);
                     activeSession = createSessionState({
                         session_id: newSessionId,
                         project_path: sessionInfo.projectPath,
                         original_goal: intentData.goal,
+                        raw_user_prompt: latestUserMessage.substring(0, 500),
                         expected_scope: intentData.expected_scope,
                         constraints: intentData.constraints,
                         keywords: intentData.keywords,
                         task_type: 'main',
                     });
+                    // console.log(`[DEBUG] PATH C: Session created, raw_user_prompt="${activeSession.raw_user_prompt?.substring(0, 50)}"`);
                     activeSessionId = newSessionId;
                     activeSessions.set(newSessionId, {
                         sessionId: newSessionId,
@@ -580,7 +595,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                             final_response: textContent.substring(0, 10000),
                         });
                         // Save to team memory and mark complete
-                        await saveToTeamMemory(newSessionId, 'complete');
+                        await saveToTeamMemory(newSessionId, 'complete', taskAnalysis.task_type);
                         markSessionCompleted(newSessionId);
                     }
                     else if (taskAnalysis.task_type === 'information' && actions.length > 0) {
@@ -597,7 +612,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 case 'subtask': {
                     // Extract intent for subtask
                     let intentData = {
-                        goal: latestUserMessage.substring(0, 500),
+                        goal: taskAnalysis.current_goal,
                         expected_scope: [],
                         constraints: [],
                         keywords: [],
@@ -623,6 +638,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         session_id: subtaskId,
                         project_path: sessionInfo.projectPath,
                         original_goal: intentData.goal,
+                        raw_user_prompt: latestUserMessage.substring(0, 500),
                         expected_scope: intentData.expected_scope,
                         constraints: intentData.constraints,
                         keywords: intentData.keywords,
@@ -647,7 +663,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 case 'parallel_task': {
                     // Extract intent for parallel task
                     let intentData = {
-                        goal: latestUserMessage.substring(0, 500),
+                        goal: taskAnalysis.current_goal,
                         expected_scope: [],
                         constraints: [],
                         keywords: [],
@@ -673,6 +689,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         session_id: parallelId,
                         project_path: sessionInfo.projectPath,
                         original_goal: intentData.goal,
+                        raw_user_prompt: latestUserMessage.substring(0, 500),
                         expected_scope: intentData.expected_scope,
                         constraints: intentData.constraints,
                         keywords: intentData.keywords,
@@ -698,11 +715,18 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     // Save to team memory and mark as completed (don't delete yet - keep for new_task detection)
                     if (sessionInfo.currentSession) {
                         try {
+                            // Update goal if Haiku synthesized one and current is empty
+                            if (taskAnalysis.current_goal && !sessionInfo.currentSession.original_goal) {
+                                updateSessionState(sessionInfo.currentSession.session_id, {
+                                    original_goal: taskAnalysis.current_goal,
+                                });
+                                sessionInfo.currentSession.original_goal = taskAnalysis.current_goal;
+                            }
                             // Set final_response BEFORE saving so reasoning extraction has the data
                             updateSessionState(sessionInfo.currentSession.session_id, {
                                 final_response: textContent.substring(0, 10000),
                             });
-                            await saveToTeamMemory(sessionInfo.currentSession.session_id, 'complete');
+                            await saveToTeamMemory(sessionInfo.currentSession.session_id, 'complete', taskAnalysis.task_type);
                             markSessionCompleted(sessionInfo.currentSession.session_id);
                             activeSessions.delete(sessionInfo.currentSession.session_id);
                             lastDriftResults.delete(sessionInfo.currentSession.session_id);
@@ -745,34 +769,26 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                         // Example: user asks clarification question, answer is provided in single turn
                         try {
                             const newSessionId = randomUUID();
-                            // Extract clean goal summary instead of using raw text
-                            let goalSummary = latestUserMessage.substring(0, 500);
-                            if (isIntentExtractionAvailable() && latestUserMessage.length > 10) {
-                                try {
-                                    const intentData = await extractIntent(latestUserMessage);
-                                    goalSummary = intentData.goal;
-                                }
-                                catch {
-                                    // Keep fallback goalSummary
-                                }
-                            }
+                            // DEBUG: Commented out for cleaner terminal - uncomment when debugging
+                            // console.log(`[DEBUG] PATH D (instant_complete): latestUserMessage="${latestUserMessage.substring(0, 50)}"`);
                             const instantSession = createSessionState({
                                 session_id: newSessionId,
                                 project_path: sessionInfo.projectPath,
-                                original_goal: goalSummary,
+                                original_goal: taskAnalysis.current_goal || '', // Don't fallback to user prompt
+                                raw_user_prompt: latestUserMessage.substring(0, 500),
                                 task_type: 'main',
                             });
                             // Set final_response for reasoning extraction
                             updateSessionState(newSessionId, {
                                 final_response: textContent.substring(0, 10000),
                             });
-                            await saveToTeamMemory(newSessionId, 'complete');
+                            await saveToTeamMemory(newSessionId, 'complete', taskAnalysis.task_type);
                             markSessionCompleted(newSessionId);
                             logger.info({ msg: 'Instant complete - new task saved immediately', sessionId: newSessionId.substring(0, 8) });
                             // TASK LOG: Instant complete (new task that finished in one turn)
                             taskLog('ORCHESTRATION_TASK_COMPLETE', {
                                 sessionId: newSessionId,
-                                goal: goalSummary,
+                                goal: taskAnalysis.current_goal || '',
                                 source: 'instant_complete',
                             });
                         }
@@ -787,7 +803,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     if (sessionInfo.currentSession) {
                         const parentId = sessionInfo.currentSession.parent_session_id;
                         try {
-                            await saveToTeamMemory(sessionInfo.currentSession.session_id, 'complete');
+                            await saveToTeamMemory(sessionInfo.currentSession.session_id, 'complete', taskAnalysis.task_type);
                             markSessionCompleted(sessionInfo.currentSession.session_id);
                             activeSessions.delete(sessionInfo.currentSession.session_id);
                             lastDriftResults.delete(sessionInfo.currentSession.session_id);
@@ -820,7 +836,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
             // Fall back to existing session or create new with intent extraction
             if (!sessionInfo.currentSession) {
                 let intentData = {
-                    goal: latestUserMessage.substring(0, 500),
+                    goal: '', // Don't copy user prompt - let extractIntent synthesize or leave empty
                     expected_scope: [],
                     constraints: [],
                     keywords: [],
@@ -844,6 +860,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                     session_id: newSessionId,
                     project_path: sessionInfo.projectPath,
                     original_goal: intentData.goal,
+                    raw_user_prompt: latestUserMessage.substring(0, 500),
                     expected_scope: intentData.expected_scope,
                     constraints: intentData.constraints,
                     keywords: intentData.keywords,
@@ -862,7 +879,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
         });
         if (!sessionInfo.currentSession) {
             let intentData = {
-                goal: latestUserMessage.substring(0, 500),
+                goal: '', // Don't copy user prompt - let extractIntent synthesize or leave empty
                 expected_scope: [],
                 constraints: [],
                 keywords: [],
@@ -887,6 +904,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 session_id: newSessionId,
                 project_path: sessionInfo.projectPath,
                 original_goal: intentData.goal,
+                raw_user_prompt: latestUserMessage.substring(0, 500),
                 expected_scope: intentData.expected_scope,
                 constraints: intentData.constraints,
                 keywords: intentData.keywords,
@@ -927,16 +945,32 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
     // === CLEAR MODE PRE-COMPUTE (85% threshold) ===
     // Pre-compute summary before hitting 100% threshold to avoid blocking Haiku call
     const preComputeThreshold = Math.floor(config.TOKEN_CLEAR_THRESHOLD * 0.85);
+    // DEBUG: Commented out for cleaner terminal - uncomment when debugging
+    // console.log('[CLEAR-PRECOMPUTE] ═══════════════════════════════════════');
+    // console.log('[CLEAR-PRECOMPUTE] actualContextSize:', actualContextSize);
+    // console.log('[CLEAR-PRECOMPUTE] preComputeThreshold:', preComputeThreshold);
+    // console.log('[CLEAR-PRECOMPUTE] hasActiveSession:', !!activeSession);
+    // console.log('[CLEAR-PRECOMPUTE] hasPendingSummary:', !!activeSession?.pending_clear_summary);
+    // console.log('[CLEAR-PRECOMPUTE] isSummaryAvailable:', isSummaryAvailable());
+    // console.log('[CLEAR-PRECOMPUTE] shouldPrecompute:',
+    //   !!activeSession &&
+    //   actualContextSize > preComputeThreshold &&
+    //   !activeSession?.pending_clear_summary &&
+    //   isSummaryAvailable());
+    // console.log('[CLEAR-PRECOMPUTE] ═══════════════════════════════════════');
     // Use actualContextSize (cacheCreation + cacheRead) as the real context size
     if (activeSession &&
         actualContextSize > preComputeThreshold &&
         !activeSession.pending_clear_summary &&
         isSummaryAvailable()) {
+        // console.log('[CLEAR-PRECOMPUTE] >>> STARTING SUMMARY GENERATION <<<');
         // Get all validated steps for comprehensive summary
         const allSteps = getValidatedSteps(activeSessionId);
+        // console.log('[CLEAR-PRECOMPUTE] validatedSteps:', allSteps.length);
         // Generate summary asynchronously (fire-and-forget)
         generateSessionSummary(activeSession, allSteps, 15000).then(summary => {
             updateSessionState(activeSessionId, { pending_clear_summary: summary });
+            // console.log('[CLEAR-PRECOMPUTE] >>> SUMMARY SAVED <<<', summary.length, 'chars');
             logger.info({
                 msg: 'CLEAR summary pre-computed',
                 actualContextSize,
@@ -944,6 +978,7 @@ async function postProcessResponse(response, sessionInfo, requestBody, logger, e
                 summaryLength: summary.length,
             });
         }).catch(err => {
+            // console.log('[CLEAR-PRECOMPUTE] >>> SUMMARY FAILED <<<', String(err));
             logger.info({ msg: 'CLEAR summary generation failed', error: String(err) });
         });
     }
@@ -1166,7 +1201,8 @@ export async function startServer(options = {}) {
     // Set debug mode based on flag
     if (options.debug) {
         setDebugMode(true);
-        console.log('[DEBUG] Logging to grov-proxy.log');
+        // DEBUG: Commented out for cleaner terminal - uncomment when debugging
+        // console.log('[DEBUG] Logging to grov-proxy.log');
     }
     const server = createServer();
     // Set server logger for background tasks
@@ -1194,11 +1230,9 @@ export async function startServer(options = {}) {
         if (extendedCacheTimer) {
             clearInterval(extendedCacheTimer);
             extendedCacheTimer = null;
-            log('Extended cache: timer stopped');
         }
         // 2. Clear sensitive cache data
         if (extendedCache.size > 0) {
-            log(`Extended cache: clearing ${extendedCache.size} entries`);
             for (const entry of extendedCache.values()) {
                 for (const key of Object.keys(entry.headers)) {
                     entry.headers[key] = '';

package/dist/proxy/utils/logging.d.ts

@@ -1,6 +1,7 @@
 export declare function setDebugMode(enabled: boolean): void;
+export declare function isDebugMode(): boolean;
 export declare function getNextRequestId(): number;
-export declare function taskLog(event: string, data: Record<string, unknown>): void;
+export declare function taskLog(_event: string, _data: Record<string, unknown>): void;
 interface ProxyLogEntry {
     timestamp: string;
     requestId: number;

package/dist/proxy/utils/logging.js

@@ -8,21 +8,27 @@ const TASK_LOG_PATH = path.join(process.cwd(), 'grov-task.log');
 export function setDebugMode(enabled) {
     debugMode = enabled;
 }
+export function isDebugMode() {
+    return debugMode;
+}
 export function getNextRequestId() {
     return ++requestCounter;
 }
-export function taskLog(event, data) {
+export function taskLog(_event, _data) {
+    // Disabled - minimal logging mode
+    // To re-enable, set DEBUG_TASK_LOG=true
+    if (process.env.DEBUG_TASK_LOG !== 'true')
+        return;
     const timestamp = new Date().toISOString();
-    const sessionId = data.sessionId ? String(data.sessionId).substring(0, 8) : '-';
-    // Format: [timestamp] [session] EVENT: key=value key=value
-    const kvPairs = Object.entries(data)
+    const sessionId = _data.sessionId ? String(_data.sessionId).substring(0, 8) : '-';
+    const kvPairs = Object.entries(_data)
         .filter(([k]) => k !== 'sessionId')
         .map(([k, v]) => {
         const val = typeof v === 'string' ? v.substring(0, 100) : JSON.stringify(v);
         return `${k}=${val}`;
     })
         .join(' | ');
-    const line = `[${timestamp}] [${sessionId}] ${event}: ${kvPairs}\n`;
+    const line = `[${timestamp}] [${sessionId}] ${_event}: ${kvPairs}\n`;
     fs.appendFileSync(TASK_LOG_PATH, line);
 }
 export function proxyLog(entry) {