centaurus-cli 2.8.9 → 2.9.1

package/dist/cli-adapter.js

@@ -17,6 +17,8 @@ import { createPlanTool, markTaskCompleteTool, getCurrentPlan, clearPlan, approv
 import { webSearchTool, fetchUrlTool } from './tools/web-search.js';
 import { taskCompleteTool } from './tools/task-complete.js';
 import { readBinaryFileTool } from './tools/read-binary-file.js';
+import { createImageTool } from './tools/create-image.js';
+import { backgroundCommandTool } from './tools/background-command.js';
 import { apiClient } from './services/api-client.js';
 import { conversationManager } from './services/conversation-manager.js';
 import { aiServiceClient } from './services/ai-service-client.js';
@@ -36,6 +38,7 @@ import { conversationLogger, quickLog } from './utils/conversation-logger.js';
 import { localChatStorage } from './services/local-chat-storage.js';
 import { logWarning } from './utils/logger.js';
 import { BackgroundTaskManager } from './services/background-task-manager.js';
+import { sessionQuotaManager } from './services/session-quota-manager.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
@@ -49,6 +52,7 @@ export class CentaurusCLI {
     onResponseCallback;
     onDirectMessageCallback; // For slash commands - adds directly to history
     onResponseStreamCallback;
+    onClearStreamedResponse; // Clear streamed text when task_complete has summary
     onThoughtStreamCallback;
     onThoughtCompleteCallback;
     onCommandModeChange;
@@ -89,6 +93,8 @@ export class CentaurusCLI {
     onShowBackgroundTaskPickerCallback;
     onShowBackgroundTaskCancelPickerCallback;
     onBackgroundTaskViewCallback;
+    onTokenCountUpdate; // Report actual AI context token count to UI
+    onSessionQuotaUpdate;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -119,6 +125,9 @@ export class CentaurusCLI {
     setOnResponseStreamCallback(callback) {
         this.onResponseStreamCallback = callback;
     }
+    setOnClearStreamedResponse(callback) {
+        this.onClearStreamedResponse = callback;
+    }
     setOnThoughtStreamCallback(callback) {
         this.onThoughtStreamCallback = callback;
     }
@@ -174,6 +183,23 @@ export class CentaurusCLI {
     setOnConnectionStatusUpdate(callback) {
         this.onConnectionStatusUpdate = callback;
     }
+    setOnTokenCountUpdate(callback) {
+        this.onTokenCountUpdate = callback;
+    }
+    setOnSessionQuotaUpdate(callback) {
+        this.onSessionQuotaUpdate = callback;
+    }
+    /**
+     * Notify UI about session quota status
+     */
+    notifySessionQuotaStatus() {
+        if (this.onSessionQuotaUpdate) {
+            const remaining = sessionQuotaManager.getRemainingMessages();
+            const canSend = sessionQuotaManager.canSendMessage();
+            const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+            this.onSessionQuotaUpdate(remaining, canSend, timeRemaining);
+        }
+    }
     async initializeMCP() {
         try {
             const mcpConfigManager = new MCPConfigManager();
@@ -248,9 +274,9 @@ export class CentaurusCLI {
             // This prevents caching issues when we update model configs
             this.configManager.set('model', selectedModel.id);
             this.configManager.set('modelName', selectedModel.name);
-            // Notify UI of model name change
+            // Notify UI of model name change and contextWindow
             if (this.onModelChange) {
-                this.onModelChange(selectedModel.name);
+                this.onModelChange(selectedModel.name, selectedModel.contextWindow);
             }
             const responseMessage = `Model changed to: ${selectedModel.name}`;
             // Send response back to UI
@@ -343,6 +369,8 @@ export class CentaurusCLI {
         this.toolRegistry.register(fetchUrlTool);
         this.toolRegistry.register(taskCompleteTool);
         this.toolRegistry.register(readBinaryFileTool);
+        this.toolRegistry.register(createImageTool);
+        this.toolRegistry.register(backgroundCommandTool);
         // Load configuration
         const config = this.configManager.load();
         // Enable backend sync if authenticated
@@ -359,6 +387,11 @@ export class CentaurusCLI {
         const dockerHandler = new DockerHandler();
         this.contextManager.registerHandler('docker', dockerHandler);
         this.commandDetector.registerHandler(dockerHandler);
+        // Fetch rate limits configuration from backend (async, non-blocking)
+        // Uses cached values if backend is unreachable
+        sessionQuotaManager.fetchConfigFromBackend().catch(() => {
+            // Silently fall back to cached/default config
+        });
         // Note: No need to initialize AI provider - using backend proxy via aiServiceClient
     }
     /**
@@ -404,47 +437,24 @@ Press Enter to continue...
     }
     /**
      * Start a new conversation in the backend
+     * @deprecated Backend conversation creation is no longer needed since messages are stored locally
+     * This function is kept as a no-op for compatibility
      */
     async ensureConversationStarted() {
-        if (this.conversationStarted || !apiClient.isAuthenticated()) {
-            return;
-        }
-        // Check if conversationManager already has a conversation (e.g., created by App.tsx for image upload)
-        // This prevents duplicate conversation creation
-        if (conversationManager.getCurrentConversationId()) {
-            this.conversationStarted = true;
-            return;
-        }
-        try {
-            const config = this.configManager.load();
-            const title = `Conversation ${new Date().toLocaleString()}`;
-            await conversationManager.startNewConversation(title, config.model || 'gemini-2.5-flash', 'google', // Always use Google provider now
-            this.cwd);
-            this.conversationStarted = true;
-        }
-        catch (error) {
-            // Silently continue without backend persistence
-        }
+        // No-op: Backend conversation creation has been disabled
+        // Conversations are now managed locally via local-chat-storage.ts
+        return;
     }
     /**
      * Save a message to the backend
+     * @deprecated Messages are now stored locally only via saveCurrentChat()
+     * This function is kept as a no-op for compatibility
      */
     async saveMessageToBackend(role, content) {
-        if (!apiClient.isAuthenticated()) {
-            return;
-        }
-        try {
-            await this.ensureConversationStarted();
-            await conversationManager.addMessage({
-                role,
-                content,
-                contentType: 'text',
-                metadata: {},
-            });
-        }
-        catch (error) {
-            // Silently continue without backend persistence
-        }
+        // No-op: Messages are stored locally only
+        // Backend message storage has been disabled to avoid "failed to fetch" errors
+        // All conversation history is persisted via local-chat-storage.ts
+        return;
     }
     getModel() {
         const config = this.configManager.load();
@@ -500,6 +510,27 @@ Press Enter to continue...
             this.conversationHistory.splice(lastAssistantWithToolCallsIndex);
         }
     }
+    /**
+     * Strip thinking blocks from ALL assistant messages in the conversation history.
+     *
+     * This is called at the START of a new user request to clear thinking from
+     * previous tasks. During the current agent loop, thinking is preserved for
+     * all turns to help the AI maintain reasoning context.
+     *
+     * Pattern:
+     * - New user request starts → strip ALL thinking from history
+     * - During agent loop (multi-turn tool execution) → keep ALL thinking
+     * - This allows AI to remember reasoning for current task but not old tasks
+     */
+    stripThinkingFromHistory() {
+        for (let i = 0; i < this.conversationHistory.length; i++) {
+            const msg = this.conversationHistory[i];
+            if (msg.role === 'assistant' && msg.thinking) {
+                // Remove thinking from the message in place
+                delete msg.thinking;
+            }
+        }
+    }
     async handleMessage(message) {
         // Handle command mode - execute commands directly
         if (this.commandMode) {
@@ -520,6 +551,17 @@ Press Enter to continue...
         if (!apiClient.isAuthenticated()) {
             throw new Error('Authentication required. Please sign in to use AI features.');
         }
+        // Check session quota before making any AI request
+        if (!sessionQuotaManager.canSendMessage()) {
+            const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+            const message = `\n⚠️ Session quota reached. You have used all ${sessionQuotaManager.getCurrentConfig().maxMessagesPerSession} messages for this session.\n\nYour quota will reset in ${timeRemaining}.\n\nYou can still use:\n  • Slash commands (e.g., /help, /session-limits, /exit)\n  • Terminal commands (in Command mode)\n\nUse /session-limits to check your quota status.`;
+            if (this.onDirectMessageCallback) {
+                this.onDirectMessageCallback(message);
+            }
+            // Notify UI about quota status
+            this.notifySessionQuotaStatus();
+            return;
+        }
         // Cancel any active request when a new message comes in
         // This enables "interrupt and replace" - new message takes priority
         if (this.currentAbortController) {
@@ -550,13 +592,17 @@ CRITICAL INSTRUCTIONS:
 DO NOT use write_to_file, edit_file, or execute_command until the plan is approved.`;
             userMessageContent = planModePrefix;
         }
+        // NEW USER REQUEST: Strip thinking from previous tasks
+        // This clears thinking from the previous agent loop but thinking will be
+        // preserved for all turns within the current agent loop
+        this.stripThinkingFromHistory();
         // Add user message to history
         this.conversationHistory.push({
             role: 'user',
             content: userMessageContent,
         });
-        // Save user message to backend (save original message for display, not the prefixed version)
-        await this.saveMessageToBackend('user', message);
+        // Messages are stored locally only - no backend persistence needed
+        // Local storage is handled by saveCurrentChat() which saves to ~/.centaurus/chats/
         // Start logging session and log user message
         conversationLogger.startSession();
         conversationLogger.logUserMessage(message);
@@ -606,7 +652,9 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             let narrationAttempts = 0; // Track how many times AI narrated without executing
             let completionAttempts = 0; // Track how many times AI provided text summary without task_complete
             let thoughtStartTime = null; // Track when thinking started
-            let thoughtContent = ''; // Accumulate thought content
+            let thoughtContent = ''; // Accumulate thought content during streaming
+            let currentTurnThinking = ''; // Persist thinking for the current turn to attach to assistant message
+            let currentTurnThinkingSignature = ''; // Persist thinking signature for Claude extended thinking
             // ANTI-LOOP: Track duplicate tool calls to detect infinite loops
             const MAX_DUPLICATE_CALLS = 2; // Max times same operation allowed on same target
             const fileWriteTracker = new Map(); // Track writes per file
@@ -623,15 +671,56 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             // Multi-turn tool execution loop
             while (turnCount < MAX_TURNS) {
                 turnCount++;
+                // Track session quota - each AI call in the agent loop counts as 1 message
+                sessionQuotaManager.incrementMessageCount();
+                this.notifySessionQuotaStatus();
+                // Check if session quota is now exhausted after incrementing
+                if (!sessionQuotaManager.canSendMessage() && turnCount > 1) {
+                    // Quota exhausted mid-loop, stop and inform user
+                    const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+                    const quotaMessage = `\n\n⚠️ **Session quota reached** during agent execution.\n\nYou have used all ${sessionQuotaManager.getCurrentConfig().maxMessagesPerSession} messages for this session.\nQuota will reset in ${timeRemaining}.\n\nYour current task may be incomplete. You can resume when your quota resets.\n\nUse /session-limits to check your quota status.`;
+                    if (this.onResponseCallback) {
+                        this.onResponseCallback(quotaMessage);
+                    }
+                    logWarning('Agent loop stopped due to session quota exhaustion');
+                    return;
+                }
                 // Refresh environment context to capture any CWD changes from previous turns
                 // This is sent to backend which will inject it into the system prompt
                 environmentContext = this.getEnvironmentContext();
                 let assistantMessage = '';
                 let toolCalls = [];
+                // REAL-TIME TOOL EXECUTION: Track execution state and results during streaming
+                const inStreamToolResults = []; // Results from tools executed during streaming
+                const inStreamHandledIds = new Set(); // IDs of tools already executed in-stream
+                let toolsExecutedInStream = false; // Flag to indicate tools were executed during stream
+                let pendingTextBuffer = ''; // Buffer for text while tool is executing
+                let isToolExecuting = false; // Flag to pause text streaming during tool execution
                 // DEBUG: Log message history state before AI call
                 const messageStats = {
                     totalMessages: messages.length,
-                    totalCharacters: messages.reduce((sum, m) => sum + (typeof m.content === 'string' ? m.content.length : 0), 0),
+                    totalCharacters: messages.reduce((sum, m) => {
+                        let len = typeof m.content === 'string' ? m.content.length : 0;
+                        // Include thinking content (internal reasoning)
+                        if (m.thinking) {
+                            len += m.thinking.length;
+                        }
+                        // Include tool calls (name + arguments)
+                        if (m.tool_calls) {
+                            m.tool_calls.forEach(tc => {
+                                len += tc.name.length;
+                                // Arguments are JSON stringified in the payload
+                                if (tc.arguments) {
+                                    len += JSON.stringify(tc.arguments).length;
+                                }
+                            });
+                        }
+                        // Include tool_call_id for tool messages
+                        if (m.role === 'tool' && m.tool_call_id) {
+                            len += m.tool_call_id.length;
+                        }
+                        return sum + len;
+                    }, 0),
                     byRole: {
                         system: messages.filter(m => m.role === 'system').length,
                         user: messages.filter(m => m.role === 'user').length,
@@ -647,6 +736,13 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     quickLog(`[${new Date().toISOString()}] [CLI] Assistant messages with tool_calls: ${messageStats.assistantWithToolCalls}\n`);
                 }
                 catch (e) { }
+                // Report actual token count to UI (estimate: 1 token ≈ 4 chars)
+                // Include system prompt estimate (~14000 chars based on backend logs)
+                const SYSTEM_PROMPT_ESTIMATE = 14000; // Backend injects ~14K char system prompt
+                const estimatedTokens = Math.ceil((messageStats.totalCharacters + SYSTEM_PROMPT_ESTIMATE) / 4);
+                if (this.onTokenCountUpdate) {
+                    this.onTokenCountUpdate(estimatedTokens);
+                }
                 // Stream AI response from backend
                 // Backend will inject system prompt automatically with environment context
                 for await (const chunk of aiServiceClient.streamChat(selectedModel, messages, tools, environmentContext, mode, selectedModelThinkingConfig, this.currentAbortController.signal)) {
@@ -678,6 +774,12 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         }
                         continue;
                     }
+                    // Handle thinking_signature chunks (Claude extended thinking)
+                    if (chunk.type === 'thinking_signature') {
+                        // Store the signature for this turn - it must be passed back with thinking content
+                        currentTurnThinkingSignature = chunk.signature;
+                        continue;
+                    }
                     // Handle text chunks
                     if (chunk.type === 'text') {
                         // If we were thinking and now got text, finalize the thought
@@ -687,6 +789,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -697,9 +801,16 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         if (filteredContent) {
                             assistantMessage += filteredContent;
                             conversationLogger.logAITextChunk(filteredContent);
-                            // Send chunk to UI in real-time
-                            if (this.onResponseStreamCallback) {
-                                this.onResponseStreamCallback(filteredContent);
+                            // REAL-TIME TOOL EXECUTION: If a tool is executing, accumulate text
+                            // This text will be flushed after the tool completes
+                            if (isToolExecuting) {
+                                pendingTextBuffer += filteredContent;
+                            }
+                            else {
+                                // Normal streaming - send chunk to UI in real-time
+                                if (this.onResponseStreamCallback) {
+                                    this.onResponseStreamCallback(filteredContent);
+                                }
                             }
                         }
                     }
@@ -708,7 +819,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         const toolCall = chunk.toolCall;
                         // Debug: Log every tool_call chunk received
                         try {
-                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL CHUNK RECEIVED: ${toolCall?.name || 'unknown'}, toolCalls.length before push: ${toolCalls.length}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL CHUNK RECEIVED (REAL-TIME): ${toolCall?.name || 'unknown'}\n`);
                         }
                         catch (e) { }
                         conversationLogger.logToolCall(toolCall?.name || 'unknown', toolCall?.id || 'unknown', toolCall?.arguments || {});
@@ -719,22 +830,94 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
                         toolCalls.push(chunk.toolCall);
-                        // IMMEDIATELY notify UI that a tool call was received (pending status)
-                        // This shows tool calls in the UI as they stream in, not after the stream ends
-                        if (this.onToolExecutionUpdate && toolCall) {
-                            this.onToolExecutionUpdate({
-                                toolName: toolCall.name,
-                                status: 'pending', // 'pending' means received but not yet executing
-                                arguments: toolCall.arguments
+                        // SPECIAL TOOLS: Skip in-stream execution for tools that need post-stream handling
+                        // These tools have special logic (setting flags, clearing state, etc.) that must run post-stream
+                        const SPECIAL_TOOLS = ['task_complete', 'create_plan', 'mark_task_complete'];
+                        if (SPECIAL_TOOLS.includes(toolCall.name)) {
+                            // Just notify UI with pending status, execute in post-stream loop
+                            if (this.onToolExecutionUpdate) {
+                                this.onToolExecutionUpdate({
+                                    toolName: toolCall.name,
+                                    status: 'pending',
+                                    arguments: toolCall.arguments
+                                });
+                            }
+                            continue; // Skip to next chunk, handle this tool in post-stream loop
+                        }
+                        // Mark that we're executing a tool (text will accumulate)
+                        isToolExecuting = true;
+                        toolsExecutedInStream = true;
+                        // REAL-TIME EXECUTION: Execute tool immediately during streaming
+                        // This reduces latency by not waiting for the entire stream to finish
+                        try {
+                            // Extract and display reason_text if present (skip for task_complete)
+                            const reasonText = toolCall.arguments.reason_text;
+                            if (reasonText && this.onResponseStreamCallback) {
+                                this.onResponseStreamCallback(reasonText + '\n\n');
+                            }
+                            // Show 'executing' status immediately
+                            this.notifyToolStatus(toolCall.name, 'executing', toolCall.arguments);
+                            // Log tool execution start
+                            conversationLogger.logToolExecutionStart(toolCall.name, toolCall.id);
+                            // Execute the tool (it will request approval if needed via requireApproval callback)
+                            const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+                            if (result.success) {
+                                conversationLogger.logToolResult(toolCall.name, toolCall.id, result.result, true);
+                                // Notify UI: tool succeeded
+                                this.notifyToolStatus(toolCall.name, 'completed', toolCall.arguments, result.result);
+                                // Parse and truncate result for AI
+                                let parsedResult = result.result;
+                                if (typeof result.result === 'string') {
+                                    try {
+                                        parsedResult = JSON.parse(result.result);
+                                    }
+                                    catch {
+                                        parsedResult = result.result;
+                                    }
+                                }
+                                inStreamToolResults.push({
+                                    tool_call_id: toolCall.id,
+                                    name: toolCall.name,
+                                    result: this.truncateResult(parsedResult),
+                                });
+                            }
+                            else {
+                                conversationLogger.logToolResult(toolCall.name, toolCall.id, null, false, result.error);
+                                // Notify UI: tool failed
+                                this.notifyToolStatus(toolCall.name, 'error', toolCall.arguments, undefined, result.error);
+                                inStreamToolResults.push({
+                                    tool_call_id: toolCall.id,
+                                    name: toolCall.name,
+                                    result: `Error: ${result.error}`,
+                                });
+                            }
+                            inStreamHandledIds.add(toolCall.id);
+                        }
+                        catch (error) {
+                            conversationLogger.logError(`Tool execution: ${toolCall.name}`, error);
+                            this.notifyToolStatus(toolCall.name, 'error', toolCall.arguments, undefined, error.message);
+                            inStreamToolResults.push({
+                                tool_call_id: toolCall.id,
+                                name: toolCall.name,
+                                result: `Error: ${error.message}`,
                             });
+                            inStreamHandledIds.add(toolCall.id);
                         }
-                        // Debug: Log after push
+                        // Tool execution complete - flush pending text
+                        isToolExecuting = false;
+                        if (pendingTextBuffer && this.onResponseStreamCallback) {
+                            this.onResponseStreamCallback(pendingTextBuffer);
+                            pendingTextBuffer = '';
+                        }
+                        // Debug: Log after execution
                         try {
-                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL_CALL PUSHED: ${toolCall?.name || 'unknown'}, toolCalls.length after push: ${toolCalls.length}\n`);
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** TOOL EXECUTED IN-STREAM: ${toolCall?.name || 'unknown'}\n`);
                         }
                         catch (e) { }
                     }
@@ -747,6 +930,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                             if (this.onThoughtCompleteCallback) {
                                 this.onThoughtCompleteCallback(thinkingDuration);
                             }
+                            // Capture thinking for this turn before clearing
+                            currentTurnThinking = thoughtContent;
                             thoughtStartTime = null;
                             thoughtContent = '';
                         }
@@ -781,18 +966,26 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         // Silently limit tool calls
                         toolCalls = toolCalls.slice(0, MAX_TOOL_CALLS_PER_TURN);
                     }
-                    const toolResults = [];
-                    const handledToolCallIds = new Set(); // Track tool calls that were handled directly (e.g., create_plan, mark_task_complete)
+                    const toolResults = [...inStreamToolResults]; // Start with in-stream results
+                    const handledToolCallIds = new Set(); // Only for special tools (create_plan, mark_task_complete)
                     let userCancelledOperation = false;
                     let taskCompleted = false;
                     let taskCompleteSummary = '';
                     for (let i = 0; i < toolCalls.length; i++) {
+                        const toolCall = toolCalls[i];
+                        // REAL-TIME EXECUTION: Skip tools that were already executed in-stream
+                        if (inStreamHandledIds.has(toolCall.id)) {
+                            try {
+                                quickLog(`[${new Date().toISOString()}] [CLI] *** SKIPPING TOOL (already executed in-stream): ${toolCall.name}\n`);
+                            }
+                            catch (e) { }
+                            continue;
+                        }
                         // Debug: Log which tool we're about to execute
                         try {
                             quickLog(`[${new Date().toISOString()}] [CLI] *** ABOUT TO EXECUTE TOOL [${i + 1}/${toolCalls.length}]: ${toolCalls[i].name}\n`);
                         }
                         catch (e) { }
-                        const toolCall = toolCalls[i];
                         try {
                             // Check if this is task_complete FIRST (before displaying anything)
                             if (toolCall.name === 'task_complete') {
@@ -804,6 +997,11 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                 if (taskCompleteSummary) {
                                     // AI provided a summary - suppress any other text and use the summary
                                     assistantMessage = '';
+                                    // IMPORTANT: Clear the already-streamed text from UI before showing summary
+                                    // This prevents duplicate content (streamed text + summary)
+                                    if (this.onClearStreamedResponse) {
+                                        this.onClearStreamedResponse();
+                                    }
                                     // Stream the summary to UI so it's visible
                                     if (this.onResponseStreamCallback) {
                                         this.onResponseStreamCallback(taskCompleteSummary);
@@ -845,11 +1043,18 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                     this.onPlanModeChange(false);
                                                 }
                                                 // Add assistant message with plan tool call to history
-                                                this.conversationHistory.push({
+                                                const planAssistantMsg = {
                                                     role: 'assistant',
                                                     content: '',
                                                     tool_calls: [toolCall],
-                                                });
+                                                };
+                                                if (currentTurnThinking) {
+                                                    planAssistantMsg.thinking = currentTurnThinking;
+                                                }
+                                                if (currentTurnThinkingSignature) {
+                                                    planAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                                }
+                                                this.conversationHistory.push(planAssistantMsg);
                                                 // Add plan approval response
                                                 this.conversationHistory.push({
                                                     role: 'tool',
@@ -885,11 +1090,18 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         else {
                                             // No approval callback - add the tool result to history and wait for user response
                                             // This ensures the AI doesn't get stuck in a silent loop
-                                            this.conversationHistory.push({
+                                            const planAssistantMsg = {
                                                 role: 'assistant',
                                                 content: '',
                                                 tool_calls: [toolCall],
-                                            });
+                                            };
+                                            if (currentTurnThinking) {
+                                                planAssistantMsg.thinking = currentTurnThinking;
+                                            }
+                                            if (currentTurnThinkingSignature) {
+                                                planAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                            }
+                                            this.conversationHistory.push(planAssistantMsg);
                                             this.conversationHistory.push({
                                                 role: 'tool',
                                                 tool_call_id: toolCall.id,
@@ -909,11 +1121,18 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                         // Log error and add error result to history so AI knows
                                         logWarning(`Failed to parse plan: ${parseError?.message || parseError}`);
                                         // CRITICAL: Add tool result even on parse error to prevent silent loop
-                                        this.conversationHistory.push({
+                                        const errorAssistantMsg = {
                                             role: 'assistant',
                                             content: '',
                                             tool_calls: [toolCall],
-                                        });
+                                        };
+                                        if (currentTurnThinking) {
+                                            errorAssistantMsg.thinking = currentTurnThinking;
+                                        }
+                                        if (currentTurnThinkingSignature) {
+                                            errorAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                        }
+                                        this.conversationHistory.push(errorAssistantMsg);
                                         this.conversationHistory.push({
                                             role: 'tool',
                                             tool_call_id: toolCall.id,
@@ -926,11 +1145,18 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                 }
                                 else {
                                     // Tool returned non-PLAN_CREATED result - add it to history
-                                    this.conversationHistory.push({
+                                    const resultAssistantMsg = {
                                         role: 'assistant',
                                         content: '',
                                         tool_calls: [toolCall],
-                                    });
+                                    };
+                                    if (currentTurnThinking) {
+                                        resultAssistantMsg.thinking = currentTurnThinking;
+                                    }
+                                    if (currentTurnThinkingSignature) {
+                                        resultAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                    }
+                                    this.conversationHistory.push(resultAssistantMsg);
                                     this.conversationHistory.push({
                                         role: 'tool',
                                         tool_call_id: toolCall.id,
@@ -959,7 +1185,8 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                             const mainTaskNum = parseInt(taskNumParts[0], 10) - 1;
                                             const task = currentPlanData.steps[mainTaskNum];
                                             if (task) {
-                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote);
+                                                this.onTaskCompleted(task, completion.taskNumber, completion.totalCount, completion.completionNote, completion.taskDescription // Pass the actual task/subtask description
+                                                );
                                             }
                                         }
                                         // Notify UI about completed task/subtask
@@ -979,11 +1206,18 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                                                     result: `Task completed. Moving to Task ${nextPhase.taskNumber}: ${nextPhase.task.description}`,
                                                 });
                                                 // Add the tool call and result to history
-                                                this.conversationHistory.push({
+                                                const nextPhaseAssistantMsg = {
                                                     role: 'assistant',
                                                     content: '',
                                                     tool_calls: [toolCall],
-                                                });
+                                                };
+                                                if (currentTurnThinking) {
+                                                    nextPhaseAssistantMsg.thinking = currentTurnThinking;
+                                                }
+                                                if (currentTurnThinkingSignature) {
+                                                    nextPhaseAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                                                }
+                                                this.conversationHistory.push(nextPhaseAssistantMsg);
                                                 this.conversationHistory.push({
                                                     role: 'tool',
                                                     tool_call_id: toolCall.id,
@@ -1216,12 +1450,19 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     }
                     // If user cancelled an operation, stop the agentic loop immediately
                     if (userCancelledOperation) {
-                        // Add assistant message to history
-                        this.conversationHistory.push({
+                        // Add assistant message to history with thinking if available
+                        const cancelledAssistantMsg = {
                             role: 'assistant',
                             content: assistantMessage || '',
                             tool_calls: toolCalls, // Store tool calls for MaaS models
-                        });
+                        };
+                        if (currentTurnThinking) {
+                            cancelledAssistantMsg.thinking = currentTurnThinking;
+                        }
+                        if (currentTurnThinkingSignature) {
+                            cancelledAssistantMsg.thinkingSignature = currentTurnThinkingSignature;
+                        }
+                        this.conversationHistory.push(cancelledAssistantMsg);
                         // Add tool results to history
                         for (const toolResult of toolResults) {
                             this.conversationHistory.push({
@@ -1259,11 +1500,26 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     const unhandledToolResults = toolResults.filter(tr => !handledToolCallIds.has(tr.tool_call_id));
                     // Only add assistant message if there are unhandled tool calls
                     if (unhandledToolCalls.length > 0) {
-                        this.conversationHistory.push({
+                        const assistantHistoryMsg = {
                             role: 'assistant',
                             content: assistantMessage || '',
                             tool_calls: unhandledToolCalls, // Only include unhandled tool calls
-                        });
+                        };
+                        // Include thinking from this turn if available (Extended Thinking pattern)
+                        if (currentTurnThinking) {
+                            assistantHistoryMsg.thinking = currentTurnThinking;
+                        }
+                        // Include thinking signature from this turn (required for Claude extended thinking)
+                        if (currentTurnThinkingSignature) {
+                            assistantHistoryMsg.thinkingSignature = currentTurnThinkingSignature;
+                        }
+                        // Log signature info for debugging multi-turn flows
+                        const geminiSigCount = unhandledToolCalls.filter(tc => !!tc.thoughtSignature).length;
+                        try {
+                            quickLog(`[${new Date().toISOString()}] [CLI] *** STORING ASSISTANT MSG: ${unhandledToolCalls.length} tool_calls, Gemini signatures: ${geminiSigCount}, Claude thinking: ${!!currentTurnThinking}, Claude sig: ${!!currentTurnThinkingSignature}\n`);
+                        }
+                        catch (e) { }
+                        this.conversationHistory.push(assistantHistoryMsg);
                     }
                     // Add tool results to conversation history as tool messages
                     // Format: { tool_call_id, name, result: <object or string> }
@@ -1278,8 +1534,10 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                         });
                     }
                     // Rebuild messages array with updated history
-                    // Backend will inject system prompt
+                    // During agent loop: keep ALL thinking for current task
+                    // (Thinking from previous tasks was already stripped at request start)
                     messages = [...this.conversationHistory];
+                    // No need to reset currentTurnThinking - keep accumulating for the task
                     // Re-inject subshell context
                     messages = this.aiContextInjector.injectSubshellContext(messages, currentContext);
                     continue; // Loop back to AI service
@@ -1469,8 +1727,7 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     role: 'assistant',
                     content: finalMessage,
                 });
-                // Save assistant message to backend
-                await this.saveMessageToBackend('assistant', finalMessage);
+                // Messages are stored locally only via saveCurrentChat() below
             } // End of while loop
             // Auto-save conversation to local storage
             this.saveCurrentChat();
@@ -1511,11 +1768,14 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     `/init       - Analyze project and create/load centaurus.md context file\n` +
                     `/chat       - Manage chat sessions (resume previous chats)\n` +
                     `/clear      - Clear conversation and start a new chat\n` +
+                    `/sync       - Sync data to/from cloud (upload/restore)\n` +
                     `/config     - View current configuration\n` +
                     `/model      - Select from available Google models\n` +
                     `/plan       - Toggle plan mode for complex implementations\n` +
                     `/mcp        - Manage configured MCP servers and tools\n` +
                     `/docs       - Open Centaurus documentation in browser\n` +
+                    `/copy-chat-context - Copy chat as readable text to clipboard\n` +
+                    `/session-limits - View session quota usage and limits\n` +
                     `/quality    - Toggle enhanced quality features (thinking protocol, validation)\n` +
                     `/autonomous - Toggle autonomous mode (Silent Operator with task_complete)\n` +
                     `/sign-in    - Sign in with Google (if not already signed in)\n` +
@@ -1529,6 +1789,32 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
                     `Ctrl+Z      - Undo last input change\n` +
                     `Ctrl+A      - Select all text`;
                 break;
+            case 'session-limits': {
+                const config = sessionQuotaManager.getCurrentConfig();
+                const messagesUsed = sessionQuotaManager.getMessagesUsed();
+                const remaining = sessionQuotaManager.getRemainingMessages();
+                const timeRemaining = sessionQuotaManager.getFormattedTimeRemaining();
+                const maxMessages = config.maxMessagesPerSession;
+                // Calculate percentage used (cap at 100% for display)
+                const percentUsed = maxMessages > 0 ? Math.min(100, Math.round((messagesUsed / maxMessages) * 100)) : 0;
+                // Create a visual progress bar (clamp to valid range)
+                const barLength = 20;
+                const filledLength = Math.min(barLength, Math.max(0, Math.round((messagesUsed / maxMessages) * barLength)));
+                const emptyLength = barLength - filledLength;
+                const progressBar = '█'.repeat(filledLength) + '░'.repeat(emptyLength);
+                // Status message based on quota
+                const quotaStatus = remaining <= 0
+                    ? '\n\n⚠️ Session quota exhausted! AI requests are blocked until reset.'
+                    : '';
+                responseMessage = `📊 Session Limits\n\n` +
+                    `Plan:            free\n` +
+                    `Session Window:  ${config.sessionDurationMs / (60 * 60 * 1000)} hours\n\n` +
+                    `Messages Used:   ${messagesUsed} / ${maxMessages} (${percentUsed}%)\n` +
+                    `Messages Left:   ${Math.max(0, remaining)}\n` +
+                    `Progress:        [${progressBar}]\n` +
+                    `Time Remaining:  ${timeRemaining || 'Session not started'}${quotaStatus}`;
+                break;
+            }
             case 'init':
                 try {
                     // Define the context file names in priority order
@@ -1938,7 +2224,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show list of saved chats for resuming (interactive picker)
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats found.\\n\\nStart a new conversation and it will be automatically saved!';
+                        responseMessage = 'No saved chats found.\n\nStart a new conversation and it will be automatically saved!';
                     }
                     else {
                         // Format chat list for picker display
@@ -1948,13 +2234,13 @@ Start by listing the directory structure to understand what you're working with.
                         }
                         else {
                             // Fallback: show as text if no picker callback
-                            responseMessage = '📚 Saved Chats:\\n\\n' +
+                            responseMessage = 'Saved Chats:\n\n' +
                                 chats.slice(0, 10).map((chat, i) => {
                                     const date = new Date(chat.updatedAt).toLocaleDateString();
                                     const time = new Date(chat.updatedAt).toLocaleTimeString();
-                                    return `${i + 1}. ${chat.title}\\n   📅 ${date} ${time} | 💬 ${chat.messageCount} messages`;
-                                }).join('\\n\\n') +
-                                (chats.length > 10 ? `\\n\\n...and ${chats.length - 10} more chats` : '');
+                                    return `${i + 1}. ${chat.title}\n   ${date} ${time} | ${chat.messageCount} messages`;
+                                }).join('\n\n') +
+                                (chats.length > 10 ? `\n\n...and ${chats.length - 10} more chats` : '');
                         }
                     }
                 }
@@ -1962,7 +2248,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show read-only list of saved chats (no selection)
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats found.\\n\\nStart a new conversation and it will be automatically saved!';
+                        responseMessage = 'No saved chats found.\n\nStart a new conversation and it will be automatically saved!';
                     }
                     else {
                         // Format chat list for read-only display
@@ -1987,7 +2273,7 @@ Start by listing the directory structure to understand what you're working with.
                     // Show list of saved chats for deletion
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats to delete.';
+                        responseMessage = 'No saved chats to delete.';
                     }
                     else {
                         // Format chat list for delete picker display
@@ -2007,13 +2293,13 @@ Start by listing the directory structure to understand what you're working with.
                     if (this.onRestoreMessagesCallback) {
                         this.onRestoreMessagesCallback([]);
                     }
-                    responseMessage = '🆕 Started a new chat session!\n\nYour previous conversation has been saved and can be resumed with /chat resume.';
+                    responseMessage = '✅ Started a new chat session!\n\nYour previous conversation has been saved and can be resumed with /chat resume.';
                 }
                 else if (chatSubCommand === 'rename') {
                     // Show list of saved chats for renaming
                     const chats = localChatStorage.listChats();
                     if (chats.length === 0) {
-                        responseMessage = '📭 No saved chats to rename.';
+                        responseMessage = 'No saved chats to rename.';
                     }
                     else {
                         // Format chat list for rename picker display
@@ -2030,6 +2316,30 @@ Start by listing the directory structure to understand what you're working with.
                     responseMessage = `Unknown /chat subcommand: ${chatSubCommand}\\n\\nUsage:\\n  /chat resume  - Resume a previous chat session\\n  /chat list    - List all saved chats\\n  /chat delete  - Delete a saved chat\\n  /chat new     - Start a new chat session\\n  /chat rename  - Rename a saved chat`;
                 }
                 break;
+            case 'copy-chat-context':
+                try {
+                    const { formatChatForClipboard } = await import('./utils/chat-formatter.js');
+                    const { copyTextToClipboard } = await import('./utils/text-clipboard.js');
+                    if (this.uiMessageHistory.length === 0) {
+                        responseMessage = 'No messages in current chat to copy.';
+                    }
+                    else {
+                        const formattedChat = formatChatForClipboard(this.uiMessageHistory);
+                        const success = await copyTextToClipboard(formattedChat);
+                        if (success) {
+                            responseMessage = '✅ Chat content copied to clipboard!';
+                        }
+                        else {
+                            responseMessage = '❌ Failed to copy to clipboard.\n\n' +
+                                'This might happen if clipboard access is not available in your environment.\n' +
+                                'Try running the CLI in a terminal with clipboard access.';
+                        }
+                    }
+                }
+                catch (error) {
+                    responseMessage = `❌ Error copying chat content: ${error.message}`;
+                }
+                break;
             case 'exit':
                 process.exit(0);
                 break;
@@ -2147,6 +2457,138 @@ Start by listing the directory structure to understand what you're working with.
                         '  /background-task cancel  - Cancel a running background task';
                 }
                 break;
+            case 'sync':
+                // Sync local data to/from cloud
+                if (!apiClient.isAuthenticated()) {
+                    responseMessage = '❌ You must be signed in to sync data.\n\nUse /sign-in to authenticate first.';
+                    break;
+                }
+                // Parse subcommand
+                const syncSubcommand = args[0]?.toLowerCase();
+                if (!syncSubcommand) {
+                    // Show sync help
+                    responseMessage = '☁️  Sync Commands:\n\n' +
+                        '  /sync upload   - Upload local data to cloud (overwrites cloud data)\n' +
+                        '  /sync restore  - Download cloud data and restore locally (overwrites local data)\n\n' +
+                        'Use these commands to backup or restore your chat history and settings.';
+                    break;
+                }
+                if (syncSubcommand === 'upload') {
+                    try {
+                        responseMessage = '☁️  Uploading data to cloud...';
+                        // Send initial response
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(responseMessage);
+                        }
+                        // Gather all local data
+                        const config = this.configManager.load();
+                        const chats = localChatStorage.listChats();
+                        // Load full chat data for each chat
+                        const fullChats = chats.map(chatMeta => {
+                            const fullChat = localChatStorage.loadChat(chatMeta.id);
+                            return fullChat;
+                        }).filter(chat => chat !== null);
+                        // Create sync data structure
+                        const syncData = {
+                            version: 1,
+                            exportedAt: new Date().toISOString(),
+                            config: {
+                                model: config.model,
+                                modelName: config.modelName,
+                                enhancedQuality: config.enhancedQuality,
+                                autonomousMode: config.autonomousMode,
+                            },
+                            chats: fullChats,
+                            metadata: {
+                                totalChats: fullChats.length,
+                                totalMessages: fullChats.reduce((sum, chat) => sum + (chat?.messageCount || 0), 0),
+                            }
+                        };
+                        // Upload to backend
+                        const result = await apiClient.uploadSyncData(syncData);
+                        responseMessage = `✅ Data uploaded successfully!\n\n` +
+                            `📊 Upload Summary:\n` +
+                            `   • Chats: ${fullChats.length}\n` +
+                            `   • Messages: ${syncData.metadata.totalMessages}\n` +
+                            `   • Version: ${result.version}\n` +
+                            `   • Updated: ${new Date(result.updatedAt).toLocaleString()}\n\n` +
+                            `Your local data is now backed up to the cloud.`;
+                    }
+                    catch (error) {
+                        responseMessage = `❌ Upload failed: ${error.message}\n\nPlease try again later.`;
+                    }
+                }
+                else if (syncSubcommand === 'restore') {
+                    try {
+                        responseMessage = '☁️  Downloading data from cloud...';
+                        // Send initial response
+                        if (this.onDirectMessageCallback) {
+                            this.onDirectMessageCallback(responseMessage);
+                        }
+                        // Get sync data from backend
+                        const cloudData = await apiClient.getSyncData();
+                        if (!cloudData) {
+                            responseMessage = '❌ No cloud data found.\n\nUse /sync upload first to backup your data.';
+                            break;
+                        }
+                        const syncData = cloudData.syncData;
+                        // Validate sync data structure
+                        if (!syncData || typeof syncData !== 'object') {
+                            responseMessage = '❌ Invalid cloud data format.\n\nPlease try uploading again with /sync upload.';
+                            break;
+                        }
+                        // Restore config if present
+                        if (syncData.config) {
+                            const currentConfig = this.configManager.load();
+                            if (syncData.config.model) {
+                                currentConfig.model = syncData.config.model;
+                            }
+                            if (syncData.config.modelName) {
+                                currentConfig.modelName = syncData.config.modelName;
+                            }
+                            if (typeof syncData.config.enhancedQuality === 'boolean') {
+                                currentConfig.enhancedQuality = syncData.config.enhancedQuality;
+                            }
+                            if (typeof syncData.config.autonomousMode === 'boolean') {
+                                currentConfig.autonomousMode = syncData.config.autonomousMode;
+                            }
+                            this.configManager.save(currentConfig);
+                        }
+                        // Restore chats if present
+                        let restoredChats = 0;
+                        let restoredMessages = 0;
+                        if (syncData.chats && Array.isArray(syncData.chats)) {
+                            for (const chat of syncData.chats) {
+                                if (chat && chat.id) {
+                                    // Import each chat to local storage
+                                    const success = localChatStorage.importChat(chat);
+                                    if (success) {
+                                        restoredChats++;
+                                        restoredMessages += chat.messageCount || chat.messages?.length || 0;
+                                    }
+                                }
+                            }
+                        }
+                        responseMessage = `✅ Data restored successfully!\n\n` +
+                            `📊 Restore Summary:\n` +
+                            `   • Chats restored: ${restoredChats}\n` +
+                            `   • Messages restored: ${restoredMessages}\n` +
+                            `   • Cloud version: ${cloudData.version}\n` +
+                            `   • Last updated: ${new Date(cloudData.updatedAt).toLocaleString()}\n\n` +
+                            `Your local data has been restored from the cloud.\n` +
+                            `Note: Existing local chats with the same ID were overwritten.`;
+                    }
+                    catch (error) {
+                        responseMessage = `❌ Restore failed: ${error.message}\n\nPlease try again later.`;
+                    }
+                }
+                else {
+                    responseMessage = `❌ Unknown sync subcommand: ${syncSubcommand}\n\n` +
+                        'Available subcommands:\n' +
+                        '  /sync upload   - Upload local data to cloud\n' +
+                        '  /sync restore  - Download and restore cloud data locally';
+                }
+                break;
             default:
                 responseMessage = `Unknown command: /${cmd}\nType /help for available commands.`;
         }