centaurus-cli 3.0.1 → 3.1.0

package/dist/services/sub-agent-manager.js

@@ -1,541 +1,499 @@
-/**
- * Sub-Agent Manager Service
- *
- * Manages the lifecycle of background sub-agents that can be spawned
- * by the main agent to handle delegated tasks.
- */
-import { randomUUID } from 'crypto';
-import { aiServiceClient } from './ai-service-client.js';
-import { apiClient } from './api-client.js';
-import { sessionQuotaManager } from './session-quota-manager.js';
-import { logError } from '../utils/logger.js';
-import { quickLog } from '../utils/conversation-logger.js';
-import { ContextManager } from '../context/context-manager.js';
-// ==================== Constants ====================
+import { randomUUID } from "crypto";
+import { aiServiceClient } from "./ai-service-client.js";
+import { apiClient } from "./api-client.js";
+import { sessionQuotaManager } from "./session-quota-manager.js";
+import { logError } from "../utils/logger.js";
+import { quickLog } from "../utils/conversation-logger.js";
+import { ContextManager } from "../context/context-manager.js";
 const MAX_CONCURRENT_SUBAGENTS = 5;
-const SUBAGENT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+const SUBAGENT_TIMEOUT_MS = 10 * 60 * 1e3;
 const MAX_TURNS_PER_SUBAGENT = 50;
-// Model selection based on complexity
-const SIMPLE_MODEL = 'gemini-3-flash-preview';
-const COMPLEX_MODEL = 'gemini-3-pro-preview';
+const SIMPLE_MODEL = "gemini-3-flash-preview";
+const COMPLEX_MODEL = "gemini-3.1-pro-preview";
 const COMPLEXITY_THRESHOLD = 5;
-// ==================== Sub-Agent System Prompt ====================
-const SUBAGENT_SYSTEM_PROMPT = `You are a sub-agent spawned by a main AI agent to complete a specific task.
-
-IMPORTANT RULES:
-1. You have full access to file system tools (read, write, edit, list, grep, find)
-2. You have access to command execution tools
-3. Focus ONLY on the task assigned to you
-4. Always provide reason_text for every tool call to explain what you're doing
-5. Call task_complete when you've finished the assigned task
-6. Be efficient - don't explore unnecessarily, stick to the task
-7. If you encounter errors, try to resolve them or report clearly what went wrong
-
-CONTEXT FROM MAIN AGENT:
-Working Directory: {WORKING_DIRECTORY}
-
-{CONTEXT}
-
-YOUR TASK:
-{PROMPT}
-
+const SUBAGENT_SYSTEM_PROMPT = `You are a sub-agent spawned by a main AI agent to complete a specific task.
+
+IMPORTANT RULES:
+1. You have full access to file system tools (read, write, edit, list, grep, find)
+2. You have access to command execution tools
+3. Focus ONLY on the task assigned to you
+4. Always provide reason_text for every tool call to explain what you're doing
+5. Call task_complete when you've finished the assigned task
+6. Be efficient - don't explore unnecessarily, stick to the task
+7. If you encounter errors, try to resolve them or report clearly what went wrong
+
+CONTEXT FROM MAIN AGENT:
+Working Directory: {WORKING_DIRECTORY}
+
+{CONTEXT}
+
+YOUR TASK:
+{PROMPT}
+
 Complete this task efficiently and call task_complete when done.`;
-// ==================== SubAgentManager Class ====================
 class SubAgentManagerClass {
-    subAgents = new Map();
-    toolRegistry;
-    onSubAgentCountChange;
-    onToolExecutionUpdate;
-    /**
-     * Initialize the manager with a tool registry
-     */
-    initialize(toolRegistry) {
-        this.toolRegistry = toolRegistry;
-        quickLog(`[${new Date().toISOString()}] [SubAgentManager] Initialized with tool registry\n`);
+  subAgents = /* @__PURE__ */ new Map();
+  toolRegistry;
+  onSubAgentCountChange;
+  onToolExecutionUpdate;
+  /**
+   * Initialize the manager with a tool registry
+   */
+  initialize(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [SubAgentManager] Initialized with tool registry
+`);
+  }
+  /**
+   * Set callback for sub-agent count changes
+   */
+  setOnSubAgentCountChange(callback) {
+    this.onSubAgentCountChange = callback;
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [SubAgentManager] setOnSubAgentCountChange callback registered
+`);
+  }
+  /**
+   * Set callback for tool execution updates (for logging)
+   */
+  setOnToolExecutionUpdate(callback) {
+    this.onToolExecutionUpdate = callback;
+  }
+  /**
+   * Notify listeners about sub-agent count change
+   */
+  notifyCountChange() {
+    const runningAgents = this.getRunningSubAgents();
+    const runningCount = runningAgents.length;
+    const details = runningAgents.map((a) => `${a.id}:${a.status}`).join(", ");
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [SubAgentManager] notifyCountChange called, runningCount=${runningCount}, agents=[${details}]
+`);
+    if (this.onSubAgentCountChange) {
+      this.onSubAgentCountChange(runningCount);
     }
-    /**
-     * Set callback for sub-agent count changes
-     */
-    setOnSubAgentCountChange(callback) {
-        this.onSubAgentCountChange = callback;
-        quickLog(`[${new Date().toISOString()}] [SubAgentManager] setOnSubAgentCountChange callback registered\n`);
+  }
+  /**
+   * Select model based on complexity
+   */
+  selectModel(complexity) {
+    return complexity <= COMPLEXITY_THRESHOLD ? SIMPLE_MODEL : COMPLEX_MODEL;
+  }
+  /**
+   * Generate system prompt for sub-agent
+   */
+  generateSystemPrompt(config) {
+    return SUBAGENT_SYSTEM_PROMPT.replace("{WORKING_DIRECTORY}", config.workingDirectory).replace("{CONTEXT}", config.context || "No additional context provided.").replace("{PROMPT}", config.prompt);
+  }
+  /**
+   * Spawn a new sub-agent
+   */
+  async spawnSubAgent(config) {
+    if (this.getRunningSubAgents().length >= MAX_CONCURRENT_SUBAGENTS) {
+      return {
+        success: false,
+        error: `Maximum ${MAX_CONCURRENT_SUBAGENTS} concurrent sub-agents allowed. Wait for existing sub-agents to complete.`
+      };
     }
-    /**
-     * Set callback for tool execution updates (for logging)
-     */
-    setOnToolExecutionUpdate(callback) {
-        this.onToolExecutionUpdate = callback;
+    if (!this.toolRegistry) {
+      return {
+        success: false,
+        error: "SubAgentManager not initialized. Tool registry is missing."
+      };
     }
-    /**
-     * Notify listeners about sub-agent count change
-     */
-    notifyCountChange() {
-        const runningAgents = this.getRunningSubAgents();
-        const runningCount = runningAgents.length;
-        const details = runningAgents.map(a => `${a.id}:${a.status}`).join(', ');
-        quickLog(`[${new Date().toISOString()}] [SubAgentManager] notifyCountChange called, runningCount=${runningCount}, agents=[${details}]\n`);
-        if (this.onSubAgentCountChange) {
-            this.onSubAgentCountChange(runningCount);
-            // quickLog(`Callback invoked`) // Removed redundant log or kept if preferred
-        }
+    if (!apiClient.isAuthenticated()) {
+      return {
+        success: false,
+        error: "Authentication required for sub-agents."
+      };
     }
-    /**
-     * Select model based on complexity
-     */
-    selectModel(complexity) {
-        return complexity <= COMPLEXITY_THRESHOLD ? SIMPLE_MODEL : COMPLEX_MODEL;
+    if (!sessionQuotaManager.canSendMessage()) {
+      return {
+        success: false,
+        error: "Session quota exhausted. Cannot spawn sub-agent."
+      };
     }
-    /**
-     * Generate system prompt for sub-agent
-     */
-    generateSystemPrompt(config) {
-        return SUBAGENT_SYSTEM_PROMPT
-            .replace('{WORKING_DIRECTORY}', config.workingDirectory)
-            .replace('{CONTEXT}', config.context || 'No additional context provided.')
-            .replace('{PROMPT}', config.prompt);
+    const agentId = `subagent-${randomUUID().substring(0, 8)}`;
+    const model = this.selectModel(config.complexity);
+    const subAgent = {
+      id: agentId,
+      status: "pending",
+      prompt: config.prompt,
+      context: config.context,
+      workingDirectory: config.workingDirectory,
+      complexity: config.complexity,
+      model,
+      startTime: /* @__PURE__ */ new Date(),
+      conversationHistory: [],
+      turnCount: 0,
+      fileOperations: [],
+      toolHistory: [],
+      isRead: false,
+      abortController: new AbortController()
+    };
+    this.subAgents.set(agentId, subAgent);
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [SubAgentManager] Sub-agent ${agentId} added to map, calling notifyCountChange\\n`);
+    this.notifyCountChange();
+    this.runSubAgentLoop(agentId, config).catch((error) => {
+      logError(`Sub-agent ${agentId} failed:`, error);
+      const agent = this.subAgents.get(agentId);
+      if (agent && agent.status === "running") {
+        agent.status = "failed";
+        agent.error = error.message || String(error);
+        agent.endTime = /* @__PURE__ */ new Date();
+        this.notifyCountChange();
+      }
+    });
+    return { success: true, agentId };
+  }
+  /**
+   * Run the sub-agent's agent loop
+   */
+  async runSubAgentLoop(agentId, config) {
+    const subAgent = this.subAgents.get(agentId);
+    if (!subAgent) {
+      throw new Error(`Sub-agent ${agentId} not found`);
     }
-    /**
-     * Spawn a new sub-agent
-     */
-    async spawnSubAgent(config) {
-        // Check concurrent limit
-        if (this.getRunningSubAgents().length >= MAX_CONCURRENT_SUBAGENTS) {
-            return {
-                success: false,
-                error: `Maximum ${MAX_CONCURRENT_SUBAGENTS} concurrent sub-agents allowed. Wait for existing sub-agents to complete.`
-            };
-        }
-        // Check if tool registry is initialized
-        if (!this.toolRegistry) {
-            return {
-                success: false,
-                error: 'SubAgentManager not initialized. Tool registry is missing.'
-            };
-        }
-        // Check authentication
-        if (!apiClient.isAuthenticated()) {
-            return {
-                success: false,
-                error: 'Authentication required for sub-agents.'
-            };
+    subAgent.status = "running";
+    this.notifyCountChange();
+    const timeoutId = setTimeout(() => {
+      const agent = this.subAgents.get(agentId);
+      if (agent && agent.status === "running") {
+        agent.status = "failed";
+        agent.error = "Sub-agent timed out after 10 minutes";
+        agent.endTime = /* @__PURE__ */ new Date();
+        agent.abortController?.abort();
+        this.notifyCountChange();
+      }
+    }, SUBAGENT_TIMEOUT_MS);
+    try {
+      const systemPrompt = this.generateSystemPrompt(config);
+      subAgent.conversationHistory.push({
+        role: "user",
+        content: systemPrompt
+      });
+      const tools = this.toolRegistry.getSchemas();
+      const effectiveContextManager = config.parentContextManager || new ContextManager(config.workingDirectory, process.platform);
+      const context = {
+        cwd: config.workingDirectory,
+        contextManager: effectiveContextManager,
+        requireApproval: async () => true,
+        // Auto-approve for sub-agents (autonomous)
+        onStreamingOutput: () => {
         }
-        // Check session quota
+        // No streaming output for sub-agents (yet)
+      };
+      const currentCtx = effectiveContextManager.getCurrentContext();
+      const isRemote = currentCtx && currentCtx.type !== "local";
+      let envOs;
+      let envShell;
+      let envHomeDir;
+      let envPlatform;
+      if (isRemote && currentCtx.metadata) {
+        const remoteOs = currentCtx.metadata.os;
+        envOs = remoteOs || "linux";
+        envPlatform = envOs === "windows" ? "win32" : "linux";
+        envShell = currentCtx.metadata.shell || "bash";
+        envHomeDir = currentCtx.metadata.homeDirectory || `/home/${currentCtx.metadata.username || "user"}`;
+      } else {
+        envOs = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux";
+        envPlatform = process.platform;
+        envShell = process.env.SHELL || "cmd.exe";
+        envHomeDir = process.env.USERPROFILE || process.env.HOME || "";
+      }
+      while (subAgent.turnCount < MAX_TURNS_PER_SUBAGENT && subAgent.status === "running") {
+        subAgent.turnCount++;
+        sessionQuotaManager.incrementMessageCount();
         if (!sessionQuotaManager.canSendMessage()) {
-            return {
-                success: false,
-                error: 'Session quota exhausted. Cannot spawn sub-agent.'
-            };
+          subAgent.status = "failed";
+          subAgent.error = "Session quota exhausted during sub-agent execution";
+          break;
         }
-        // Create sub-agent
-        const agentId = `subagent-${randomUUID().substring(0, 8)}`;
-        const model = this.selectModel(config.complexity);
-        const subAgent = {
-            id: agentId,
-            status: 'pending',
-            prompt: config.prompt,
-            context: config.context,
-            workingDirectory: config.workingDirectory,
-            complexity: config.complexity,
-            model,
-            startTime: new Date(),
-            conversationHistory: [],
-            turnCount: 0,
-            fileOperations: [],
-            toolHistory: [],
-            isRead: false,
-            abortController: new AbortController(),
-        };
-        this.subAgents.set(agentId, subAgent);
-        quickLog(`[${new Date().toISOString()}] [SubAgentManager] Sub-agent ${agentId} added to map, calling notifyCountChange\\n`);
-        this.notifyCountChange();
-        // Start the sub-agent loop in background (don't await)
-        this.runSubAgentLoop(agentId, config).catch(error => {
-            logError(`Sub-agent ${agentId} failed:`, error);
-            const agent = this.subAgents.get(agentId);
-            if (agent && agent.status === 'running') {
-                agent.status = 'failed';
-                agent.error = error.message || String(error);
-                agent.endTime = new Date();
-                this.notifyCountChange();
-            }
-        });
-        return { success: true, agentId };
-    }
-    /**
-     * Run the sub-agent's agent loop
-     */
-    async runSubAgentLoop(agentId, config) {
-        const subAgent = this.subAgents.get(agentId);
-        if (!subAgent) {
-            throw new Error(`Sub-agent ${agentId} not found`);
-        }
-        subAgent.status = 'running';
-        this.notifyCountChange();
-        // Set up timeout
-        const timeoutId = setTimeout(() => {
-            const agent = this.subAgents.get(agentId);
-            if (agent && agent.status === 'running') {
-                agent.status = 'failed';
-                agent.error = 'Sub-agent timed out after 10 minutes';
-                agent.endTime = new Date();
-                agent.abortController?.abort();
-                this.notifyCountChange();
-            }
-        }, SUBAGENT_TIMEOUT_MS);
+        let assistantMessage = "";
+        let toolCalls = [];
         try {
-            // Initialize conversation with system prompt (as user message since backend injects system)
-            const systemPrompt = this.generateSystemPrompt(config);
-            subAgent.conversationHistory.push({
-                role: 'user',
-                content: systemPrompt,
-            });
-            const tools = this.toolRegistry.getSchemas();
-            // Build execution context
-            // Use parent's ContextManager if available (for remote sessions like SSH/Docker/WSL),
-            // otherwise create a new local one
-            const effectiveContextManager = config.parentContextManager || new ContextManager(config.workingDirectory, process.platform);
-            const context = {
-                cwd: config.workingDirectory,
-                contextManager: effectiveContextManager,
-                requireApproval: async () => true, // Auto-approve for sub-agents (autonomous)
-                onStreamingOutput: () => { }, // No streaming output for sub-agents (yet)
-            };
-            // Detect environment from the effective context manager's current state
-            // This ensures the AI model knows the correct OS/shell when in a remote session
-            const currentCtx = effectiveContextManager.getCurrentContext();
-            const isRemote = currentCtx && currentCtx.type !== 'local';
-            let envOs;
-            let envShell;
-            let envHomeDir;
-            let envPlatform;
-            if (isRemote && currentCtx.metadata) {
-                // Use remote session's OS/shell info
-                const remoteOs = currentCtx.metadata.os;
-                envOs = remoteOs || 'linux'; // Most remote sessions are Linux
-                envPlatform = envOs === 'windows' ? 'win32' : 'linux';
-                envShell = currentCtx.metadata.shell || 'bash';
-                envHomeDir = currentCtx.metadata.homeDirectory || `/home/${currentCtx.metadata.username || 'user'}`;
+          for await (const chunk of aiServiceClient.streamChat(
+            subAgent.model,
+            subAgent.conversationHistory,
+            tools,
+            { cwd: config.workingDirectory, platform: envPlatform, shell: envShell, os: envOs, homeDir: envHomeDir },
+            void 0,
+            void 0,
+            subAgent.abortController?.signal
+          )) {
+            if (chunk.type === "error") {
+              throw new Error(chunk.message);
             }
-            else {
-                // Local environment
-                envOs = process.platform === 'win32' ? 'windows' : process.platform === 'darwin' ? 'macos' : 'linux';
-                envPlatform = process.platform;
-                envShell = process.env.SHELL || 'cmd.exe';
-                envHomeDir = process.env.USERPROFILE || process.env.HOME || '';
+            if (chunk.type === "text") {
+              assistantMessage += chunk.content;
             }
-            // Agent loop
-            while (subAgent.turnCount < MAX_TURNS_PER_SUBAGENT && subAgent.status === 'running') {
-                subAgent.turnCount++;
-                // Check quota
-                sessionQuotaManager.incrementMessageCount();
-                if (!sessionQuotaManager.canSendMessage()) {
-                    subAgent.status = 'failed';
-                    subAgent.error = 'Session quota exhausted during sub-agent execution';
-                    break;
-                }
-                let assistantMessage = '';
-                let toolCalls = [];
-                // Stream AI response
+            if (chunk.type === "tool_call") {
+              const toolCall = chunk.toolCall;
+              if (toolCall.arguments && typeof toolCall.arguments === "string") {
                 try {
-                    for await (const chunk of aiServiceClient.streamChat(subAgent.model, subAgent.conversationHistory, tools, { cwd: config.workingDirectory, platform: envPlatform, shell: envShell, os: envOs, homeDir: envHomeDir }, undefined, undefined, subAgent.abortController?.signal)) {
-                        if (chunk.type === 'error') {
-                            throw new Error(chunk.message);
-                        }
-                        if (chunk.type === 'text') {
-                            assistantMessage += chunk.content;
-                        }
-                        if (chunk.type === 'tool_call') {
-                            const toolCall = chunk.toolCall;
-                            // Parse string arguments if needed
-                            if (toolCall.arguments && typeof toolCall.arguments === 'string') {
-                                try {
-                                    toolCall.arguments = JSON.parse(toolCall.arguments);
-                                }
-                                catch (e) {
-                                    // Ignore parsing error
-                                }
-                            }
-                            toolCalls.push(toolCall);
-                        }
-                        if (chunk.type === 'done') {
-                            break;
-                        }
-                    }
-                }
-                catch (error) {
-                    if (error.name === 'AbortError') {
-                        // Sub-agent was terminated
-                        subAgent.status = 'terminated';
-                        subAgent.endTime = new Date();
-                        break;
-                    }
-                    throw error;
-                }
-                // Add assistant message to history
-                if (toolCalls.length > 0 || assistantMessage) {
-                    const assistantMsg = {
-                        role: 'assistant',
-                        content: assistantMessage,
-                    };
-                    if (toolCalls.length > 0) {
-                        assistantMsg.tool_calls = toolCalls;
-                    }
-                    subAgent.conversationHistory.push(assistantMsg);
-                }
-                // Execute tool calls
-                if (toolCalls.length === 0) {
-                    // No tool calls and no task_complete - something went wrong
-                    subAgent.status = 'completed';
-                    subAgent.result = assistantMessage || 'Sub-agent completed without explicit task_complete';
-                    subAgent.endTime = new Date();
-                    break;
-                }
-                for (const toolCall of toolCalls) {
-                    // Check for task_complete
-                    if (toolCall.name === 'task_complete') {
-                        subAgent.status = 'completed';
-                        subAgent.result = assistantMessage || 'Task completed successfully';
-                        subAgent.endTime = new Date();
-                        break;
-                    }
-                    // Track the tool execution
-                    const reasonText = toolCall.arguments?.reason_text;
-                    const toolExecution = {
-                        toolName: toolCall.name,
-                        arguments: toolCall.arguments,
-                        reasonText,
-                        result: '',
-                        success: false,
-                        timestamp: new Date(),
-                    };
-                    try {
-                        quickLog(`[SubAgent ${subAgent.id}] Executing tool: ${toolCall.name}`);
-                        // Execute the tool
-                        const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
-                        quickLog(`[SubAgent ${subAgent.id}] Tool ${toolCall.name} execution result: ${JSON.stringify(result)}`);
-                        toolExecution.success = result.success;
-                        toolExecution.result = result.result;
-                        // Track file operations
-                        this.trackFileOperation(subAgent, toolCall, result);
-                        // Add tool result to history
-                        subAgent.conversationHistory.push({
-                            role: 'tool',
-                            tool_call_id: toolCall.id,
-                            content: result.success ? result.result : `Error: ${result.error}`,
-                        });
-                    }
-                    catch (error) {
-                        toolExecution.success = false;
-                        toolExecution.result = `Error: ${error.message}`;
-                        subAgent.conversationHistory.push({
-                            role: 'tool',
-                            tool_call_id: toolCall.id,
-                            content: `Error: ${error.message}`,
-                        });
-                    }
-                    subAgent.toolHistory.push(toolExecution);
-                }
-                // Check if task was completed
-                if (subAgent.status === 'completed') {
-                    break;
+                  toolCall.arguments = JSON.parse(toolCall.arguments);
+                } catch (e) {
                 }
+              }
+              toolCalls.push(toolCall);
             }
-            // Check if we hit max turns
-            if (subAgent.turnCount >= MAX_TURNS_PER_SUBAGENT && subAgent.status === 'running') {
-                subAgent.status = 'failed';
-                subAgent.error = `Sub-agent exceeded maximum ${MAX_TURNS_PER_SUBAGENT} turns`;
-                subAgent.endTime = new Date();
+            if (chunk.type === "done") {
+              break;
             }
+          }
+        } catch (error) {
+          if (error.name === "AbortError") {
+            subAgent.status = "terminated";
+            subAgent.endTime = /* @__PURE__ */ new Date();
+            break;
+          }
+          throw error;
         }
-        finally {
-            clearTimeout(timeoutId);
-            this.notifyCountChange();
+        if (toolCalls.length > 0 || assistantMessage) {
+          const assistantMsg = {
+            role: "assistant",
+            content: assistantMessage
+          };
+          if (toolCalls.length > 0) {
+            assistantMsg.tool_calls = toolCalls;
+          }
+          subAgent.conversationHistory.push(assistantMsg);
         }
-        quickLog(`[${new Date().toISOString()}] [SubAgent] ${agentId} finished with status: ${subAgent.status}\n`);
-    }
-    /**
-     * Track file operations made by sub-agent
-     */
-    trackFileOperation(subAgent, toolCall, result) {
-        const { name, arguments: args } = toolCall;
-        if (name === 'write_to_file') {
-            subAgent.fileOperations.push({
-                type: 'create',
-                path: args.TargetFile || args.target_path || args.file_path || 'unknown_file',
-                newContent: args.content,
-                reasonText: args.reason_text,
-                timestamp: new Date(),
-            });
+        if (toolCalls.length === 0) {
+          subAgent.status = "completed";
+          subAgent.result = assistantMessage || "Sub-agent completed without explicit task_complete";
+          subAgent.endTime = /* @__PURE__ */ new Date();
+          break;
         }
-        else if (name === 'edit_file' || name === 'multi_edit_file') {
-            subAgent.fileOperations.push({
-                type: 'edit',
-                path: args.file_path || args.target_path || 'unknown_file',
-                diff: result.success ? result.result : undefined,
-                reasonText: args.reason_text,
-                timestamp: new Date(),
+        for (const toolCall of toolCalls) {
+          if (toolCall.name === "task_complete") {
+            subAgent.status = "completed";
+            subAgent.result = assistantMessage || "Task completed successfully";
+            subAgent.endTime = /* @__PURE__ */ new Date();
+            break;
+          }
+          const reasonText = toolCall.arguments?.reason_text;
+          const toolExecution = {
+            toolName: toolCall.name,
+            arguments: toolCall.arguments,
+            reasonText,
+            result: "",
+            success: false,
+            timestamp: /* @__PURE__ */ new Date()
+          };
+          try {
+            quickLog(`[SubAgent ${subAgent.id}] Executing tool: ${toolCall.name}`);
+            const result = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+            quickLog(`[SubAgent ${subAgent.id}] Tool ${toolCall.name} execution result: ${JSON.stringify(result)}`);
+            toolExecution.success = result.success;
+            toolExecution.result = result.result;
+            this.trackFileOperation(subAgent, toolCall, result);
+            subAgent.conversationHistory.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: result.success ? result.result : `Error: ${result.error}`
             });
+          } catch (error) {
+            toolExecution.success = false;
+            toolExecution.result = `Error: ${error.message}`;
+            subAgent.conversationHistory.push({
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: `Error: ${error.message}`
+            });
+          }
+          subAgent.toolHistory.push(toolExecution);
+        }
+        if (subAgent.status === "completed") {
+          break;
         }
-        // Note: We could also track delete operations if there was a delete_file tool
+      }
+      if (subAgent.turnCount >= MAX_TURNS_PER_SUBAGENT && subAgent.status === "running") {
+        subAgent.status = "failed";
+        subAgent.error = `Sub-agent exceeded maximum ${MAX_TURNS_PER_SUBAGENT} turns`;
+        subAgent.endTime = /* @__PURE__ */ new Date();
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      this.notifyCountChange();
     }
-    /**
-     * Get a sub-agent by ID
-     */
-    getSubAgent(agentId) {
-        return this.subAgents.get(agentId);
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [SubAgent] ${agentId} finished with status: ${subAgent.status}
+`);
+  }
+  /**
+   * Track file operations made by sub-agent
+   */
+  trackFileOperation(subAgent, toolCall, result) {
+    const { name, arguments: args } = toolCall;
+    if (name === "write_to_file") {
+      subAgent.fileOperations.push({
+        type: "create",
+        path: args.TargetFile || args.target_path || args.file_path || "unknown_file",
+        newContent: args.content,
+        reasonText: args.reason_text,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    } else if (name === "edit_file" || name === "multi_edit_file") {
+      subAgent.fileOperations.push({
+        type: "edit",
+        path: args.file_path || args.target_path || "unknown_file",
+        diff: result.success ? result.result : void 0,
+        reasonText: args.reason_text,
+        timestamp: /* @__PURE__ */ new Date()
+      });
     }
-    /**
-     * Get all sub-agents
-     */
-    getAllSubAgents() {
-        return Array.from(this.subAgents.values());
+  }
+  /**
+   * Get a sub-agent by ID
+   */
+  getSubAgent(agentId) {
+    return this.subAgents.get(agentId);
+  }
+  /**
+   * Get all sub-agents
+   */
+  getAllSubAgents() {
+    return Array.from(this.subAgents.values());
+  }
+  /**
+   * Get running sub-agents
+   */
+  getRunningSubAgents() {
+    return this.getAllSubAgents().filter((a) => a.status === "running" || a.status === "pending");
+  }
+  /**
+   * Get completed but unread sub-agents
+   */
+  getCompletedUnreadSubAgents() {
+    return this.getAllSubAgents().filter(
+      (a) => (a.status === "completed" || a.status === "failed" || a.status === "terminated") && !a.isRead
+    );
+  }
+  /**
+   * Terminate a sub-agent
+   */
+  terminateSubAgent(agentId) {
+    const subAgent = this.subAgents.get(agentId);
+    if (!subAgent) {
+      return { success: false, error: `Sub-agent ${agentId} not found` };
     }
-    /**
-     * Get running sub-agents
-     */
-    getRunningSubAgents() {
-        return this.getAllSubAgents().filter(a => a.status === 'running' || a.status === 'pending');
+    if (subAgent.status !== "running" && subAgent.status !== "pending") {
+      return { success: false, error: `Sub-agent ${agentId} is not running (status: ${subAgent.status})` };
     }
-    /**
-     * Get completed but unread sub-agents
-     */
-    getCompletedUnreadSubAgents() {
-        return this.getAllSubAgents().filter(a => (a.status === 'completed' || a.status === 'failed' || a.status === 'terminated') &&
-            !a.isRead);
+    subAgent.abortController?.abort();
+    subAgent.status = "terminated";
+    subAgent.endTime = /* @__PURE__ */ new Date();
+    this.notifyCountChange();
+    return { success: true };
+  }
+  /**
+   * Get formatted diff output for a sub-agent
+   */
+  getSubAgentDiff(agentId) {
+    const subAgent = this.subAgents.get(agentId);
+    if (!subAgent) {
+      return `Sub-agent ${agentId} not found`;
     }
-    /**
-     * Terminate a sub-agent
-     */
-    terminateSubAgent(agentId) {
-        const subAgent = this.subAgents.get(agentId);
-        if (!subAgent) {
-            return { success: false, error: `Sub-agent ${agentId} not found` };
-        }
-        if (subAgent.status !== 'running' && subAgent.status !== 'pending') {
-            return { success: false, error: `Sub-agent ${agentId} is not running (status: ${subAgent.status})` };
-        }
-        subAgent.abortController?.abort();
-        subAgent.status = 'terminated';
-        subAgent.endTime = new Date();
-        this.notifyCountChange();
-        return { success: true };
+    const lines = [];
+    lines.push(`## Sub-Agent Results: ${agentId}`);
+    lines.push(`**Status:** ${subAgent.status}`);
+    lines.push(`**Model:** ${subAgent.model}`);
+    lines.push(`**Duration:** ${this.formatDuration(subAgent.startTime, subAgent.endTime)}`);
+    lines.push(`**Turns:** ${subAgent.turnCount}`);
+    lines.push("");
+    if (subAgent.result) {
+      lines.push(`**Result:** ${subAgent.result}`);
+      lines.push("");
     }
-    /**
-     * Get formatted diff output for a sub-agent
-     */
-    getSubAgentDiff(agentId) {
-        const subAgent = this.subAgents.get(agentId);
-        if (!subAgent) {
-            return `Sub-agent ${agentId} not found`;
-        }
-        const lines = [];
-        lines.push(`## Sub-Agent Results: ${agentId}`);
-        lines.push(`**Status:** ${subAgent.status}`);
-        lines.push(`**Model:** ${subAgent.model}`);
-        lines.push(`**Duration:** ${this.formatDuration(subAgent.startTime, subAgent.endTime)}`);
-        lines.push(`**Turns:** ${subAgent.turnCount}`);
-        lines.push('');
-        if (subAgent.result) {
-            lines.push(`**Result:** ${subAgent.result}`);
-            lines.push('');
-        }
-        if (subAgent.error) {
-            lines.push(`**Error:** ${subAgent.error}`);
-            lines.push('');
-        }
-        // File operations
-        if (subAgent.fileOperations.length > 0) {
-            lines.push('### File Operations');
-            lines.push('');
-            for (const op of subAgent.fileOperations) {
-                const typeIcon = op.type === 'create' ? '📝' : op.type === 'edit' ? '✏️' : '🗑️';
-                lines.push(`${typeIcon} **${op.type.toUpperCase()}**: \`${op.path}\``);
-                if (op.reasonText) {
-                    lines.push(`   *Reason:* ${op.reasonText}`);
-                }
-                if (op.diff) {
-                    lines.push('```diff');
-                    lines.push(op.diff);
-                    lines.push('```');
-                }
-                else if (op.newContent && op.type === 'create') {
-                    // For new files, show a summary
-                    const lineCount = op.newContent.split('\n').length;
-                    lines.push(`   *Created file with ${lineCount} lines*`);
-                }
-                lines.push('');
-            }
+    if (subAgent.error) {
+      lines.push(`**Error:** ${subAgent.error}`);
+      lines.push("");
+    }
+    if (subAgent.fileOperations.length > 0) {
+      lines.push("### File Operations");
+      lines.push("");
+      for (const op of subAgent.fileOperations) {
+        const typeIcon = op.type === "create" ? "\u{1F4DD}" : op.type === "edit" ? "\u270F\uFE0F" : "\u{1F5D1}\uFE0F";
+        lines.push(`${typeIcon} **${op.type.toUpperCase()}**: \`${op.path}\``);
+        if (op.reasonText) {
+          lines.push(`   *Reason:* ${op.reasonText}`);
         }
-        // Tool execution history (summarized)
-        if (subAgent.toolHistory.length > 0) {
-            lines.push('### Tool Execution Summary');
-            lines.push('');
-            const toolCounts = new Map();
-            for (const exec of subAgent.toolHistory) {
-                toolCounts.set(exec.toolName, (toolCounts.get(exec.toolName) || 0) + 1);
-            }
-            for (const [tool, count] of toolCounts) {
-                lines.push(`- ${tool}: ${count} call(s)`);
-            }
-            lines.push('');
+        if (op.diff) {
+          lines.push("```diff");
+          lines.push(op.diff);
+          lines.push("```");
+        } else if (op.newContent && op.type === "create") {
+          const lineCount = op.newContent.split("\n").length;
+          lines.push(`   *Created file with ${lineCount} lines*`);
         }
-        const markdownReport = lines.join('\n');
-        // Create structured data for UI
-        const structuredData = {
-            agentId: subAgent.id,
-            status: subAgent.status,
-            model: subAgent.model,
-            duration: this.formatDuration(subAgent.startTime, subAgent.endTime),
-            turnCount: subAgent.turnCount,
-            fileOperations: subAgent.fileOperations.map(op => ({
-                type: op.type,
-                path: op.path
-            })),
-            result: subAgent.result,
-            error: subAgent.error
-        };
-        // Return JSON string containing both checkable text (for AI) and structured data (for UI)
-        // Wrapped in a format that looks like text but can be parsed as JSON if needed by UI
-        // Actually, let's just return a JSON object string. The AI can read JSON.
-        return JSON.stringify({
-            report: markdownReport,
-            data: structuredData
-        }, null, 2);
+        lines.push("");
+      }
     }
-    /**
-     * Mark sub-agent results as read
-     */
-    markSubAgentRead(agentId) {
-        const subAgent = this.subAgents.get(agentId);
-        if (subAgent) {
-            subAgent.isRead = true;
-        }
+    if (subAgent.toolHistory.length > 0) {
+      lines.push("### Tool Execution Summary");
+      lines.push("");
+      const toolCounts = /* @__PURE__ */ new Map();
+      for (const exec of subAgent.toolHistory) {
+        toolCounts.set(exec.toolName, (toolCounts.get(exec.toolName) || 0) + 1);
+      }
+      for (const [tool, count] of toolCounts) {
+        lines.push(`- ${tool}: ${count} call(s)`);
+      }
+      lines.push("");
     }
-    /**
-     * Format duration between two dates
-     */
-    formatDuration(start, end) {
-        const endTime = end || new Date();
-        const durationMs = endTime.getTime() - start.getTime();
-        const seconds = Math.floor(durationMs / 1000);
-        const minutes = Math.floor(seconds / 60);
-        if (minutes > 0) {
-            return `${minutes}m ${seconds % 60}s`;
-        }
-        return `${seconds}s`;
+    const markdownReport = lines.join("\n");
+    const structuredData = {
+      agentId: subAgent.id,
+      status: subAgent.status,
+      model: subAgent.model,
+      duration: this.formatDuration(subAgent.startTime, subAgent.endTime),
+      turnCount: subAgent.turnCount,
+      fileOperations: subAgent.fileOperations.map((op) => ({
+        type: op.type,
+        path: op.path
+      })),
+      result: subAgent.result,
+      error: subAgent.error
+    };
+    return JSON.stringify({
+      report: markdownReport,
+      data: structuredData
+    }, null, 2);
+  }
+  /**
+   * Mark sub-agent results as read
+   */
+  markSubAgentRead(agentId) {
+    const subAgent = this.subAgents.get(agentId);
+    if (subAgent) {
+      subAgent.isRead = true;
     }
-    /**
-     * Clean up old completed sub-agents (call periodically)
-     */
-    cleanup() {
-        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
-        for (const [id, agent] of this.subAgents) {
-            if (agent.endTime && agent.endTime < oneHourAgo && agent.isRead) {
-                this.subAgents.delete(id);
-            }
-        }
+  }
+  /**
+   * Format duration between two dates
+   */
+  formatDuration(start, end) {
+    const endTime = end || /* @__PURE__ */ new Date();
+    const durationMs = endTime.getTime() - start.getTime();
+    const seconds = Math.floor(durationMs / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+  }
+  /**
+   * Clean up old completed sub-agents (call periodically)
+   */
+  cleanup() {
+    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1e3);
+    for (const [id, agent] of this.subAgents) {
+      if (agent.endTime && agent.endTime < oneHourAgo && agent.isRead) {
+        this.subAgents.delete(id);
+      }
     }
+  }
 }
-// Export singleton
-export const SubAgentManager = new SubAgentManagerClass();
+const SubAgentManager = new SubAgentManagerClass();
+export {
+  SubAgentManager
+};
 //# sourceMappingURL=sub-agent-manager.js.map