orquesta-cli 0.2.45 → 0.2.47

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

package/dist/prompts/system/plan-execute.js

@@ -1,83 +1,76 @@
 import { LANGUAGE_PRIORITY_RULE } from '../shared/language-rules.js';
-import { AVAILABLE_TOOLS_WITH_TODO, TOOL_REASON_GUIDE } from '../shared/tool-usage.js';
 import { CODEBASE_FIRST_RULE } from '../shared/codebase-rules.js';
-export const PLAN_EXECUTE_SYSTEM_PROMPT = `You are an AI assistant executing a TODO-based plan.
+export const PLAN_EXECUTE_SYSTEM_PROMPT = `You are Orquesta, an expert AI coding assistant working in the user's terminal. You write correct, production-quality code and help with any development task.
 
 ${LANGUAGE_PRIORITY_RULE}
 
-## TODO Workflow
+## How You Work
 
-1. Work through TODOs systematically
-2. Update status using \`write_todos\` (include ALL todos with current status)
-3. **DONE when ALL TODOs are "completed"**
+1. **Understand first** — Read relevant code before modifying it. Never guess file contents.
+2. **Act, don't describe** — Use tools to do the work. Don't say "I would do X", just do X.
+3. **Verify your changes** — After edits, run the build/tests if available to confirm nothing broke.
+4. **Be concise** — Short answers for simple questions. Thorough work for complex tasks.
+5. **Match the user's intent** — Do what was asked, no more. Don't add unrequested features or refactors.
 
-**CRITICAL: Keep TODO status in sync with your actual progress!**
-- When starting a task → mark it "in_progress" IMMEDIATELY
-- When finishing a task → mark it "completed" IMMEDIATELY
-- The user sees the TODO list in real-time - mismatched status is confusing
-- Call \`write_todos\` FREQUENTLY, not just at the end
+## Decision Framework
 
-${AVAILABLE_TOOLS_WITH_TODO}
+- **Simple questions** (what is X, explain Y): Respond directly with knowledge.
+- **Code tasks** (fix, add, edit, refactor): Read → Edit → Verify. Use tools.
+- **Investigation** (why is this failing, what does X do): Read code, search, then explain.
+- **Ambiguous requests**: Infer the most useful action and proceed. Only ask if truly blocked.
 
-${TOOL_REASON_GUIDE}
+## Tool Usage
 
-## Execution Rules
+Use tools for all file operations, commands, and code changes. Your available tools:
+- **read_file**: Always read before editing
+- **edit_file**: Modify existing files (match exact content for old_string)
+- **create_file**: Create new files
+- **list_files** / **find_files** / **search_content**: Navigate the codebase
+- **bash**: Run commands (build, test, git, etc.)
+- **tell_to_user**: Show progress updates
+- **write_todos**: Track task progress (for multi-step work)
 
-1. **Read before modify** - Always read existing code first
-2. **Use tools** - Perform actual work, don't just describe
-3. **Retry on error** - Up to 3 attempts before marking "failed"
-4. **Stay focused** - Only work on TODOs, no unrelated features
+Every tool has a "reason" parameter shown to the user. Write it naturally in the user's language.
 
-${CODEBASE_FIRST_RULE}
-
-## CRITICAL: Tool Error Handling
-
-**If a tool returns an error, you MUST retry the same tool with corrected parameters.**
+## Code Quality Rules
 
-1. STOP - Read the error message carefully
-2. Investigate - Use \`read_file\` to check actual file content
-3. **RETRY THE SAME TOOL** with corrected parameters (DO NOT skip or move on)
-4. Repeat until success or 3 failures
+- Write minimal, correct code that solves the problem
+- Follow existing project conventions (style, naming, patterns)
+- Use secure coding practices by default
+- Don't introduce new dependencies unless necessary
+- Include error handling where appropriate
 
-**You are NOT allowed to:**
-- Skip the failed tool and move to next task
-- Say "I'll try a different approach" without actually retrying
-- Mark TODO as complete if the tool failed
+## Error Handling
 
-Example flow:
-1. \`edit_file\` fails: "Line 77 content does not match"
-2. Call \`read_file\` to see actual content
-3. **Call \`edit_file\` again** with correct \`old_string\`
-4. Only proceed after edit succeeds
+If a tool fails:
+1. Read the error carefully
+2. Investigate (read_file to check actual content)
+3. Retry with corrected parameters
+4. Only give up after 3 failed attempts
 
-## CRITICAL: When to Respond
+Common edit_file failures: wrong old_string → re-read file, copy exact text, retry.
 
-**ONLY respond when ALL TODOs are "completed" or "failed".**
-
-- Responding early = execution ends prematurely
-- Use \`tell_to_user\` to communicate progress during execution
-- \`write_todos\` only updates internal state
-
-**Before final response, verify:**
-- All TODOs completed?
-- All tool calls successful?
-- User's request fulfilled?
+${CODEBASE_FIRST_RULE}
 
-## CRITICAL: Final Response
+## Response Style
 
-Your final response MUST contain the **actual answer or result**:
-- Question → Answer with information found
-- Task → Summarize what was done
+- Direct and concise. No filler phrases.
+- Code in markdown blocks with language tags.
+- When summarizing completed work: state what was done in 1-3 sentences.
+- Match the user's language (if they write in Spanish, respond in Spanish).
 
-**DO NOT** just say "Task complete" or give task statistics.
+## TODO Workflow (for multi-step tasks)
 
-Example:
-- User: "What's the project name?" → "This project is **LOCAL-CLI**."
-- User: "Add a debug function" → "Added debug function to logger.ts."
+When working on a plan with TODOs:
+- Update status via write_todos as you progress
+- Mark "in_progress" when starting, "completed" when done
+- Stay focused on the current task
 
-## Loop Detection
+## IMPORTANT
 
-If TODO context keeps repeating but work is done → IMMEDIATELY mark all as "completed".
+- You can respond directly without using any tool — do so for simple questions or when you're done working.
+- After completing all requested work, give a brief summary of what was done.
+- Never fabricate file contents, paths, or command outputs. If unsure, investigate first.
 `;
 export default PLAN_EXECUTE_SYSTEM_PROMPT;
 //# sourceMappingURL=plan-execute.js.map

package/dist/tools/llm/simple/file-tools.js

@@ -1,6 +1,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { logger } from '../../../utils/logger.js';
+import { shouldIgnore } from '../../../core/ignore-filter.js';
 const EXCLUDED_DIRS = new Set([
     'node_modules',
     '.git',
@@ -451,6 +452,9 @@ async function getFilesRecursively(dirPath, baseDir = dirPath, depth = 0, fileCo
         }
         const fullPath = path.join(dirPath, entry.name);
         const relativePath = path.relative(baseDir, fullPath);
+        if (shouldIgnore(fullPath)) {
+            continue;
+        }
         if (entry.isDirectory()) {
             if (EXCLUDED_DIRS.has(entry.name)) {
                 continue;
@@ -491,7 +495,9 @@ async function _executeListFilesInternal(args) {
         }
         else {
             const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
-            const files = entries.map((entry) => ({
+            const files = entries
+                .filter(entry => !shouldIgnore(path.join(resolvedPath, entry.name)))
+                .map((entry) => ({
                 name: entry.name,
                 type: entry.isDirectory() ? 'directory' : 'file',
                 path: path.join(directoryPath, entry.name),
@@ -580,6 +586,9 @@ async function findFilesRecursively(dirPath, regex, baseDir, depth = 0, fileCoun
             continue;
         }
         const fullPath = path.join(dirPath, entry.name);
+        if (shouldIgnore(fullPath)) {
+            continue;
+        }
         if (entry.isDirectory()) {
             if (EXCLUDED_DIRS.has(entry.name)) {
                 continue;
@@ -700,6 +709,8 @@ async function searchContentRecursively(dirPath, searchRegex, baseDir, fileRegex
         if (entry.name.startsWith('.'))
             continue;
         const fullPath = path.join(dirPath, entry.name);
+        if (shouldIgnore(fullPath))
+            continue;
         if (entry.isDirectory()) {
             if (EXCLUDED_DIRS.has(entry.name))
                 continue;

package/dist/tools/llm/simple/final-response-tool.js

@@ -1,4 +1,5 @@
 import { logger } from '../../../utils/logger.js';
+import { eventBus, Events } from '../../../core/event-bus.js';
 let getTodosCallback = null;
 let finalResponseCallback = null;
 let markTodosCompletedCallback = null;
@@ -28,23 +29,16 @@ const FINAL_RESPONSE_DEFINITION = {
     type: 'function',
     function: {
         name: 'final_response',
-        description: `Use this tool to deliver your final response to the user after completing all tasks.
+        description: `Deliver a final summary to the user after completing work. Optional — you can also respond directly without this tool.
 
-IMPORTANT:
-- You MUST complete all TODOs before calling this tool
-- If any TODO is not completed, this tool will return an error
-- After all tasks are done, use this tool to summarize what was accomplished
-
-Example:
-{
-  "message": "I've completed all the requested tasks:\\n\\n1. Fixed the bug in the login form\\n2. Added input validation\\n3. Updated the tests\\n\\nAll changes have been committed."
-}`,
+Use this when you want to explicitly signal task completion with a summary.
+Any incomplete TODOs will be auto-marked as done.`,
         parameters: {
             type: 'object',
             properties: {
                 message: {
                     type: 'string',
-                    description: 'Your final response message to the user. Summarize what was accomplished.',
+                    description: 'Your final response message to the user.',
                 },
             },
             required: ['message'],
@@ -138,6 +132,7 @@ async function executeFinalResponse(args) {
         if (finalResponseCallback) {
             finalResponseCallback(message);
         }
+        eventBus.emit(Events.FINAL_RESPONSE, message);
         return {
             success: true,
             result: message,
@@ -163,6 +158,7 @@ async function executeFinalResponse(args) {
     if (finalResponseCallback) {
         finalResponseCallback(message);
     }
+    eventBus.emit(Events.FINAL_RESPONSE, message);
     return {
         success: true,
         result: message,

package/dist/tools/registry.js

@@ -9,10 +9,33 @@ import { PLANNING_TOOLS } from './llm/simple/planning-tools.js';
 import { FinalResponseTool } from './llm/simple/final-response-tool.js';
 import { RemotePhoneTool } from './llm/simple/remote-phone-tool.js';
 import { getShellTools } from './llm/simple/index.js';
-import { BROWSER_TOOLS, startBrowserServer, shutdownBrowserServer } from './browser/index.js';
-import { WORD_TOOLS, EXCEL_TOOLS, POWERPOINT_TOOLS } from './office/index.js';
+let _browserTools = null;
+let _startBrowserServer = null;
+let _shutdownBrowserServer = null;
+async function getBrowserModule() {
+    if (!_browserTools) {
+        const mod = await import('./browser/index.js');
+        _browserTools = mod.BROWSER_TOOLS;
+        _startBrowserServer = mod.startBrowserServer;
+        _shutdownBrowserServer = mod.shutdownBrowserServer;
+    }
+    return { BROWSER_TOOLS: _browserTools, startBrowserServer: _startBrowserServer, shutdownBrowserServer: _shutdownBrowserServer };
+}
+let _wordTools = null;
+let _excelTools = null;
+let _powerpointTools = null;
+async function getOfficeModule() {
+    if (!_wordTools) {
+        const mod = await import('./office/index.js');
+        _wordTools = mod.WORD_TOOLS;
+        _excelTools = mod.EXCEL_TOOLS;
+        _powerpointTools = mod.POWERPOINT_TOOLS;
+    }
+    return { WORD_TOOLS: _wordTools, EXCEL_TOOLS: _excelTools, POWERPOINT_TOOLS: _powerpointTools };
+}
 async function validateBrowserTools() {
     try {
+        const { startBrowserServer } = await getBrowserModule();
         await startBrowserServer();
         return { success: true };
     }
@@ -29,10 +52,19 @@ function getOptionalToolGroupsConfig() {
             id: 'browser',
             name: 'Browser Automation',
             description: 'Control Chrome/Edge browser for web testing (navigate, click, screenshot, etc.)',
-            tools: BROWSER_TOOLS,
+            tools: [],
             enabled: false,
-            onEnable: validateBrowserTools,
-            onDisable: shutdownBrowserServer,
+            onEnable: async () => {
+                const { BROWSER_TOOLS } = await getBrowserModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'browser');
+                if (group)
+                    group.tools = BROWSER_TOOLS;
+                return validateBrowserTools();
+            },
+            onDisable: async () => {
+                const { shutdownBrowserServer } = await getBrowserModule();
+                await shutdownBrowserServer();
+            },
         },
     ];
     if (hasWindowsAccess()) {
@@ -40,20 +72,41 @@ function getOptionalToolGroupsConfig() {
             id: 'word',
             name: 'Microsoft Word',
             description: 'Control Word for document editing (write, read, save, export PDF, header/footer)',
-            tools: WORD_TOOLS,
+            tools: [],
             enabled: false,
+            onEnable: async () => {
+                const { WORD_TOOLS } = await getOfficeModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'word');
+                if (group)
+                    group.tools = WORD_TOOLS;
+                return { success: true };
+            },
         }, {
             id: 'excel',
             name: 'Microsoft Excel',
             description: 'Control Excel for spreadsheet editing (cells, ranges, formulas, charts)',
-            tools: EXCEL_TOOLS,
+            tools: [],
             enabled: false,
+            onEnable: async () => {
+                const { EXCEL_TOOLS } = await getOfficeModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'excel');
+                if (group)
+                    group.tools = EXCEL_TOOLS;
+                return { success: true };
+            },
         }, {
             id: 'powerpoint',
             name: 'Microsoft PowerPoint',
             description: 'Control PowerPoint for presentations (slides, shapes, transitions, PDF export)',
-            tools: POWERPOINT_TOOLS,
+            tools: [],
             enabled: false,
+            onEnable: async () => {
+                const { POWERPOINT_TOOLS } = await getOfficeModule();
+                const group = OPTIONAL_TOOL_GROUPS.find(g => g.id === 'powerpoint');
+                if (group)
+                    group.tools = POWERPOINT_TOOLS;
+                return { success: true };
+            },
         });
     }
     return groups;
@@ -138,9 +191,9 @@ class ToolRegistry {
             logger.error('Tool group not found', { groupId });
             return { success: false, error: `Tool group '${groupId}' not found` };
         }
-        if (!skipValidation && group.onEnable) {
+        if (group.onEnable) {
             const result = await group.onEnable();
-            if (!result.success) {
+            if (!skipValidation && !result.success) {
                 return result;
             }
         }

package/dist/ui/components/PlanExecuteApp.d.ts

@@ -17,6 +17,7 @@ interface PlanExecuteAppProps {
         model: string;
         endpoint: string;
     };
+    resumeLastSession?: boolean;
 }
 export declare const PlanExecuteApp: React.FC<PlanExecuteAppProps>;
 export default PlanExecuteApp;