grov 0.2.3 → 0.5.2

package/dist/lib/store.js

@@ -70,6 +70,8 @@ export function initDatabase() {
       turn_number INTEGER,
       tags JSON DEFAULT '[]',
       created_at TEXT NOT NULL,
+      synced_at TEXT,
+      sync_error TEXT,
       FOREIGN KEY (parent_task_id) REFERENCES tasks(id)
     );
 
@@ -90,6 +92,14 @@ export function initDatabase() {
         db.exec(`ALTER TABLE tasks ADD COLUMN trigger_reason TEXT`);
     }
     catch { /* column exists */ }
+    try {
+        db.exec(`ALTER TABLE tasks ADD COLUMN synced_at TEXT`);
+    }
+    catch { /* column exists */ }
+    try {
+        db.exec(`ALTER TABLE tasks ADD COLUMN sync_error TEXT`);
+    }
+    catch { /* column exists */ }
     // Create session_states table (temporary per-session tracking)
     db.exec(`
     CREATE TABLE IF NOT EXISTS session_states (
@@ -112,6 +122,7 @@ export function initDatabase() {
       completed_at TEXT,
       parent_session_id TEXT,
       task_type TEXT DEFAULT 'main' CHECK(task_type IN ('main', 'subtask', 'parallel')),
+      pending_correction TEXT,
       FOREIGN KEY (parent_session_id) REFERENCES session_states(session_id)
     );
 
@@ -264,6 +275,18 @@ export function initDatabase() {
     if (!existingColumns.has('drift_warnings')) {
         db.exec(`ALTER TABLE session_states ADD COLUMN drift_warnings JSON DEFAULT '[]'`);
     }
+    if (!existingColumns.has('pending_correction')) {
+        db.exec(`ALTER TABLE session_states ADD COLUMN pending_correction TEXT`);
+    }
+    if (!existingColumns.has('pending_clear_summary')) {
+        db.exec(`ALTER TABLE session_states ADD COLUMN pending_clear_summary TEXT`);
+    }
+    if (!existingColumns.has('pending_forced_recovery')) {
+        db.exec(`ALTER TABLE session_states ADD COLUMN pending_forced_recovery TEXT`);
+    }
+    if (!existingColumns.has('final_response')) {
+        db.exec(`ALTER TABLE session_states ADD COLUMN final_response TEXT`);
+    }
     // Create steps table (action log for current session)
     db.exec(`
     CREATE TABLE IF NOT EXISTS steps (
@@ -368,22 +391,24 @@ export function createTask(input) {
         parent_task_id: input.parent_task_id,
         turn_number: input.turn_number,
         tags: input.tags || [],
-        created_at: new Date().toISOString()
+        created_at: new Date().toISOString(),
+        synced_at: null,
+        sync_error: null
     };
     const stmt = database.prepare(`
     INSERT INTO tasks (
       id, project_path, user, original_query, goal,
       reasoning_trace, files_touched, decisions, constraints,
       status, trigger_reason, linked_commit,
-      parent_task_id, turn_number, tags, created_at
+      parent_task_id, turn_number, tags, created_at, synced_at, sync_error
     ) VALUES (
       ?, ?, ?, ?, ?,
       ?, ?, ?, ?,
       ?, ?, ?,
-      ?, ?, ?, ?
+      ?, ?, ?, ?, ?, ?
     )
   `);
-    stmt.run(task.id, task.project_path, task.user || null, task.original_query, task.goal || null, JSON.stringify(task.reasoning_trace), JSON.stringify(task.files_touched), JSON.stringify(task.decisions), JSON.stringify(task.constraints), task.status, task.trigger_reason || null, task.linked_commit || null, task.parent_task_id || null, task.turn_number || null, JSON.stringify(task.tags), task.created_at);
+    stmt.run(task.id, task.project_path, task.user || null, task.original_query, task.goal || null, JSON.stringify(task.reasoning_trace), JSON.stringify(task.files_touched), JSON.stringify(task.decisions), JSON.stringify(task.constraints), task.status, task.trigger_reason || null, task.linked_commit || null, task.parent_task_id || null, task.turn_number || null, JSON.stringify(task.tags), task.created_at, task.synced_at, task.sync_error);
     return task;
 }
 /**
@@ -468,6 +493,36 @@ export function getTaskCount(projectPath) {
     const row = stmt.get(projectPath);
     return row?.count ?? 0;
 }
+/**
+ * Get unsynced tasks for a project (synced_at is NULL)
+ */
+export function getUnsyncedTasks(projectPath, limit) {
+    const database = initDatabase();
+    let sql = 'SELECT * FROM tasks WHERE project_path = ? AND synced_at IS NULL ORDER BY created_at DESC';
+    const params = [projectPath];
+    if (limit) {
+        sql += ' LIMIT ?';
+        params.push(limit);
+    }
+    const stmt = database.prepare(sql);
+    const rows = stmt.all(...params);
+    return rows.map(rowToTask);
+}
+/**
+ * Mark a task as synced and clear any previous sync error
+ */
+export function markTaskSynced(id) {
+    const database = initDatabase();
+    const now = new Date().toISOString();
+    database.prepare('UPDATE tasks SET synced_at = ?, sync_error = NULL WHERE id = ?').run(now, id);
+}
+/**
+ * Record a sync error for a task
+ */
+export function setTaskSyncError(id, error) {
+    const database = initDatabase();
+    database.prepare('UPDATE tasks SET sync_error = ? WHERE id = ?').run(error, id);
+}
 /**
  * Safely parse JSON with fallback to empty array.
  */
@@ -502,7 +557,9 @@ function rowToTask(row) {
         parent_task_id: row.parent_task_id,
         turn_number: row.turn_number,
         tags: safeJsonParse(row.tags, []),
-        created_at: row.created_at
+        created_at: row.created_at,
+        synced_at: row.synced_at,
+        sync_error: row.sync_error
     };
 }
 // ============================================
@@ -631,6 +688,22 @@ export function updateSessionState(sessionId, updates) {
         setClauses.push('status = ?');
         params.push(updates.status);
     }
+    if (updates.pending_correction !== undefined) {
+        setClauses.push('pending_correction = ?');
+        params.push(updates.pending_correction || null);
+    }
+    if (updates.pending_forced_recovery !== undefined) {
+        setClauses.push('pending_forced_recovery = ?');
+        params.push(updates.pending_forced_recovery || null);
+    }
+    if (updates.pending_clear_summary !== undefined) {
+        setClauses.push('pending_clear_summary = ?');
+        params.push(updates.pending_clear_summary || null);
+    }
+    if (updates.final_response !== undefined) {
+        setClauses.push('final_response = ?');
+        params.push(updates.final_response || null);
+    }
     // Always update last_update
     setClauses.push('last_update = ?');
     params.push(new Date().toISOString());
@@ -729,6 +802,10 @@ function rowToSessionState(row) {
         completed_at: row.completed_at,
         parent_session_id: row.parent_session_id,
         task_type: row.task_type || 'main',
+        pending_correction: row.pending_correction,
+        pending_forced_recovery: row.pending_forced_recovery,
+        pending_clear_summary: row.pending_clear_summary,
+        final_response: row.final_response,
     };
 }
 // ============================================
@@ -974,6 +1051,43 @@ export function getValidatedSteps(sessionId) {
     const rows = stmt.all(sessionId);
     return rows.map(rowToStep);
 }
+/**
+ * Get key decision steps for a session (is_key_decision = 1)
+ * Used for user message injection - important decisions with reasoning
+ */
+export function getKeyDecisions(sessionId, limit = 5) {
+    const database = initDatabase();
+    const stmt = database.prepare(`SELECT * FROM steps
+     WHERE session_id = ? AND is_key_decision = 1 AND reasoning IS NOT NULL
+     ORDER BY timestamp DESC
+     LIMIT ?`);
+    const rows = stmt.all(sessionId, limit);
+    return rows.map(rowToStep);
+}
+/**
+ * Get edited files for a session (action_type IN ('edit', 'write'))
+ * Used for user message injection - prevent re-work
+ */
+export function getEditedFiles(sessionId) {
+    const database = initDatabase();
+    const stmt = database.prepare(`SELECT DISTINCT files FROM steps
+     WHERE session_id = ? AND action_type IN ('edit', 'write')
+     ORDER BY timestamp DESC`);
+    const rows = stmt.all(sessionId);
+    const allFiles = [];
+    for (const row of rows) {
+        try {
+            const files = JSON.parse(row.files || '[]');
+            if (Array.isArray(files)) {
+                allFiles.push(...files);
+            }
+        }
+        catch {
+            // Skip invalid JSON
+        }
+    }
+    return [...new Set(allFiles)];
+}
 /**
  * Delete steps for a session
  */
@@ -1132,19 +1246,27 @@ export function getKeyDecisionSteps(sessionId, limit = 5) {
 }
 /**
  * Get steps reasoning by file path (for proxy team memory injection)
- * Searches across ALL sessions, returns file-level reasoning from steps table
+ * Searches across sessions, returns file-level reasoning from steps table
+ * @param excludeSessionId - Optional session ID to exclude (for filtering current session)
  */
-export function getStepsReasoningByPath(filePath, limit = 5) {
+export function getStepsReasoningByPath(filePath, limit = 5, excludeSessionId) {
     const database = initDatabase();
     // Search steps where files JSON contains this path and reasoning exists
     const pattern = `%"${escapeLikePattern(filePath)}"%`;
-    const rows = database.prepare(`
+    let sql = `
     SELECT files, reasoning
     FROM steps
     WHERE files LIKE ? AND reasoning IS NOT NULL AND reasoning != ''
-    ORDER BY timestamp DESC
-    LIMIT ?
-  `).all(pattern, limit);
+  `;
+    const params = [pattern];
+    // Exclude current session if specified (for team memory from PAST sessions only)
+    if (excludeSessionId) {
+        sql += ` AND session_id != ?`;
+        params.push(excludeSessionId);
+    }
+    sql += ` ORDER BY timestamp DESC LIMIT ?`;
+    params.push(limit);
+    const rows = database.prepare(sql).all(...params);
     return rows.map(row => {
         const files = safeJsonParse(row.files, []);
         // Find the matching file path from the files array

package/dist/lib/utils.d.ts

@@ -5,6 +5,11 @@
  * Truncate a string to a maximum length, adding ellipsis if truncated.
  */
 export declare function truncate(str: string, maxLength: number): string;
+/**
+ * Smart truncate: cleans markdown noise, prefers sentence/punctuation boundaries.
+ * Used for reasoning content that may contain markdown tables, bullets, etc.
+ */
+export declare function smartTruncate(text: string, maxLen?: number): string;
 /**
  * Capitalize the first letter of a string.
  */

package/dist/lib/utils.js

@@ -9,6 +9,51 @@ export function truncate(str, maxLength) {
         return str;
     return str.substring(0, maxLength - 3) + '...';
 }
+/**
+ * Smart truncate: cleans markdown noise, prefers sentence/punctuation boundaries.
+ * Used for reasoning content that may contain markdown tables, bullets, etc.
+ */
+export function smartTruncate(text, maxLen = 120) {
+    // 1. Clean markdown noise
+    let clean = text
+        .replace(/\|[^|]+\|/g, '') // markdown table cells
+        .replace(/^[-*]\s*/gm, '') // bullet points
+        .replace(/#{1,6}\s*/g, '') // headers
+        .replace(/\n+/g, ' ') // newlines to space
+        .replace(/\s+/g, ' ') // multiple spaces to one
+        .trim();
+    // 2. If short enough, return as-is
+    if (clean.length <= maxLen)
+        return clean;
+    // 3. Try to keep complete sentences
+    const sentences = clean.match(/[^.!?]+[.!?]+/g) || [];
+    let result = '';
+    for (const sentence of sentences) {
+        if ((result + sentence).length <= maxLen) {
+            result += sentence;
+        }
+        else {
+            break;
+        }
+    }
+    // 4. If we got at least one meaningful sentence, return it
+    if (result.length > 20)
+        return result.trim();
+    // 5. Fallback: find punctuation boundary
+    const truncated = clean.slice(0, maxLen);
+    const breakPoints = [
+        truncated.lastIndexOf('. '),
+        truncated.lastIndexOf(', '),
+        truncated.lastIndexOf('; '),
+        truncated.lastIndexOf(': '),
+        truncated.lastIndexOf(' - '),
+        truncated.lastIndexOf(' '),
+    ].filter(p => p > maxLen * 0.6);
+    const cutPoint = breakPoints.length > 0
+        ? Math.max(...breakPoints)
+        : truncated.lastIndexOf(' ');
+    return truncated.slice(0, cutPoint > 0 ? cutPoint : maxLen).trim() + '...';
+}
 /**
  * Capitalize the first letter of a string.
  */

package/dist/proxy/action-parser.d.ts

@@ -10,9 +10,11 @@ export interface AnthropicResponse {
     usage: {
         input_tokens: number;
         output_tokens: number;
+        cache_creation_input_tokens?: number;
+        cache_read_input_tokens?: number;
     };
 }
-export type ContentBlock = TextBlock | ToolUseBlock;
+export type ContentBlock = TextBlock | ToolUseBlock | ThinkingBlock;
 export interface TextBlock {
     type: 'text';
     text: string;
@@ -23,6 +25,10 @@ export interface ToolUseBlock {
     name: string;
     input: Record<string, unknown>;
 }
+export interface ThinkingBlock {
+    type: 'thinking';
+    thinking: string;
+}
 export interface ParsedAction {
     toolName: string;
     toolId: string;
@@ -37,12 +43,14 @@ export interface ParsedAction {
  */
 export declare function parseToolUseBlocks(response: AnthropicResponse): ParsedAction[];
 /**
- * Extract token usage from response
+ * Extract token usage from response (including cache metrics)
  */
 export declare function extractTokenUsage(response: AnthropicResponse): {
     inputTokens: number;
     outputTokens: number;
     totalTokens: number;
+    cacheCreation: number;
+    cacheRead: number;
 };
 /**
  * Check if response contains any file-modifying actions

package/dist/proxy/action-parser.js

@@ -132,13 +132,15 @@ function extractPathFromGlobPattern(pattern) {
     return nonGlobParts.length > 0 ? nonGlobParts.join('/') : null;
 }
 /**
- * Extract token usage from response
+ * Extract token usage from response (including cache metrics)
  */
 export function extractTokenUsage(response) {
     return {
         inputTokens: response.usage.input_tokens,
         outputTokens: response.usage.output_tokens,
-        totalTokens: response.usage.input_tokens + response.usage.output_tokens
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        cacheCreation: response.usage.cache_creation_input_tokens || 0,
+        cacheRead: response.usage.cache_read_input_tokens || 0,
     };
 }
 /**

package/dist/proxy/forwarder.d.ts

@@ -4,6 +4,7 @@ export interface ForwardResult {
     headers: Record<string, string | string[]>;
     body: AnthropicResponse | Record<string, unknown>;
     rawBody: string;
+    wasSSE: boolean;
 }
 export interface ForwardError {
     type: 'timeout' | 'network' | 'parse' | 'unknown';
@@ -13,11 +14,16 @@ export interface ForwardError {
 /**
  * Forward request to Anthropic API
  * Buffers full response for processing
+ *
+ * @param body - Parsed body for logging
+ * @param headers - Request headers
+ * @param logger - Optional logger
+ * @param rawBody - Raw request bytes (preserves exact bytes for cache)
  */
 export declare function forwardToAnthropic(body: Record<string, unknown>, headers: Record<string, string | string[] | undefined>, logger?: {
     info: (msg: string, data?: Record<string, unknown>) => void;
     error: (msg: string, data?: Record<string, unknown>) => void;
-}): Promise<ForwardResult>;
+}, rawBody?: Buffer): Promise<ForwardResult>;
 /**
  * Check if error is a ForwardError
  */

package/dist/proxy/forwarder.js

@@ -10,13 +10,139 @@ const agent = new Agent({
     autoSelectFamilyAttemptTimeout: 500, // Try next address family after 500ms
 });
 import { config, buildSafeHeaders, maskSensitiveValue } from './config.js';
+/**
+ * Parse SSE stream and reconstruct final message
+ * SSE format: "event: <type>\ndata: <json>\n\n"
+ */
+function parseSSEResponse(sseText) {
+    const lines = sseText.split('\n');
+    let message = null;
+    const contentBlocks = [];
+    const contentDeltas = new Map();
+    let finalUsage = null;
+    let stopReason = null;
+    let currentEvent = '';
+    let currentData = '';
+    for (const line of lines) {
+        if (line.startsWith('event: ')) {
+            currentEvent = line.slice(7).trim();
+        }
+        else if (line.startsWith('data: ')) {
+            currentData = line.slice(6);
+            try {
+                const data = JSON.parse(currentData);
+                switch (data.type) {
+                    case 'message_start':
+                        // Initialize message from message_start event
+                        message = data.message;
+                        break;
+                    case 'content_block_start':
+                        // Add new content block
+                        if (data.content_block) {
+                            contentBlocks[data.index] = data.content_block;
+                            if (data.content_block.type === 'text') {
+                                contentDeltas.set(data.index, []);
+                            }
+                            else if (data.content_block.type === 'thinking') {
+                                // Initialize thinking with empty string, will accumulate via deltas
+                                contentBlocks[data.index] = { type: 'thinking', thinking: '' };
+                            }
+                        }
+                        break;
+                    case 'content_block_delta':
+                        // Accumulate text deltas
+                        if (data.delta?.type === 'text_delta' && data.delta.text) {
+                            const deltas = contentDeltas.get(data.index) || [];
+                            deltas.push(data.delta.text);
+                            contentDeltas.set(data.index, deltas);
+                        }
+                        else if (data.delta?.type === 'thinking_delta' && data.delta.thinking) {
+                            // Handle thinking blocks
+                            const block = contentBlocks[data.index];
+                            if (block && block.type === 'thinking') {
+                                block.thinking += data.delta.thinking;
+                            }
+                        }
+                        else if (data.delta?.type === 'input_json_delta' && data.delta.partial_json) {
+                            // Handle tool input streaming
+                            const block = contentBlocks[data.index];
+                            if (block && block.type === 'tool_use') {
+                                // Accumulate partial JSON - will need to parse at the end
+                                const partialKey = `tool_partial_${data.index}`;
+                                const existing = contentDeltas.get(data.index) || [];
+                                existing.push(data.delta.partial_json);
+                                contentDeltas.set(data.index, existing);
+                            }
+                        }
+                        break;
+                    case 'message_delta':
+                        // Final usage and stop_reason
+                        if (data.usage) {
+                            finalUsage = data.usage;
+                        }
+                        if (data.delta?.stop_reason) {
+                            stopReason = data.delta.stop_reason;
+                        }
+                        break;
+                }
+            }
+            catch {
+                // Ignore unparseable data lines
+            }
+        }
+    }
+    if (!message) {
+        return null;
+    }
+    // Reconstruct content blocks with accumulated text/input
+    for (let i = 0; i < contentBlocks.length; i++) {
+        const block = contentBlocks[i];
+        if (!block)
+            continue;
+        const deltas = contentDeltas.get(i);
+        if (deltas && deltas.length > 0) {
+            if (block.type === 'text') {
+                block.text = deltas.join('');
+            }
+            else if (block.type === 'tool_use') {
+                // Parse accumulated partial JSON for tool input
+                try {
+                    const fullJson = deltas.join('');
+                    block.input = JSON.parse(fullJson);
+                }
+                catch {
+                    // Keep original input if parsing fails
+                }
+            }
+        }
+    }
+    // Build final response
+    const response = {
+        id: message.id || '',
+        type: 'message',
+        role: 'assistant',
+        content: contentBlocks.filter(Boolean),
+        model: message.model || '',
+        stop_reason: stopReason,
+        stop_sequence: null,
+        usage: finalUsage || message.usage || { input_tokens: 0, output_tokens: 0 },
+    };
+    return response;
+}
 /**
  * Forward request to Anthropic API
  * Buffers full response for processing
+ *
+ * @param body - Parsed body for logging
+ * @param headers - Request headers
+ * @param logger - Optional logger
+ * @param rawBody - Raw request bytes (preserves exact bytes for cache)
  */
-export async function forwardToAnthropic(body, headers, logger) {
+export async function forwardToAnthropic(body, headers, logger, rawBody) {
     const targetUrl = `${config.ANTHROPIC_BASE_URL}/v1/messages`;
     const safeHeaders = buildSafeHeaders(headers);
+    // Use raw bytes if available (preserves cache), otherwise re-serialize
+    const requestBody = rawBody || JSON.stringify(body);
     // Log request (mask sensitive data)
     if (logger && config.LOG_REQUESTS) {
         const maskedHeaders = {};
@@ -28,6 +154,8 @@ export async function forwardToAnthropic(body, headers, logger) {
             model: body.model,
             messageCount: Array.isArray(body.messages) ? body.messages.length : 0,
             headers: maskedHeaders,
+            usingRawBody: !!rawBody,
+            bodySize: rawBody?.length || JSON.stringify(body).length,
         });
     }
     try {
@@ -37,7 +165,7 @@ export async function forwardToAnthropic(body, headers, logger) {
                 ...safeHeaders,
                 'content-type': 'application/json',
             },
-            body: JSON.stringify(body),
+            body: requestBody,
             bodyTimeout: config.REQUEST_TIMEOUT,
             headersTimeout: config.REQUEST_TIMEOUT,
             dispatcher: agent,
@@ -48,14 +176,29 @@ export async function forwardToAnthropic(body, headers, logger) {
             chunks.push(Buffer.from(chunk));
         }
         const rawBody = Buffer.concat(chunks).toString('utf-8');
+        // Check if response is SSE streaming
+        const contentType = response.headers['content-type'];
+        const isSSE = typeof contentType === 'string' && contentType.includes('text/event-stream');
         // Parse response
         let parsedBody;
-        try {
-            parsedBody = JSON.parse(rawBody);
+        if (isSSE) {
+            // Parse SSE and reconstruct final message
+            const sseMessage = parseSSEResponse(rawBody);
+            if (sseMessage) {
+                parsedBody = sseMessage;
+            }
+            else {
+                parsedBody = { error: 'Failed to parse SSE response', raw: rawBody.substring(0, 500) };
+            }
         }
-        catch {
-            // Return raw body if not JSON
-            parsedBody = { error: 'Invalid JSON response', raw: rawBody.substring(0, 500) };
+        else {
+            // Regular JSON response
+            try {
+                parsedBody = JSON.parse(rawBody);
+            }
+            catch {
+                parsedBody = { error: 'Invalid JSON response', raw: rawBody.substring(0, 500) };
+            }
         }
         // Convert headers to record
         const responseHeaders = {};
@@ -64,11 +207,17 @@ export async function forwardToAnthropic(body, headers, logger) {
                 responseHeaders[key] = value;
             }
         }
+        // If we parsed SSE, change content-type to JSON for Claude Code
+        if (isSSE) {
+            responseHeaders['content-type'] = 'application/json';
+        }
         if (logger && config.LOG_REQUESTS) {
             logger.info('Received from Anthropic', {
                 statusCode: response.statusCode,
                 bodyLength: rawBody.length,
                 hasUsage: 'usage' in parsedBody,
+                wasSSE: isSSE,
+                parseSuccess: !('error' in parsedBody),
             });
         }
         return {
@@ -76,6 +225,7 @@ export async function forwardToAnthropic(body, headers, logger) {
             headers: responseHeaders,
             body: parsedBody,
             rawBody,
+            wasSSE: isSSE,
         };
     }
     catch (error) {

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

@@ -1,8 +1,9 @@
 /**
- * Build context from team memory for injection
- * Queries tasks and file_reasoning tables
+ * Build context from team memory for injection (PAST sessions only)
+ * Queries tasks and file_reasoning tables, excluding current session data
+ * @param currentSessionId - Session ID to exclude (ensures only past session data)
  */
-export declare function buildTeamMemoryContext(projectPath: string, mentionedFiles: string[]): string | null;
+export declare function buildTeamMemoryContext(projectPath: string, mentionedFiles: string[], currentSessionId?: string): string | null;
 /**
  * Extract file paths from messages (user messages only, clean text)
  */

package/dist/proxy/request-processor.js

@@ -3,10 +3,11 @@
 import { getTasksForProject, getTasksByFiles, getStepsReasoningByPath, } from '../lib/store.js';
 import { truncate } from '../lib/utils.js';
 /**
- * Build context from team memory for injection
- * Queries tasks and file_reasoning tables
+ * Build context from team memory for injection (PAST sessions only)
+ * Queries tasks and file_reasoning tables, excluding current session data
+ * @param currentSessionId - Session ID to exclude (ensures only past session data)
  */
-export function buildTeamMemoryContext(projectPath, mentionedFiles) {
+export function buildTeamMemoryContext(projectPath, mentionedFiles, currentSessionId) {
     // Get recent completed tasks for this project
     const tasks = getTasksForProject(projectPath, {
         status: 'complete',
@@ -16,9 +17,10 @@ export function buildTeamMemoryContext(projectPath, mentionedFiles) {
     const fileTasks = mentionedFiles.length > 0
         ? getTasksByFiles(projectPath, mentionedFiles, { status: 'complete', limit: 5 })
         : [];
-    // Get file-level reasoning from steps table (proxy version)
+    // Get file-level reasoning from steps table (PAST sessions only)
+    // Pass currentSessionId to exclude current session data
     const fileReasonings = mentionedFiles.length > 0
-        ? mentionedFiles.flatMap(f => getStepsReasoningByPath(f, 3))
+        ? mentionedFiles.flatMap(f => getStepsReasoningByPath(f, 3, currentSessionId))
         : [];
     // Combine unique tasks
     const allTasks = [...new Map([...tasks, ...fileTasks].map(t => [t.id, t])).values()];