orquesta-cli 0.2.45 → 0.2.46

package/dist/core/llm/llm-client.js

@@ -108,6 +108,7 @@ export class LLMClient {
     modelName;
     currentAbortController = null;
     isInterrupted = false;
+    onStreamingContent = null;
     static DEFAULT_MAX_RETRIES = 3;
     constructor() {
         const endpoint = configManager.getCurrentEndpoint();
@@ -183,11 +184,11 @@ export class LLMClient {
             const modelId = options.model || this.model;
             const processedMessages = options.messages ?
                 this.preprocessMessages(options.messages, modelId) : [];
-            logger.vars({ name: 'modelId', value: modelId }, { name: 'originalMessages', value: options.messages?.length || 0 }, { name: 'processedMessages', value: processedMessages.length }, { name: 'temperature', value: options.temperature ?? 0.7 });
+            logger.vars({ name: 'modelId', value: modelId }, { name: 'originalMessages', value: options.messages?.length || 0 }, { name: 'processedMessages', value: processedMessages.length }, { name: 'temperature', value: options.temperature ?? 0 });
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
-                temperature: options.temperature ?? 0.7,
+                temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: false,
                 ...(options.tools && {
@@ -210,13 +211,112 @@ export class LLMClient {
             }
             logger.startTimer('llm-api-call');
             this.currentAbortController = new AbortController();
-            const response = await this.axiosInstance.post(url, requestBody, {
-                signal: this.currentAbortController.signal,
-                headers: buildPerRequestHeaders(),
-            });
-            this.currentAbortController = null;
+            let response;
+            if (this.onStreamingContent) {
+                const streamRequestBody = { ...requestBody, stream: true };
+                const streamResp = await this.axiosInstance.post(url, streamRequestBody, {
+                    responseType: 'stream',
+                    signal: this.currentAbortController.signal,
+                    headers: buildPerRequestHeaders(),
+                });
+                captureBatutaHeaders(streamResp.headers);
+                const stream = streamResp.data;
+                let buffer = '';
+                let contentAccum = '';
+                let reasoningAccum = '';
+                let role = 'assistant';
+                let finishReason = null;
+                const toolCallsMap = new Map();
+                let responseId = '';
+                let responseModel = '';
+                for await (const chunk of stream) {
+                    if (this.isInterrupted) {
+                        throw new Error('INTERRUPTED');
+                    }
+                    buffer += chunk.toString();
+                    const lines = buffer.split('\n');
+                    buffer = lines.pop() || '';
+                    for (const line of lines) {
+                        const trimmed = line.trim();
+                        if (!trimmed || trimmed === 'data: [DONE]')
+                            continue;
+                        if (!trimmed.startsWith('data: '))
+                            continue;
+                        try {
+                            const data = JSON.parse(trimmed.slice(6));
+                            if (data.id)
+                                responseId = data.id;
+                            if (data.model)
+                                responseModel = data.model;
+                            const choice = data.choices?.[0];
+                            if (!choice)
+                                continue;
+                            if (choice.finish_reason)
+                                finishReason = choice.finish_reason;
+                            const delta = choice.delta;
+                            if (!delta)
+                                continue;
+                            if (delta.role)
+                                role = delta.role;
+                            if (delta.content) {
+                                contentAccum += delta.content;
+                                this.onStreamingContent(delta.content);
+                            }
+                            if (delta.reasoning) {
+                                reasoningAccum += delta.reasoning;
+                            }
+                            if (delta.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    const idx = tc.index ?? 0;
+                                    if (!toolCallsMap.has(idx)) {
+                                        toolCallsMap.set(idx, { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } });
+                                    }
+                                    const existing = toolCallsMap.get(idx);
+                                    if (tc.id)
+                                        existing.id = tc.id;
+                                    if (tc.function?.name)
+                                        existing.function.name += tc.function.name;
+                                    if (tc.function?.arguments)
+                                        existing.function.arguments += tc.function.arguments;
+                                }
+                            }
+                        }
+                        catch { }
+                    }
+                }
+                this.currentAbortController = null;
+                const toolCalls = Array.from(toolCallsMap.values())
+                    .filter(tc => tc.id && tc.function.name)
+                    .map(tc => ({ id: tc.id, type: 'function', function: { name: tc.function.name, arguments: tc.function.arguments } }));
+                const reassembledMessage = {
+                    role: role,
+                    content: contentAccum,
+                    ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+                    ...(reasoningAccum ? { reasoning: reasoningAccum } : {}),
+                };
+                response = {
+                    data: {
+                        id: responseId,
+                        object: 'chat.completion',
+                        created: Math.floor(Date.now() / 1000),
+                        model: responseModel || modelId,
+                        choices: [{ index: 0, message: reassembledMessage, finish_reason: finishReason }],
+                    },
+                    status: streamResp.status,
+                    statusText: streamResp.statusText,
+                    headers: streamResp.headers,
+                };
+            }
+            else {
+                const httpResp = await this.axiosInstance.post(url, requestBody, {
+                    signal: this.currentAbortController.signal,
+                    headers: buildPerRequestHeaders(),
+                });
+                this.currentAbortController = null;
+                response = { data: httpResp.data, status: httpResp.status, statusText: httpResp.statusText, headers: httpResp.headers };
+                captureBatutaHeaders(response.headers);
+            }
             const elapsed = logger.endTimer('llm-api-call');
-            captureBatutaHeaders(response.headers);
             logger.flow('API response received');
             if (!response.data.choices || !Array.isArray(response.data.choices)) {
                 logger.error('Invalid response structure - missing choices array', response.data);
@@ -354,7 +454,7 @@ export class LLMClient {
             const requestBody = {
                 model: modelId,
                 messages: processedMessages,
-                temperature: options.temperature ?? 0.7,
+                temperature: options.temperature ?? 0,
                 max_tokens: options.max_tokens,
                 stream: true,
                 ...(options.tools && {
@@ -495,9 +595,7 @@ export class LLMClient {
         const toolCallHistory = [];
         let iterations = 0;
         let contextLengthRecoveryAttempted = false;
-        let noToolCallRetries = 0;
         let finalResponseFailures = 0;
-        const MAX_NO_TOOL_CALL_RETRIES = 3;
         const MAX_FINAL_RESPONSE_FAILURES = 3;
         const recentToolSignatures = [];
         const recentNormalizedSignatures = [];
@@ -524,7 +622,7 @@ export class LLMClient {
                 response = await this.chatCompletion({
                     messages: workingMessages,
                     tools,
-                    tool_choice: 'required',
+                    tool_choice: 'auto',
                     ...(roleModel ? { model: roleModel } : {}),
                 });
             }
@@ -733,34 +831,14 @@ export class LLMClient {
                 continue;
             }
             else {
-                noToolCallRetries++;
-                logger.flow(`No tool call - enforcing tool usage (attempt ${noToolCallRetries}/${MAX_NO_TOOL_CALL_RETRIES})`);
-                if (noToolCallRetries > MAX_NO_TOOL_CALL_RETRIES) {
-                    logger.warn('Max no-tool-call retries exceeded - returning content as final response');
-                    const fallbackContent = assistantMessage.content || 'Task completed.';
-                    const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
-                    emitAssistantResponse(fallbackContent);
-                    return {
-                        message: { role: 'assistant', content: fallbackContent },
-                        toolCalls: toolCallHistory,
-                        allMessages: workingMessages,
-                    };
-                }
-                const hasMalformedToolCall = assistantMessage.content &&
-                    (/<tool_call>/i.test(assistantMessage.content) ||
-                        /<arg_key>/i.test(assistantMessage.content) ||
-                        /<arg_value>/i.test(assistantMessage.content) ||
-                        /<\/tool_call>/i.test(assistantMessage.content) ||
-                        /bash<arg_key>/i.test(assistantMessage.content));
-                const retryMessage = hasMalformedToolCall
-                    ? 'Your previous response contained a malformed tool call (XML tags in content). You MUST use the proper tool_calls API format. Use final_response tool to deliver your message to the user.'
-                    : 'You must use tools for all actions. Use final_response tool to deliver your final message to the user after completing all tasks.';
-                workingMessages.push({
-                    role: 'user',
-                    content: retryMessage,
-                });
-                logger.debug('Enforcing tool call - added retry message');
-                continue;
+                const finalContent = assistantMessage.content || 'Task completed.';
+                const { emitAssistantResponse } = await import('../../tools/llm/simple/file-tools.js');
+                emitAssistantResponse(finalContent);
+                return {
+                    message: { role: 'assistant', content: finalContent },
+                    toolCalls: toolCallHistory,
+                    allMessages: workingMessages,
+                };
             }
         }
     }

package/dist/core/onboarding.d.ts

@@ -0,0 +1,3 @@
+export declare function shouldShowOnboarding(): boolean;
+export declare function runOnboarding(): Promise<boolean>;
+//# sourceMappingURL=onboarding.d.ts.map

package/dist/core/onboarding.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk';
+import { configManager } from './config/config-manager.js';
+import { scanProviders, toEndpointConfig } from './config/auto-detect.js';
+import { CONFIG_FILE_PATH } from '../constants.js';
+import * as fs from 'fs';
+export function shouldShowOnboarding() {
+    if (!fs.existsSync(CONFIG_FILE_PATH))
+        return true;
+    return !configManager.hasEndpoints();
+}
+export async function runOnboarding() {
+    console.log();
+    console.log(chalk.cyan('  ╔══════════════════════════════════════════╗'));
+    console.log(chalk.cyan('  ║') + chalk.bold('   Welcome to Orquesta CLI! 🎵            ') + chalk.cyan('║'));
+    console.log(chalk.cyan('  ╚══════════════════════════════════════════╝'));
+    console.log();
+    console.log(chalk.dim('  Scanning for LLM providers...'));
+    console.log();
+    const result = await scanProviders();
+    if (result.detected.length === 0) {
+        console.log(chalk.yellow('  No LLM providers detected.'));
+        console.log();
+        console.log(chalk.dim('  To get started, do one of the following:'));
+        console.log(chalk.dim('    • Set an env var: OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.'));
+        console.log(chalk.dim('    • Start a local provider (Ollama on port 11434)'));
+        console.log(chalk.dim('    • Run: orquesta --add-provider <provider-id>'));
+        console.log();
+        return false;
+    }
+    let addedCount = 0;
+    for (const detected of result.detected) {
+        const endpoint = toEndpointConfig(detected);
+        await configManager.addEndpoint(endpoint);
+        addedCount++;
+        if (addedCount === 1 && endpoint.models.length > 0) {
+            await configManager.setCurrentEndpoint(endpoint.id);
+            await configManager.setCurrentModel(endpoint.models[0].id);
+        }
+    }
+    console.log(chalk.green(`  ✓ Auto-configured ${addedCount} provider(s):`));
+    for (const d of result.detected) {
+        const modelCount = d.discoveredModels.length;
+        console.log(chalk.white(`    • ${d.provider.name}`) + chalk.dim(` (${modelCount} model${modelCount !== 1 ? 's' : ''})`));
+    }
+    console.log();
+    return true;
+}
+//# sourceMappingURL=onboarding.js.map

package/dist/core/slash-command-handler.js

@@ -1,3 +1,4 @@
+import { commandRegistry } from './commands/index.js';
 import { sessionManager } from './session/session-manager.js';
 import { usageTracker } from './usage-tracker.js';
 import { logger } from '../utils/logger.js';
@@ -6,72 +7,24 @@ import { readHookConfig, writeHookFiles, disableHooks } from '../orquesta/hook-i
 import { checkForCliUpdate, runCliUpdate, setSkippedVersion } from '../utils/update-checker.js';
 import { createRequire } from 'module';
 import { configManager } from './config/config-manager.js';
-import { getForcedTier, setForcedTier, resetBatutaSession } from './routing-state.js';
+import { getForcedTier, setForcedTier } from './routing-state.js';
 import { auditLog } from '../orchestration/audit-log.js';
 import { remotePhone } from '../orquesta/remote-phone.js';
 export async function executeSlashCommand(command, context) {
     const trimmedCommand = command.trim();
     logger.enter('executeSlashCommand', { command: trimmedCommand });
+    const commandName = trimmedCommand.split(/\s/)[0];
+    const registryResult = await commandRegistry.execute(commandName, context, trimmedCommand);
+    if (registryResult) {
+        logger.exit('executeSlashCommand', { handled: true, command: commandName, source: 'registry' });
+        return registryResult;
+    }
     if (trimmedCommand === '/exit' || trimmedCommand === '/quit') {
         logger.flow('Exit command received');
         context.exit();
         logger.exit('executeSlashCommand', { handled: true, command: 'exit' });
         return { handled: true, shouldContinue: false };
     }
-    if (trimmedCommand === '/clear') {
-        logger.flow('Clear command - resetting messages and todos');
-        context.setMessages([]);
-        context.setTodos([]);
-        resetBatutaSession();
-        logger.exit('executeSlashCommand', { handled: true, command: 'clear' });
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: [],
-                todos: [],
-            },
-        };
-    }
-    if (trimmedCommand === '/compact') {
-        logger.flow('Compact command received');
-        if (context.onCompact) {
-            logger.flow('Executing compact callback');
-            const result = await context.onCompact();
-            logger.vars({ name: 'compactSuccess', value: result.success }, { name: 'originalCount', value: result.originalMessageCount }, { name: 'newCount', value: result.newMessageCount });
-            const compactMessage = result.success
-                ? `✅ Conversation compacted successfully. (${result.originalMessageCount} → ${result.newMessageCount} messages)`
-                : `❌ Compact failed: ${result.error}`;
-            const baseMessages = (result.success && result.compactedMessages)
-                ? result.compactedMessages
-                : context.messages;
-            const updatedMessages = [
-                ...baseMessages,
-                { role: 'assistant', content: compactMessage },
-            ];
-            context.setMessages(updatedMessages);
-            return {
-                handled: true,
-                shouldContinue: false,
-                updatedContext: {
-                    messages: updatedMessages,
-                },
-            };
-        }
-        const fallbackMessage = '/compact is only available in interactive mode.';
-        const updatedMessages = [
-            ...context.messages,
-            { role: 'assistant', content: fallbackMessage },
-        ];
-        context.setMessages(updatedMessages);
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: updatedMessages,
-            },
-        };
-    }
     if (trimmedCommand === '/settings') {
         if (context.onShowSettings) {
             context.onShowSettings();
@@ -524,41 +477,6 @@ ${executorLines}
         context.setMessages(updatedMessages);
         return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
     }
-    if (trimmedCommand.startsWith('/memory')) {
-        const sub = trimmedCommand.slice(7).trim();
-        const { addMemory, removeMemory, clearMemory, listMemory } = await import('./memory.js');
-        const reply = (content) => {
-            const updatedMessages = [...context.messages, { role: 'assistant', content }];
-            context.setMessages(updatedMessages);
-            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
-        };
-        if (sub.startsWith('add ')) {
-            const note = sub.slice(4).trim();
-            if (!note)
-                return reply('Usage: /memory add <note>');
-            addMemory(note);
-            return reply(`✓ Saved to memory: "${note}"`);
-        }
-        if (sub === 'list' || sub === '') {
-            const entries = listMemory();
-            if (entries.length === 0)
-                return reply('Memory is empty. Use `/memory add <note>` to save preferences.');
-            const list = entries.map((e, i) => `  ${i + 1}. ${e}`).join('\n');
-            return reply(`📝 User memory (${entries.length} entries):\n${list}\n\nCommands: /memory add <note> | remove <n> | clear`);
-        }
-        if (sub.startsWith('remove ')) {
-            const idx = parseInt(sub.slice(7).trim(), 10);
-            if (isNaN(idx))
-                return reply('Usage: /memory remove <number>');
-            const ok = removeMemory(idx);
-            return reply(ok ? `✓ Removed entry #${idx}` : `Entry #${idx} not found`);
-        }
-        if (sub === 'clear') {
-            clearMemory();
-            return reply('✓ Memory cleared');
-        }
-        return reply('Usage: /memory add <note> | list | remove <n> | clear');
-    }
     if (trimmedCommand === '/update') {
         logger.flow('Update command received');
         const reply = (content) => {
@@ -661,51 +579,6 @@ ${executorLines}
             return reply(`❌ Could not open the remote phone channel: ${e.message}`);
         }
     }
-    if (trimmedCommand === '/help') {
-        const helpMessage = `
-Available commands:
-  /exit, /quit    - Exit the application
-  /clear          - Clear conversation and TODOs
-  /compact        - Compact conversation to free up context
-  /memory         - Persistent memory: /memory add <note> | list | remove <n> | clear
-  /settings       - Open settings menu
-  /model          - Switch between LLM models
-  /project        - Switch between Orquesta projects
-  /tool           - Enable/disable optional tools (Browser, Background)
-  /load           - Load a saved session
-  /usage          - Show token usage statistics
-  /cost           - Estimated USD spend this process (by model)
-  /route          - Pin Batuta Auto tier (fast/balanced/premium/auto)
-  /sync           - Bidirectional sync with Orquesta dashboard (pull & push LLM configs)
-  /login          - Sign in to Orquesta via browser (opens getorquesta.com)
-  /logout         - Sign out of Orquesta (clears token, keeps local LLM configs)
-  /whoami         - Show current Orquesta connection
-  /hook           - Claude Code hook here: /hook status | enable | disable
-  /remote-phone   - Drive this session from your phone: on | off | status
-  /update         - Update orquesta-cli to the latest version
-
-Keyboard shortcuts:
-  Ctrl+C          - Exit
-  Ctrl+T          - Toggle TODO details
-  ESC             - Interrupt current execution
-  @               - File browser
-  /               - Command autocomplete
-
-Note: All conversations are automatically saved.
-    `;
-        const updatedMessages = [
-            ...context.messages,
-            { role: 'assistant', content: helpMessage },
-        ];
-        context.setMessages(updatedMessages);
-        return {
-            handled: true,
-            shouldContinue: false,
-            updatedContext: {
-                messages: updatedMessages,
-            },
-        };
-    }
     if (trimmedCommand.startsWith('/load')) {
         logger.flow('Load command received');
         const parts = trimmedCommand.split(' ');

package/dist/orchestration/plan-executor.js

@@ -4,12 +4,14 @@ import { CompactManager, contextTracker, buildCompactedMessages, } from '../core
 import { configManager } from '../core/config/config-manager.js';
 import { setTodoWriteCallback, clearTodoCallbacks, } from '../tools/llm/simple/todo-tools.js';
 import { setGetTodosCallback, setFinalResponseCallback, setMarkTodosCompletedCallback, clearFinalResponseCallbacks, } from '../tools/llm/simple/final-response-tool.js';
+import { eventBus, Events } from '../core/event-bus.js';
 import { setDocsSearchLLMClientGetter, clearDocsSearchLLMClientGetter, } from '../tools/llm/simple/docs-search-agent-tool.js';
 import { emitPlanCreated, emitTodoStart, emitTodoComplete, emitTodoFail, emitCompact, emitAssistantResponse, } from '../tools/llm/simple/file-tools.js';
 import { toolRegistry } from '../tools/registry.js';
 import { PLAN_EXECUTE_SYSTEM_PROMPT as PLAN_PROMPT } from '../prompts/system/plan-execute.js';
 import { getProjectContext } from '../core/project-context.js';
 import { getMemoryPrompt } from '../core/memory.js';
+import { getGitContextPrompt } from '../core/git-context.js';
 import { GIT_COMMIT_RULES } from '../prompts/shared/git-rules.js';
 import { logger } from '../utils/logger.js';
 import { getStreamLogger } from '../utils/json-stream-logger.js';
@@ -34,7 +36,7 @@ function buildSystemPrompt() {
     const projectContext = getProjectContext();
     const base = isGitRepo ? `${PLAN_PROMPT}\n\n${GIT_COMMIT_RULES}` : PLAN_PROMPT;
     const appended = appendedSystemPrompt ? `\n\n${appendedSystemPrompt}` : '';
-    return base + buildEnvironmentContext() + projectContext + getMemoryPrompt() + appended;
+    return base + buildEnvironmentContext() + projectContext + getMemoryPrompt() + getGitContextPrompt() + appended;
 }
 export class PlanExecutor {
     currentLLMClient = null;
@@ -80,74 +82,82 @@ export class PlanExecutor {
                 throw new Error('INTERRUPTED');
             }
             let currentMessages = messages;
-            callbacks.setCurrentActivity('Thinking');
-            const plannerModel = configManager.getRoleModel('planner');
-            const planningLLM = new PlanningLLM(llmClient, plannerModel ?? undefined);
-            const plannerStartedAt = Date.now();
-            if (callbacks.askUser) {
-                planningLLM.setAskUserCallback(callbacks.askUser);
+            const isSimpleTask = userMessage.length < 500 &&
+                !/\b(and then|after that|first.*then|step \d|multiple|several|refactor.*entire|migrate|rewrite.*all)\b/i.test(userMessage);
+            if (isSimpleTask) {
+                logger.flow('Simple task detected — skipping planner, executor will handle directly');
+                streamLogger?.logPlanningEnd(0, [], false, 0);
             }
-            const planResult = await planningLLM.generateTODOListWithDocsDecision(userMessage, currentMessages);
-            auditLog.emit(auditSid, 'planner.complete', {
-                runId,
-                model: plannerModel,
-                durationMs: Date.now() - plannerStartedAt,
-                todoCount: planResult.todos.length,
-                directResponse: !!planResult.directResponse,
-            });
-            if (planResult.clarificationMessages?.length) {
-                currentMessages = [...currentMessages, ...planResult.clarificationMessages];
-                callbacks.setMessages([...currentMessages]);
-                logger.flow('Added planning clarification messages to history', {
-                    count: planResult.clarificationMessages.length,
+            else {
+                callbacks.setCurrentActivity('Thinking');
+                const plannerModel = configManager.getRoleModel('planner');
+                const planningLLM = new PlanningLLM(llmClient, plannerModel ?? undefined);
+                const plannerStartedAt = Date.now();
+                if (callbacks.askUser) {
+                    planningLLM.setAskUserCallback(callbacks.askUser);
+                }
+                const planResult = await planningLLM.generateTODOListWithDocsDecision(userMessage, currentMessages);
+                auditLog.emit(auditSid, 'planner.complete', {
+                    runId,
+                    model: plannerModel,
+                    durationMs: Date.now() - plannerStartedAt,
+                    todoCount: planResult.todos.length,
+                    directResponse: !!planResult.directResponse,
                 });
-            }
-            if (planResult.directResponse) {
-                logger.flow('Direct response - no execution needed');
-                streamLogger?.logPlanningEnd(0, [], true, Date.now() - planningStartTime);
-                const lastMsg = currentMessages[currentMessages.length - 1];
-                const needsUserMessage = !(lastMsg?.role === 'user' && lastMsg?.content === userMessage);
-                const updatedMessages = needsUserMessage
+                if (planResult.clarificationMessages?.length) {
+                    currentMessages = [...currentMessages, ...planResult.clarificationMessages];
+                    callbacks.setMessages([...currentMessages]);
+                    logger.flow('Added planning clarification messages to history', {
+                        count: planResult.clarificationMessages.length,
+                    });
+                }
+                if (planResult.directResponse) {
+                    logger.flow('Direct response - no execution needed');
+                    streamLogger?.logPlanningEnd(0, [], true, Date.now() - planningStartTime);
+                    const lastMsg = currentMessages[currentMessages.length - 1];
+                    const needsUserMessage = !(lastMsg?.role === 'user' && lastMsg?.content === userMessage);
+                    const updatedMessages = needsUserMessage
+                        ? [
+                            ...currentMessages,
+                            { role: 'user', content: userMessage },
+                            { role: 'assistant', content: planResult.directResponse }
+                        ]
+                        : [
+                            ...currentMessages,
+                            { role: 'assistant', content: planResult.directResponse }
+                        ];
+                    emitAssistantResponse(planResult.directResponse);
+                    callbacks.setMessages([...updatedMessages]);
+                    sessionManager.autoSaveCurrentSession(updatedMessages);
+                    callbacks.setExecutionPhase('idle');
+                    logger.exit('PlanExecutor.executePlanMode', { directResponse: true });
+                    return;
+                }
+                currentTodos = planResult.todos;
+                streamLogger?.logPlanningEnd(currentTodos.length, currentTodos.map(t => ({ id: t.id, title: t.title, status: t.status })), false, Date.now() - planningStartTime);
+                logger.vars({ name: 'todoCount', value: currentTodos.length }, { name: 'docsSearchNeeded', value: planResult.docsSearchNeeded });
+                callbacks.setTodos(currentTodos);
+                emitPlanCreated(currentTodos.map(t => t.title));
+                const planMessage = planResult.docsSearchNeeded
+                    ? `📋 Created ${currentTodos.length} tasks (including docs search). Starting execution...`
+                    : `📋 Created ${currentTodos.length} tasks. Starting execution...`;
+                const lastMsgForPlan = currentMessages[currentMessages.length - 1];
+                const needsUserMessageForPlan = !(lastMsgForPlan?.role === 'user' && lastMsgForPlan?.content === userMessage);
+                currentMessages = needsUserMessageForPlan
                     ? [
                         ...currentMessages,
                         { role: 'user', content: userMessage },
-                        { role: 'assistant', content: planResult.directResponse }
+                        { role: 'assistant', content: planMessage }
                     ]
                     : [
                         ...currentMessages,
-                        { role: 'assistant', content: planResult.directResponse }
+                        { role: 'assistant', content: planMessage }
                     ];
-                emitAssistantResponse(planResult.directResponse);
-                callbacks.setMessages([...updatedMessages]);
-                sessionManager.autoSaveCurrentSession(updatedMessages);
-                callbacks.setExecutionPhase('idle');
-                logger.exit('PlanExecutor.executePlanMode', { directResponse: true });
-                return;
+                callbacks.setMessages(currentMessages);
+                this.setupTodoCallbacks(currentTodos, callbacks, (updated) => {
+                    currentTodos = updated;
+                });
             }
-            currentTodos = planResult.todos;
-            streamLogger?.logPlanningEnd(currentTodos.length, currentTodos.map(t => ({ id: t.id, title: t.title, status: t.status })), false, Date.now() - planningStartTime);
-            logger.vars({ name: 'todoCount', value: currentTodos.length }, { name: 'docsSearchNeeded', value: planResult.docsSearchNeeded });
-            callbacks.setTodos(currentTodos);
-            emitPlanCreated(currentTodos.map(t => t.title));
-            const planMessage = planResult.docsSearchNeeded
-                ? `📋 Created ${currentTodos.length} tasks (including docs search). Starting execution...`
-                : `📋 Created ${currentTodos.length} tasks. Starting execution...`;
-            const lastMsgForPlan = currentMessages[currentMessages.length - 1];
-            const needsUserMessageForPlan = !(lastMsgForPlan?.role === 'user' && lastMsgForPlan?.content === userMessage);
-            currentMessages = needsUserMessageForPlan
-                ? [
-                    ...currentMessages,
-                    { role: 'user', content: userMessage },
-                    { role: 'assistant', content: planMessage }
-                ]
-                : [
-                    ...currentMessages,
-                    { role: 'assistant', content: planMessage }
-                ];
-            callbacks.setMessages(currentMessages);
-            this.setupTodoCallbacks(currentTodos, callbacks, (updated) => {
-                currentTodos = updated;
-            });
             callbacks.setExecutionPhase('executing');
             const tools = toolRegistry.getLLMToolDefinitions();
             const hasSystemMessage = currentMessages.some(m => m.role === 'system');
@@ -198,12 +208,9 @@ export class PlanExecutor {
             }
             else {
                 const todoContext = buildTodoContext(currentTodos);
-                const lastUserMsgIndex = currentMessages.map(m => m.role).lastIndexOf('user');
-                const messagesForLLM = lastUserMsgIndex >= 0
-                    ? currentMessages.map((m, i) => i === lastUserMsgIndex
-                        ? { ...m, content: m.content + todoContext }
-                        : m)
-                    : [...currentMessages, { role: 'user', content: `Execute the TODO list.${todoContext}` }];
+                const messagesForLLM = todoContext
+                    ? [...currentMessages, { role: 'user', content: `[Current task status]${todoContext}` }]
+                    : currentMessages;
                 const executorModel = configManager.getRoleModel('executor');
                 const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
                     getPendingMessage: callbacks.getPendingMessage,
@@ -314,12 +321,9 @@ export class PlanExecutor {
             const activeTodo = findActiveTodo(currentTodos);
             callbacks.setCurrentActivity(activeTodo?.title || 'Working on tasks');
             const todoContext = buildTodoContext(currentTodos);
-            const lastUserMsgIndex = currentMessages.map(m => m.role).lastIndexOf('user');
-            const messagesForLLM = lastUserMsgIndex >= 0
-                ? currentMessages.map((m, i) => i === lastUserMsgIndex
-                    ? { ...m, content: m.content + todoContext }
-                    : m)
-                : [...currentMessages, { role: 'user', content: `Resume the TODO list.${todoContext}` }];
+            const messagesForLLM = todoContext
+                ? [...currentMessages, { role: 'user', content: `[Current task status]${todoContext}` }]
+                : currentMessages;
             const executorModel = configManager.getRoleModel('executor');
             const result = await llmClient.chatCompletionWithTools(messagesForLLM, tools, {
                 getPendingMessage: callbacks.getPendingMessage,
@@ -460,6 +464,8 @@ export class PlanExecutor {
         setFinalResponseCallback((message) => {
             emitAssistantResponse(message);
         });
+        void eventBus.on(Events.FINAL_RESPONSE, (_message) => {
+        });
         setMarkTodosCompletedCallback(() => {
             const completed = todosRef.map(t => t.status === 'completed' || t.status === 'failed'
                 ? t

package/dist/prompts/shared/tool-usage.js

@@ -22,7 +22,6 @@ export const AVAILABLE_TOOLS_WITH_TODO = `
 - **tell_to_user**: Send status updates to the user
 - **ask_to_user**: Ask user a question with multiple choice options
 - **write_todos**: Update entire TODO list (replaces current list)
-- **call_docs_search_agent**: Search local documentation (~/.local-cli/docs)
 `.trim();
 export const TOOL_REASON_GUIDE = `
 ## CRITICAL - Tool "reason" Parameter