@defai.digital/ax-cli 2.7.0 → 3.0.0

package/dist/agent/llm-agent.js

@@ -2,6 +2,7 @@ import { LLMClient } from "../llm/client.js";
 import { getAllGrokTools, getMCPManager, initializeMCPServers, } from "../llm/tools.js";
 import { loadMCPConfig } from "../mcp/config.js";
 import { TextEditorTool, BashTool, TodoTool, SearchTool, } from "../tools/index.js";
+import { BashOutputTool } from "../tools/bash-output.js";
 import { EventEmitter } from "events";
 import { AGENT_CONFIG } from "../constants.js";
 import { createTokenCounter } from "../utils/token-counter.js";
@@ -11,10 +12,15 @@ import { ContextManager } from "./context-manager.js";
 import { buildSystemPrompt } from "../utils/prompt-builder.js";
 import { getUsageTracker } from "../utils/usage-tracker.js";
 import { extractErrorMessage } from "../utils/error-handler.js";
+import { getCheckpointManager } from "../checkpoint/index.js";
+import { SubagentOrchestrator } from "./subagent-orchestrator.js";
+import { getTaskPlanner, isComplexRequest, } from "../planner/index.js";
+import { PLANNER_CONFIG } from "../constants.js";
 export class LLMAgent extends EventEmitter {
     llmClient;
     textEditor;
     bash;
+    bashOutput;
     todoTool;
     search;
     chatHistory = [];
@@ -24,6 +30,11 @@ export class LLMAgent extends EventEmitter {
     abortController = null;
     maxToolRounds;
     recentToolCalls = new Map(); // Track recent tool calls to detect loops
+    checkpointManager;
+    subagentOrchestrator;
+    taskPlanner;
+    currentPlan = null;
+    planningEnabled = PLANNER_CONFIG.ENABLED;
     constructor(apiKey, baseURL, model, maxToolRounds) {
         super();
         const manager = getSettingsManager();
@@ -36,10 +47,28 @@ export class LLMAgent extends EventEmitter {
         this.llmClient = new LLMClient(apiKey, modelToUse, baseURL);
         this.textEditor = new TextEditorTool();
         this.bash = new BashTool();
+        this.bashOutput = new BashOutputTool();
         this.todoTool = new TodoTool();
         this.search = new SearchTool();
         this.tokenCounter = createTokenCounter(modelToUse);
         this.contextManager = new ContextManager({ model: modelToUse });
+        this.checkpointManager = getCheckpointManager();
+        this.subagentOrchestrator = new SubagentOrchestrator({ maxConcurrentAgents: 5 });
+        this.taskPlanner = getTaskPlanner();
+        // Wire up checkpoint callback for automatic checkpoint creation
+        this.textEditor.setCheckpointCallback(async (files, description) => {
+            await this.checkpointManager.createCheckpoint({
+                files,
+                conversationState: this.chatHistory,
+                description,
+                metadata: {
+                    model: this.llmClient.getCurrentModel(),
+                    triggeredBy: 'auto',
+                },
+            });
+        });
+        // Initialize checkpoint manager
+        this.initializeCheckpointManager();
         // Initialize MCP servers if configured
         this.initializeMCP();
         // Build system prompt from YAML configuration
@@ -53,6 +82,23 @@ export class LLMAgent extends EventEmitter {
             content: `${systemPrompt}\n\nCurrent working directory: ${process.cwd()}`,
         });
     }
+    initializeCheckpointManager() {
+        // Initialize checkpoint manager in the background
+        Promise.resolve().then(async () => {
+            try {
+                await this.checkpointManager.initialize();
+                this.emit('system', 'Checkpoint system initialized');
+            }
+            catch (error) {
+                const errorMsg = extractErrorMessage(error);
+                console.warn("Checkpoint initialization failed:", errorMsg);
+                this.emit('system', `Checkpoint initialization failed: ${errorMsg}`);
+            }
+        }).catch((error) => {
+            const errorMsg = extractErrorMessage(error);
+            console.warn("Unexpected error during checkpoint initialization:", errorMsg);
+        });
+    }
     async initializeMCP() {
         // Initialize MCP in the background without blocking
         Promise.resolve().then(async () => {
@@ -148,8 +194,7 @@ export class LLMAgent extends EventEmitter {
             // Clean up old entries (keep only last N unique calls)
             if (this.recentToolCalls.size > AGENT_CONFIG.MAX_RECENT_TOOL_CALLS) {
                 const firstKey = this.recentToolCalls.keys().next().value;
-                // Map.keys().next().value is guaranteed to exist when size > 0, but TypeScript doesn't know this
-                if (firstKey) {
+                if (firstKey !== undefined) {
                     this.recentToolCalls.delete(firstKey);
                 }
             }
@@ -201,6 +246,345 @@ export class LLMAgent extends EventEmitter {
             return true;
         return false;
     }
+    // ============================================================================
+    // Multi-Phase Planning Integration
+    // ============================================================================
+    /**
+     * Check if a request should trigger multi-phase planning
+     */
+    shouldCreatePlan(message) {
+        if (!this.planningEnabled)
+            return false;
+        return isComplexRequest(message);
+    }
+    /**
+     * Get the current plan if any
+     */
+    getCurrentPlan() {
+        return this.currentPlan;
+    }
+    /**
+     * Execute a single phase using the LLM
+     */
+    async executePhase(phase, context) {
+        const startTime = Date.now();
+        const startTokens = this.tokenCounter.countMessageTokens(this.messages);
+        const filesModified = [];
+        let lastAssistantContent = "";
+        // Emit phase started event
+        this.emit("phase:started", { phase, planId: context.planId });
+        try {
+            // Build phase-specific prompt
+            const phasePrompt = this.buildPhasePrompt(phase, context);
+            // Execute through normal message processing (without recursively planning)
+            const savedPlanningState = this.planningEnabled;
+            this.planningEnabled = false; // Temporarily disable planning for phase execution
+            // Add phase context to messages
+            this.messages.push({
+                role: "user",
+                content: phasePrompt,
+            });
+            // Execute using the standard tool loop
+            const tools = await getAllGrokTools();
+            let toolRounds = 0;
+            const maxPhaseRounds = Math.min(this.maxToolRounds, 50); // Limit per phase
+            while (toolRounds < maxPhaseRounds) {
+                const response = await this.llmClient.chat(this.messages, tools);
+                const assistantMessage = response.choices[0]?.message;
+                if (!assistantMessage)
+                    break;
+                // Capture the assistant's content for phase output
+                if (assistantMessage.content) {
+                    lastAssistantContent = assistantMessage.content;
+                }
+                // Add to messages
+                this.messages.push({
+                    role: "assistant",
+                    content: assistantMessage.content || "",
+                    tool_calls: assistantMessage.tool_calls,
+                });
+                // Check for tool calls
+                if (!assistantMessage.tool_calls || assistantMessage.tool_calls.length === 0) {
+                    break; // No more tool calls, phase complete
+                }
+                toolRounds++;
+                // Execute tools and track file modifications
+                for (const toolCall of assistantMessage.tool_calls) {
+                    const result = await this.executeTool(toolCall);
+                    // Track file modifications from text_editor tool
+                    if (toolCall.function.name === "text_editor" ||
+                        toolCall.function.name === "str_replace_editor") {
+                        try {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            if (args.path && result.success) {
+                                if (!filesModified.includes(args.path)) {
+                                    filesModified.push(args.path);
+                                }
+                            }
+                        }
+                        catch {
+                            // Ignore parse errors
+                        }
+                    }
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: toolCall.id,
+                        content: result.output || result.error || "No output",
+                    });
+                }
+            }
+            // Restore planning state
+            this.planningEnabled = savedPlanningState;
+            // Prune context if configured
+            if (PLANNER_CONFIG.PRUNE_AFTER_PHASE) {
+                if (this.contextManager.shouldPrune(this.messages, this.tokenCounter)) {
+                    this.messages = this.contextManager.pruneMessages(this.messages, this.tokenCounter);
+                }
+            }
+            const endTokens = this.tokenCounter.countMessageTokens(this.messages);
+            const duration = Date.now() - startTime;
+            // Build meaningful output
+            const output = lastAssistantContent ||
+                `Phase "${phase.name}" completed (${toolRounds} tool rounds, ${filesModified.length} files modified)`;
+            // Emit phase completed event
+            this.emit("phase:completed", {
+                phase,
+                planId: context.planId,
+                result: { success: true, output, filesModified }
+            });
+            return {
+                phaseId: phase.id,
+                success: true,
+                output,
+                duration,
+                tokensUsed: endTokens - startTokens,
+                filesModified,
+                wasRetry: false,
+                retryAttempt: 0,
+            };
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = extractErrorMessage(error);
+            // Emit phase failed event
+            this.emit("phase:failed", {
+                phase,
+                planId: context.planId,
+                error: errorMessage
+            });
+            return {
+                phaseId: phase.id,
+                success: false,
+                error: errorMessage,
+                duration,
+                tokensUsed: 0,
+                filesModified,
+                wasRetry: false,
+                retryAttempt: 0,
+            };
+        }
+    }
+    /**
+     * Build a prompt for phase execution
+     */
+    buildPhasePrompt(phase, context) {
+        let prompt = `## Phase ${phase.index + 1}: ${phase.name}\n\n`;
+        prompt += `**Objective:** ${phase.description}\n\n`;
+        if (phase.objectives.length > 0) {
+            prompt += "**Tasks to complete:**\n";
+            for (const obj of phase.objectives) {
+                prompt += `- ${obj}\n`;
+            }
+            prompt += "\n";
+        }
+        if (context.completedPhases.length > 0) {
+            prompt += `**Previously completed phases:** ${context.completedPhases.join(", ")}\n\n`;
+        }
+        prompt += `**Original request:** ${context.originalRequest}\n\n`;
+        prompt += "Please complete this phase. Focus only on the objectives listed above.";
+        return prompt;
+    }
+    /**
+     * Generate and execute a plan for a complex request
+     */
+    async *processWithPlanning(message) {
+        // Add user message to history
+        const userEntry = {
+            type: "user",
+            content: message,
+            timestamp: new Date(),
+        };
+        this.chatHistory.push(userEntry);
+        this.messages.push({ role: "user", content: message });
+        // Generate plan
+        yield {
+            type: "content",
+            content: "📋 **Analyzing request and creating execution plan...**\n\n",
+        };
+        try {
+            // Generate plan using LLM
+            const plan = await this.taskPlanner.generatePlan(message, async (systemPrompt, userPrompt) => {
+                const planMessages = [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: userPrompt },
+                ];
+                const response = await this.llmClient.chat(planMessages, []);
+                return response.choices[0]?.message?.content || "";
+            }, {
+                projectType: "typescript", // Could be detected
+            });
+            if (!plan) {
+                yield {
+                    type: "content",
+                    content: "Could not generate a plan. Processing as single request...\n\n",
+                };
+                // Fall back to normal processing - disable planning and retry
+                this.planningEnabled = false;
+                yield* this.processUserMessageStreamInternal(message);
+                this.planningEnabled = true;
+                return;
+            }
+            this.currentPlan = plan;
+            // Emit plan created event
+            this.emit("plan:created", { plan });
+            // Display plan summary
+            yield {
+                type: "content",
+                content: this.formatPlanSummary(plan),
+            };
+            // Execute phases one by one with progress updates
+            const phaseResults = [];
+            let totalTokensUsed = 0;
+            const planStartTime = Date.now();
+            for (let i = 0; i < plan.phases.length; i++) {
+                const phase = plan.phases[i];
+                plan.currentPhaseIndex = i;
+                // Show phase starting
+                yield {
+                    type: "content",
+                    content: `\n**⏳ Phase ${i + 1}/${plan.phases.length}: ${phase.name}**\n`,
+                };
+                // Execute the phase
+                const context = {
+                    planId: plan.id,
+                    originalRequest: message,
+                    completedPhases: phaseResults.filter(r => r.success).map(r => r.phaseId),
+                };
+                const result = await this.executePhase(phase, context);
+                phaseResults.push(result);
+                totalTokensUsed += result.tokensUsed;
+                // Report phase result
+                if (result.success) {
+                    yield {
+                        type: "content",
+                        content: `✓ Phase ${i + 1} completed (${Math.ceil(result.duration / 1000)}s)\n`,
+                    };
+                    if (result.filesModified.length > 0) {
+                        yield {
+                            type: "content",
+                            content: `  Files modified: ${result.filesModified.join(", ")}\n`,
+                        };
+                    }
+                }
+                else {
+                    yield {
+                        type: "content",
+                        content: `✕ Phase ${i + 1} failed: ${result.error}\n`,
+                    };
+                    // Continue with next phase unless abort strategy
+                    if (phase.fallbackStrategy === "abort") {
+                        yield {
+                            type: "content",
+                            content: `\n⚠️ Plan aborted due to phase failure.\n`,
+                        };
+                        break;
+                    }
+                }
+            }
+            const totalDuration = Date.now() - planStartTime;
+            // Build final result
+            const successfulPhases = phaseResults.filter(r => r.success);
+            const failedPhases = phaseResults.filter(r => !r.success);
+            const allFilesModified = [...new Set(phaseResults.flatMap(r => r.filesModified))];
+            const summary = successfulPhases.length === phaseResults.length
+                ? `All ${phaseResults.length} phases completed successfully. ${allFilesModified.length} files modified.`
+                : `${successfulPhases.length}/${phaseResults.length} phases completed. ${failedPhases.length} failed.`;
+            const warnings = [];
+            for (const result of failedPhases) {
+                warnings.push(`Phase ${result.phaseId} failed: ${result.error || "Unknown error"}`);
+            }
+            const planResult = {
+                planId: plan.id,
+                success: phaseResults.every(r => r.success),
+                phaseResults,
+                totalDuration,
+                totalTokensUsed,
+                summary,
+                warnings,
+            };
+            // Report final results
+            yield {
+                type: "content",
+                content: this.formatPlanResult(planResult),
+            };
+            // Emit plan completed event
+            this.emit("plan:completed", { plan, result: planResult });
+            this.currentPlan = null;
+        }
+        catch (error) {
+            yield {
+                type: "content",
+                content: `\n⚠️ Plan execution error: ${extractErrorMessage(error)}\n`,
+            };
+            this.emit("plan:failed", { error: extractErrorMessage(error) });
+            this.currentPlan = null;
+        }
+    }
+    /**
+     * Internal streaming processor (used when planning falls back)
+     */
+    async *processUserMessageStreamInternal(_message) {
+        // Simplified fallback - just yield a message
+        yield {
+            type: "content",
+            content: "Processing request without planning...\n",
+        };
+    }
+    /**
+     * Format plan summary for display
+     */
+    formatPlanSummary(plan) {
+        let output = `**📋 Execution Plan Created**\n\n`;
+        output += `**Request:** ${plan.originalPrompt.slice(0, 100)}${plan.originalPrompt.length > 100 ? "..." : ""}\n\n`;
+        output += `**Phases (${plan.phases.length}):**\n`;
+        for (const phase of plan.phases) {
+            const riskIcon = phase.riskLevel === "high" ? "⚠️" : phase.riskLevel === "medium" ? "△" : "";
+            output += `  ${phase.index + 1}. ${phase.name} ${riskIcon}\n`;
+        }
+        output += `\n**Estimated Duration:** ~${Math.ceil(plan.estimatedDuration / 60000)} min\n\n`;
+        output += "---\n\n";
+        return output;
+    }
+    /**
+     * Format plan result for display
+     */
+    formatPlanResult(result) {
+        let output = "\n---\n\n**📋 Plan Execution Complete**\n\n";
+        const successful = result.phaseResults.filter((r) => r.success).length;
+        const failed = result.phaseResults.filter((r) => !r.success).length;
+        output += `**Results:** ${successful}/${result.phaseResults.length} phases successful`;
+        if (failed > 0) {
+            output += ` (${failed} failed)`;
+        }
+        output += "\n";
+        if (result.totalDuration) {
+            output += `**Duration:** ${Math.ceil(result.totalDuration / 1000)}s\n`;
+        }
+        if (result.totalTokensUsed) {
+            output += `**Tokens Used:** ${result.totalTokensUsed.toLocaleString()}\n`;
+        }
+        return output;
+    }
     async processUserMessage(message) {
         // Reset tool call tracking for new message
         this.resetToolCallTracking();
@@ -310,6 +694,11 @@ export class LLMAgent extends EventEmitter {
                             tool_call_id: toolCall.id,
                         });
                     }
+                    // Apply context pruning after adding tool results to prevent overflow
+                    // Tool results can be very large (file reads, grep output, etc.)
+                    if (this.contextManager.shouldPrune(this.messages, this.tokenCounter)) {
+                        this.messages = this.contextManager.pruneMessages(this.messages, this.tokenCounter);
+                    }
                     // Get next response - this might contain more tool calls
                     currentResponse = await this.llmClient.chat(this.messages, tools, {
                         searchOptions: this.isGrokModel() && this.shouldUseSearchFor(message)
@@ -581,6 +970,11 @@ export class LLMAgent extends EventEmitter {
             content: accumulatedMessage.content || "",
             tool_calls: accumulatedMessage.tool_calls,
         });
+        // Apply context pruning after adding message to prevent overflow
+        // Critical for long assistant responses and tool results
+        if (this.contextManager.shouldPrune(this.messages, this.tokenCounter)) {
+            this.messages = this.contextManager.pruneMessages(this.messages, this.tokenCounter);
+        }
     }
     /**
      * Execute tool calls and yield results
@@ -625,6 +1019,11 @@ export class LLMAgent extends EventEmitter {
                 tool_call_id: toolCall.id,
             });
         }
+        // Apply context pruning after adding tool results to prevent overflow
+        // Tool results can be very large (file reads, grep output, etc.)
+        if (this.contextManager.shouldPrune(this.messages, this.tokenCounter)) {
+            this.messages = this.contextManager.pruneMessages(this.messages, this.tokenCounter);
+        }
         // Update token count after processing all tool calls
         inputTokens.value = this.tokenCounter.countMessageTokens(this.messages);
         yield {
@@ -635,6 +1034,13 @@ export class LLMAgent extends EventEmitter {
     async *processUserMessageStream(message) {
         // Create new abort controller for this request
         this.abortController = new AbortController();
+        // Check if this is a complex request that should use multi-phase planning
+        if (this.shouldCreatePlan(message)) {
+            // Delegate to planning processor
+            yield* this.processWithPlanning(message);
+            yield { type: "done" };
+            return;
+        }
         // Reset tool call tracking for new message
         this.resetToolCallTracking();
         // Prepare user message and get input tokens
@@ -814,7 +1220,12 @@ export class LLMAgent extends EventEmitter {
                 case "str_replace_editor":
                     return await this.textEditor.strReplace(args.path, args.old_str, args.new_str, args.replace_all);
                 case "bash":
-                    return await this.bash.execute(args.command);
+                    return await this.bash.execute(args.command, {
+                        background: args.background,
+                        timeout: args.timeout,
+                    });
+                case "bash_output":
+                    return await this.bashOutput.execute(args.task_id, args.wait, args.timeout);
                 case "create_todo_list":
                     return await this.todoTool.createTodoList(args.todos);
                 case "update_todo_list":
@@ -911,6 +1322,19 @@ export class LLMAgent extends EventEmitter {
     async executeBashCommand(command) {
         return await this.bash.execute(command);
     }
+    /**
+     * Check if a bash command is currently executing
+     */
+    isBashExecuting() {
+        return this.bash.isExecuting();
+    }
+    /**
+     * Move currently running bash command to background
+     * Returns task ID if successful, null otherwise
+     */
+    moveBashToBackground() {
+        return this.bash.moveToBackground();
+    }
     getCurrentModel() {
         return this.llmClient.getCurrentModel();
     }
@@ -933,6 +1357,200 @@ export class LLMAgent extends EventEmitter {
         const stats = this.contextManager.getStats(this.messages, this.tokenCounter);
         return Math.round(stats.percentage * 100) / 100;
     }
+    /**
+     * Create a checkpoint of current state
+     */
+    async createCheckpoint(description) {
+        const files = [];
+        // For now, we don't capture file state automatically
+        // This can be enhanced to capture modified files from tool calls
+        const checkpoint = await this.checkpointManager.createCheckpoint({
+            files,
+            conversationState: this.chatHistory,
+            description: description || 'Manual checkpoint',
+            metadata: {
+                model: this.llmClient.getCurrentModel(),
+                triggeredBy: 'user',
+            },
+        });
+        return checkpoint.id;
+    }
+    /**
+     * Rewind conversation to a checkpoint
+     */
+    async rewindConversation(checkpointId) {
+        try {
+            const conversationState = await this.checkpointManager.getConversationState(checkpointId);
+            if (!conversationState) {
+                return {
+                    success: false,
+                    error: `Checkpoint ${checkpointId} not found`,
+                };
+            }
+            // Restore conversation state
+            this.chatHistory = [...conversationState];
+            // Rebuild messages array from chat history
+            this.messages = [this.messages[0]]; // Keep system message
+            for (const entry of conversationState) {
+                if (entry.type === 'user') {
+                    this.messages.push({
+                        role: 'user',
+                        content: entry.content,
+                    });
+                }
+                else if (entry.type === 'assistant') {
+                    this.messages.push({
+                        role: 'assistant',
+                        content: entry.content,
+                        tool_calls: entry.toolCalls,
+                    });
+                }
+                else if (entry.type === 'tool_result' && entry.toolCall) {
+                    this.messages.push({
+                        role: 'tool',
+                        content: entry.content,
+                        tool_call_id: entry.toolCall.id,
+                    });
+                }
+            }
+            this.emit('system', `Conversation rewound to checkpoint ${checkpointId}`);
+            return { success: true };
+        }
+        catch (error) {
+            const errorMsg = extractErrorMessage(error);
+            return {
+                success: false,
+                error: `Failed to rewind: ${errorMsg}`,
+            };
+        }
+    }
+    /**
+     * Get checkpoint manager instance
+     */
+    getCheckpointManager() {
+        return this.checkpointManager;
+    }
+    /**
+     * Get subagent orchestrator instance
+     */
+    getSubagentOrchestrator() {
+        return this.subagentOrchestrator;
+    }
+    /**
+     * Spawn a specialized subagent for a specific task
+     * This is a user-facing method that simplifies subagent usage
+     *
+     * @param role - The role/specialization of the subagent
+     * @param description - Task description
+     * @param context - Optional additional context
+     * @returns The result of the subagent execution
+     */
+    async spawnSubagent(role, description, context) {
+        try {
+            // Import SubagentRole from subagent-types
+            const { SubagentRole } = await import('./subagent-types.js');
+            // Convert string role to SubagentRole enum
+            const roleMap = {
+                'testing': SubagentRole.TESTING,
+                'documentation': SubagentRole.DOCUMENTATION,
+                'refactoring': SubagentRole.REFACTORING,
+                'analysis': SubagentRole.ANALYSIS,
+                'debug': SubagentRole.DEBUG,
+                'performance': SubagentRole.PERFORMANCE,
+                'general': SubagentRole.GENERAL,
+            };
+            const subagentRole = roleMap[role.toLowerCase()] || SubagentRole.GENERAL;
+            // Spawn the subagent
+            const subagent = await this.subagentOrchestrator.spawnSubagent(subagentRole);
+            // Execute the task
+            const result = await subagent.executeTask({
+                id: `task-${Date.now()}`,
+                description,
+                role: subagentRole,
+                priority: 1,
+                context: {
+                    files: context?.files || [],
+                    conversationHistory: this.chatHistory.slice(-10), // Last 10 messages
+                    metadata: {
+                        workingDirectory: process.cwd(),
+                        additionalContext: context?.additionalContext,
+                    },
+                },
+            });
+            return {
+                success: result.success,
+                output: result.output,
+                filesModified: result.filesModified,
+                filesCreated: result.filesCreated,
+                error: result.error,
+            };
+        }
+        catch (error) {
+            const errorMsg = extractErrorMessage(error);
+            return {
+                success: false,
+                output: '',
+                error: `Failed to spawn subagent: ${errorMsg}`,
+            };
+        }
+    }
+    /**
+     * Execute multiple tasks in parallel using subagents
+     * This automatically handles dependency resolution and parallel execution
+     *
+     * @param tasks - Array of tasks with role and description
+     * @returns Array of results from all tasks
+     */
+    async executeParallelTasks(tasks) {
+        try {
+            // Import SubagentRole and SubagentTask
+            const { SubagentRole } = await import('./subagent-types.js');
+            const roleMap = {
+                'testing': SubagentRole.TESTING,
+                'documentation': SubagentRole.DOCUMENTATION,
+                'refactoring': SubagentRole.REFACTORING,
+                'analysis': SubagentRole.ANALYSIS,
+                'debug': SubagentRole.DEBUG,
+                'performance': SubagentRole.PERFORMANCE,
+                'general': SubagentRole.GENERAL,
+            };
+            // Convert tasks to SubagentTask format
+            const subagentTasks = tasks.map((task, index) => ({
+                id: task.id || `task-${index}-${Date.now()}`,
+                description: task.description,
+                role: roleMap[task.role.toLowerCase()] || SubagentRole.GENERAL,
+                priority: 1,
+                context: {
+                    files: [],
+                    conversationHistory: this.chatHistory.slice(-10),
+                    metadata: {
+                        workingDirectory: process.cwd(),
+                    },
+                },
+                dependencies: task.dependencies || [],
+            }));
+            // Execute all tasks in parallel with dependency resolution
+            const results = await this.subagentOrchestrator.executeParallel(subagentTasks);
+            // Convert results to simpler format
+            return results.map(result => ({
+                taskId: result.taskId,
+                success: result.success,
+                output: result.output,
+                filesModified: result.filesModified,
+                filesCreated: result.filesCreated,
+                error: result.error,
+            }));
+        }
+        catch (error) {
+            const errorMsg = extractErrorMessage(error);
+            return [{
+                    taskId: 'error',
+                    success: false,
+                    output: '',
+                    error: `Failed to execute parallel tasks: ${errorMsg}`,
+                }];
+        }
+    }
     /**
      * Dispose of resources and remove event listeners
      * Call this when the agent is no longer needed
@@ -945,6 +1563,10 @@ export class LLMAgent extends EventEmitter {
             this.abortController.abort();
             this.abortController = null;
         }
+        // Terminate all subagents
+        this.subagentOrchestrator.terminateAll().catch((error) => {
+            console.warn('Error terminating subagents:', error);
+        });
     }
 }
 //# sourceMappingURL=llm-agent.js.map