@crewx/cli 0.8.3-rc.9 → 0.8.4-rc.0

package/dist/crewx.tool.js

@@ -0,0 +1,2501 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var CrewXTool_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewXTool = void 0;
+const crewx_sdk_1 = require("@sowonai/crewx-sdk");
+const common_1 = require("@nestjs/common");
+const nestjs_mcp_adapter_1 = require("@sowonai/nestjs-mcp-adapter");
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const ai_service_1 = require("./ai.service");
+const ai_provider_service_1 = require("./ai-provider.service");
+const workspace_service_1 = require("./workspace.service");
+const parallel_processing_service_1 = require("./services/parallel-processing.service");
+const task_management_service_1 = require("./services/task-management.service");
+const result_formatter_service_1 = require("./services/result-formatter.service");
+const template_service_1 = require("./services/template.service");
+const document_loader_service_1 = require("./services/document-loader.service");
+const tool_call_service_1 = require("./services/tool-call.service");
+const agent_loader_service_1 = require("./services/agent-loader.service");
+const remote_agent_service_1 = require("./services/remote-agent.service");
+const provider_bridge_service_1 = require("./services/provider-bridge.service");
+const skill_loader_service_1 = require("./services/skill-loader.service");
+const tracing_service_1 = require("./services/tracing.service");
+const version_1 = require("./version");
+const extract_text_1 = require("./utils/extract-text");
+let CrewXTool = CrewXTool_1 = class CrewXTool {
+    generateSecurityKey() {
+        return crypto.randomBytes(8).toString('hex');
+    }
+    async processAgentEnv(env, agent) {
+        if (!env || Object.keys(env).length === 0) {
+            return undefined;
+        }
+        const Handlebars = await Promise.resolve().then(() => __importStar(require('handlebars')));
+        const processedEnv = {};
+        const context = {
+            agent: {
+                id: agent.id,
+                name: agent.name || agent.id,
+                role: agent.role || '',
+                team: agent.team || '',
+                description: agent.description || '',
+                workingDirectory: agent.workingDirectory,
+                provider: Array.isArray(agent.provider) ? agent.provider[0] : agent.provider,
+                model: agent.inline?.model || '',
+            },
+            env: process.env,
+        };
+        for (const [key, value] of Object.entries(env)) {
+            try {
+                if (value.includes('{{')) {
+                    const template = Handlebars.compile(value);
+                    processedEnv[key] = template(context);
+                }
+                else {
+                    processedEnv[key] = value;
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Failed to process env template for ${key}: ${(0, crewx_sdk_1.getErrorMessage)(error)}`);
+                processedEnv[key] = value;
+            }
+        }
+        return processedEnv;
+    }
+    buildToolsContext() {
+        const tools = this.toolCallService.list();
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+        return {
+            list: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.input_schema,
+                output_schema: t.output_schema,
+            })),
+            json: JSON.stringify(tools, null, 2),
+            count: tools.length,
+        };
+    }
+    async buildStructuredPayload(params) {
+        const { agentId, provider, mode, prompt, context, messages, platform, model, platformMetadata } = params;
+        const safeMessages = Array.isArray(messages) ? messages : [];
+        let formattedHistory = '';
+        try {
+            if (safeMessages.length > 0) {
+                const template = '{{{formatConversation messages platform}}}';
+                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
+                formattedHistory = await processDocumentTemplate(template, this.documentLoaderService, {
+                    messages: safeMessages,
+                    platform: platform ?? 'cli',
+                });
+                formattedHistory = formattedHistory?.trim() ?? '';
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to format conversation history for structured payload: ${error?.message || error}`);
+        }
+        const normalizedContext = context?.trim() ?? '';
+        const payload = {
+            version: '1.0',
+            agent: {
+                id: agentId,
+                provider,
+                mode,
+                model: model || null,
+            },
+            prompt,
+            context: normalizedContext,
+            messages: safeMessages,
+            metadata: {
+                platform: platform ?? 'cli',
+                formattedHistory,
+                messageCount: safeMessages.length,
+                generatedAt: new Date().toISOString(),
+                originalContext: normalizedContext,
+                ...platformMetadata,
+            },
+        };
+        return JSON.stringify(payload);
+    }
+    constructor(aiService, aiProviderService, workspaceService, parallelProcessingService, taskManagementService, resultFormatterService, templateService, documentLoaderService, toolCallService, agentLoaderService, remoteAgentService, providerBridgeService, skillLoaderService, layoutLoader, layoutRenderer, tracingService) {
+        this.aiService = aiService;
+        this.aiProviderService = aiProviderService;
+        this.workspaceService = workspaceService;
+        this.parallelProcessingService = parallelProcessingService;
+        this.taskManagementService = taskManagementService;
+        this.resultFormatterService = resultFormatterService;
+        this.templateService = templateService;
+        this.documentLoaderService = documentLoaderService;
+        this.toolCallService = toolCallService;
+        this.agentLoaderService = agentLoaderService;
+        this.remoteAgentService = remoteAgentService;
+        this.providerBridgeService = providerBridgeService;
+        this.skillLoaderService = skillLoaderService;
+        this.layoutLoader = layoutLoader;
+        this.layoutRenderer = layoutRenderer;
+        this.tracingService = tracingService;
+        this.logger = new common_1.Logger(CrewXTool_1.name);
+        this.timeoutConfig = (0, crewx_sdk_1.getTimeoutConfig)();
+    }
+    onModuleInit() {
+        this.toolCallService.setCrewXTool(this);
+        this.logger.log('CrewXTool registered to ToolCallService');
+    }
+    async getRenderedAgentPrompt(agentId, mockInput) {
+        const agents = await this.agentLoaderService.getAllAgents();
+        const agent = agents.find((a) => a.id === agentId);
+        if (!agent) {
+            throw new Error(`Agent '${agentId}' not found.`);
+        }
+        const securityKey = this.generateSecurityKey();
+        const documents = {};
+        if (this.documentLoaderService.isInitialized()) {
+            const docNames = this.documentLoaderService.getDocumentNames();
+            for (const docName of docNames) {
+                const content = await this.documentLoaderService.getDocumentContent(docName);
+                const toc = await this.documentLoaderService.getDocumentToc(docName);
+                const summary = await this.documentLoaderService.getDocumentSummary(docName);
+                documents[docName] = {
+                    content: content || '',
+                    toc: toc || '',
+                    summary: summary || '',
+                };
+            }
+        }
+        const templateContext = {
+            user_input: mockInput || 'Sample input for prompt preview',
+            messages: [],
+            agent: {
+                id: agent.id,
+                name: agent.name || agent.id,
+                provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
+                model: agent.inline?.model,
+                workingDirectory: agent.workingDirectory || './',
+                inline: {
+                    prompt: agent.inline?.prompt || agent.inline?.system_prompt || agent.systemPrompt || '',
+                },
+                specialties: agent.specialties,
+                capabilities: agent.capabilities,
+                description: agent.description,
+            },
+            documents: documents,
+            vars: {
+                security_key: securityKey,
+            },
+            props: {},
+            mode: 'query',
+            platform: 'cli',
+            env: process.env,
+            tools: this.buildToolsContext(),
+        };
+        return this.processAgentSystemPrompt(agent, templateContext);
+    }
+    async processAgentSystemPrompt(agent, templateContext) {
+        const inlineLayout = agent.inline?.layout;
+        const baseSystemPrompt = agent.inline?.prompt ||
+            agent.inline?.system_prompt ||
+            agent.systemPrompt ||
+            agent.description ||
+            `You are an expert ${agent.id}.`;
+        const documentsForTemplate = {};
+        if (this.documentLoaderService.isInitialized()) {
+            const docNames = this.documentLoaderService.getDocumentNames();
+            for (const docName of docNames) {
+                const content = await this.documentLoaderService.getDocumentContent(docName);
+                const toc = await this.documentLoaderService.getDocumentToc(docName);
+                const summary = await this.documentLoaderService.getDocumentSummary(docName);
+                documentsForTemplate[docName] = {
+                    content: content || '',
+                    toc: toc || '',
+                    summary: summary || '',
+                };
+            }
+        }
+        const layoutSpec = inlineLayout ?? 'crewx/default';
+        if (layoutSpec) {
+            const layoutId = typeof layoutSpec === 'string' ? layoutSpec : layoutSpec.id;
+            const layoutProps = typeof layoutSpec === 'object' && layoutSpec !== null && 'props' in layoutSpec
+                ? layoutSpec.props
+                : undefined;
+            try {
+                const layout = this.layoutLoader.load(layoutId, layoutProps);
+                const providerRaw = agent.provider;
+                const providerList = Array.isArray(providerRaw)
+                    ? providerRaw
+                    : (typeof providerRaw === 'string' && providerRaw.length > 0)
+                        ? [providerRaw]
+                        : [];
+                const providerDisplay = providerList.length > 0
+                    ? providerList.join(', ')
+                    : (typeof providerRaw === 'string' ? providerRaw : '');
+                const inlineConfig = agent.inline
+                    ? { ...agent.inline, prompt: baseSystemPrompt }
+                    : { prompt: baseSystemPrompt };
+                const templateOptions = [];
+                const sessionInfo = {
+                    mode: templateContext.mode ?? 'query',
+                    platform: templateContext.platform ?? 'cli',
+                    options: templateOptions,
+                    env: templateContext.env ?? {},
+                    vars: templateContext.vars ?? {},
+                    tools: templateContext.tools ?? null,
+                };
+                const agentSkills = await this.skillLoaderService.loadAgentSkills(agent.skills);
+                const renderContext = {
+                    user_input: templateContext.user_input,
+                    agent: {
+                        id: agent.id,
+                        name: agent.name || agent.id,
+                        role: agent.role || '',
+                        team: agent.team || '',
+                        description: agent.description || '',
+                        workingDirectory: agent.workingDirectory,
+                        capabilities: agent.capabilities || [],
+                        specialties: agent.specialties || [],
+                        provider: providerDisplay,
+                        providerList,
+                        providerRaw,
+                        inline: inlineConfig,
+                        model: agent.inline?.model,
+                        options: agent.options ?? {},
+                        optionsArray: Array.isArray(agent.options) ? agent.options : undefined,
+                        optionsByMode: !Array.isArray(agent.options) && typeof agent.options === 'object'
+                            ? agent.options
+                            : undefined,
+                        remote: agent.remote ?? null,
+                        documents: agent.inline && 'documents' in agent.inline ? agent.inline.documents : undefined,
+                    },
+                    documents: documentsForTemplate,
+                    skills: agentSkills,
+                    vars: templateContext.vars || {},
+                    props: layoutProps ?? {},
+                    messages: templateContext.messages || [],
+                    platform: templateContext.platform ?? 'cli',
+                    tools: templateContext.tools,
+                    session: sessionInfo,
+                    env: templateContext.env ?? {},
+                    metadata: templateContext.metadata ?? {},
+                    context: {
+                        mode: templateContext.mode ?? 'query',
+                        platform: templateContext.platform ?? 'cli',
+                        options: templateOptions,
+                        env: templateContext.env ?? {},
+                        vars: templateContext.vars ?? {},
+                        agent: templateContext.agent ?? null,
+                    },
+                };
+                renderContext.layout = {
+                    system_prompt: baseSystemPrompt,
+                    prompt: baseSystemPrompt,
+                };
+                const rendered = this.layoutRenderer.render(layout, renderContext);
+                this.logger.debug(`Layout rendered successfully for agent ${agent.id}`);
+                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
+                const finalSystemPrompt = await processDocumentTemplate(rendered, this.documentLoaderService, { ...templateContext, documents: documentsForTemplate });
+                return finalSystemPrompt;
+            }
+            catch (error) {
+                const layoutIdForLog = typeof layoutSpec === 'string' ? layoutSpec : layoutSpec.id;
+                console.error(`❌ [Layout Error] Failed to process layout (${layoutIdForLog}) for agent ${agent.id}:`, (0, crewx_sdk_1.getErrorMessage)(error));
+                this.logger.warn(`Failed to process layout (${layoutIdForLog}) for agent ${agent.id}: ${(0, crewx_sdk_1.getErrorMessage)(error)}`);
+                if (inlineLayout) {
+                    console.log('[Layout Fallback] Using inline.system_prompt');
+                    this.logger.warn('Falling back to inline.system_prompt');
+                }
+                else {
+                    console.log('[Layout Fallback] Using default system prompt');
+                    this.logger.warn('Falling back to default system prompt');
+                }
+            }
+        }
+        let systemPrompt = baseSystemPrompt;
+        if (systemPrompt) {
+            const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
+            systemPrompt = await processDocumentTemplate(systemPrompt, this.documentLoaderService, { ...templateContext, documents: documentsForTemplate });
+        }
+        return systemPrompt;
+    }
+    async getTaskLogs(input) {
+        const { taskId } = input || {};
+        this.logger.log('=== getTaskLogs called ===');
+        this.logger.log(`Input taskId: ${taskId}`);
+        try {
+            const logsContent = this.taskManagementService.getTaskLogsFromFile(taskId);
+            return {
+                content: [{ type: 'text', text: logsContent }],
+                isError: false
+            };
+        }
+        catch (error) {
+            this.logger.error('Error reading logs:', error);
+            return {
+                content: [{ type: 'text', text: `Error reading logs: ${error.message}` }],
+                isError: true
+            };
+        }
+    }
+    async checkAIProviders() {
+        this.logger.log('Checking AI provider availability');
+        try {
+            const availableProviders = await this.aiService.checkAvailableProviders();
+            const installation = await this.aiService.validateCLIInstallation();
+            const recommendations = this.getInstallationRecommendations(installation);
+            const bridgeProviders = this.providerBridgeService.listAvailableProviders();
+            let bridgeStatus = '⚠️ ProviderBridge: no providers registered.';
+            if (bridgeProviders.length > 0) {
+                try {
+                    const { resolution } = await this.providerBridgeService.createAgentRuntime({
+                        provider: bridgeProviders[0],
+                        defaultAgentId: 'provider-bridge-check',
+                    });
+                    bridgeStatus = `✅ ProviderBridge ready (${resolution.provider.name})`;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    bridgeStatus = `❌ ProviderBridge error: ${message}`;
+                }
+            }
+            const responseText = `🤖 **AI Providers Status**
+
+**Available Providers:**
+${availableProviders.length > 0 ? availableProviders.map(p => `✅ ${p}`).join('\n') : '❌ No providers available'}
+
+**Provider Bridge:**
+${bridgeStatus}${bridgeProviders.length > 0 ? `\nRegistered: ${bridgeProviders.join(', ')}` : ''}
+
+**Installation Status:**
+• Claude CLI: ${installation.claude ? '✅ Installed' : '❌ Not Installed'}
+• Gemini CLI: ${installation.gemini ? '✅ Installed' : '❌ Not Installed'}  
+• Copilot CLI: ${installation.copilot ? '✅ Installed' : '❌ Not Installed'}
+
+**Recommendations:**
+${recommendations.map(r => `• ${r}`).join('\n')}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: true,
+                availableProviders,
+                installation: {
+                    claude: installation.claude,
+                    gemini: installation.gemini,
+                    copilot: installation.copilot,
+                },
+                providerBridge: {
+                    status: bridgeStatus,
+                    providers: bridgeProviders,
+                },
+                recommendations,
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error(`Provider check failed: ${errorMessage}`, (0, crewx_sdk_1.getErrorStack)(error));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **AI Providers Check Failed**
+
+**Error:** ${errorMessage}
+
+No AI providers could be verified.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                availableProviders: [],
+                installation: {
+                    claude: { installed: false },
+                    gemini: { installed: false },
+                    copilot: { installed: false }
+                },
+                providerBridge: {
+                    status: '❌ ProviderBridge inspection skipped due to error',
+                    providers: [],
+                },
+            };
+        }
+    }
+    getInstallationRecommendations(installation) {
+        const recommendations = [];
+        if (!installation.claude) {
+            recommendations.push('Claude CLI installation: npm install -g @anthropic-ai/claude-code');
+        }
+        if (!installation.gemini) {
+            recommendations.push('Gemini CLI installation: npm install -g @google/gemini-cli');
+        }
+        if (!installation.copilot) {
+            recommendations.push('GitHub Copilot CLI installation: npm install -g @github/copilot-cli or gh extension install github/gh-copilot');
+        }
+        if (installation.claude && installation.gemini && installation.copilot) {
+            recommendations.push('All AI providers are available!');
+        }
+        return recommendations;
+    }
+    async listAgents() {
+        try {
+            const agents = await this.agentLoaderService.getAllAgents();
+            this.logger.log(`Retrieved ${agents.length} available agents`);
+            const agentsConfigPath = process.env.CREWX_CONFIG;
+            let yamlContent = '';
+            if (agentsConfigPath) {
+                try {
+                    const { readFile } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                    yamlContent = await readFile(agentsConfigPath, 'utf-8');
+                }
+                catch (error) {
+                    this.logger.warn('Could not read YAML file for display:', (0, crewx_sdk_1.getErrorMessage)(error));
+                }
+            }
+            const responseText = `🤖 **Available AI Agents (${agents.length} total)**
+
+**Configuration Source:** ${process.env.CREWX_CONFIG ? 'External YAML file' : 'Built-in defaults'}
+${process.env.CREWX_CONFIG ? `**Config Path:** \`${process.env.CREWX_CONFIG}\`` : ''}
+
+**Parsed Agent Summary:**
+${agents.map((agent, index) => `${index + 1}. **${agent.id}**
+   - Provider: ${agent.provider}
+   - Working Dir: ${agent.workingDirectory}
+   ${agent.name ? `- Name: ${agent.name}` : ''}
+   ${agent.role ? `- Role: ${agent.role}` : ''}
+   ${agent.team ? `- Team: ${agent.team}` : ''}
+`).join('')}
+
+${yamlContent ? `**Full YAML Configuration:**
+\`\`\`yaml
+${yamlContent}
+\`\`\`
+
+**💡 Customization Guide:**
+You can customize agents by modifying the YAML file. Required fields:
+- \`id\`: Unique identifier
+- \`working_directory\`: Path for agent operations  
+- \`inline.provider\`: AI provider (claude/gemini/copilot)
+- \`inline.system_prompt\`: Agent's specialized instructions
+
+Optional fields (like \`name\`, \`role\`, \`team\`, etc.) can be added for better organization.` : `**Default Configuration:**
+No external YAML file configured. Using built-in agents.
+Set \`CREWX_CONFIG\` environment variable to use custom agents.
+
+**Example YAML Structure:**
+\`\`\`yaml
+agents:
+  - id: "your_agent_id"
+    name: "Your Agent Name"
+    role: "specialist"
+    working_directory: "/path/to/project"
+    inline:
+      type: "agent"
+      provider: "claude"
+      system_prompt: |
+        You are a specialized AI agent for...
+\`\`\``}
+
+**Recommendations:**
+
+**🚀 Performance Tip:** For optimal results, formulate queries in English. Testing shows English queries typically produce more detailed responses, faster processing times (20% improvement), and higher success rates compared to other languages.
+
+**Configuration Source:** ${process.env.CREWX_CONFIG ? 'External YAML file' : 'Default hardcoded values'}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: true,
+                availableAgents: agents,
+                totalCount: agents.length,
+                configurationSource: process.env.CREWX_CONFIG ? 'External YAML file' : 'Default hardcoded values'
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error('Agent listing failed:', errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Error loading agents:** ${errorMessage}
+
+**Fallback:** No agents available due to configuration error.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                availableAgents: [],
+                totalCount: 0
+            };
+        }
+    }
+    async queryAgent(args) {
+        const { agentId, query, context, model, messages, platform, metadata } = args || {};
+        if (!agentId || !query) {
+            const missingParams = [];
+            if (!agentId)
+                missingParams.push('agentId');
+            if (!query)
+                missingParams.push('query');
+            this.logger.error(`[queryAgent] Missing required parameters: ${missingParams.join(', ')}`);
+            this.logger.debug(`[queryAgent] Received args: ${JSON.stringify(args)}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Parameter Validation Failed**
+
+**Error:** Missing required parameters: ${missingParams.join(', ')}
+
+**Received Arguments:**
+\`\`\`json
+${JSON.stringify(args, null, 2)}
+\`\`\`
+
+**Expected Parameters:**
+- \`agentId\` (required): Agent ID to query
+- \`query\` (required): Question or request to ask the agent
+
+Please ensure the MCP client is sending the correct JSON-RPC request format:
+\`\`\`json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "tools/call",
+  "params": {
+    "name": "crewx_queryAgent",
+    "arguments": {
+      "agentId": "your-agent-id",
+      "query": "your question here"
+    }
+  }
+}
+\`\`\``
+                    }
+                ],
+                success: false,
+                error: `Missing required parameters: ${missingParams.join(', ')}`,
+                missingParameters: missingParams,
+                receivedArgs: args,
+                readOnlyMode: true,
+                isError: true
+            };
+        }
+        let taskId;
+        let traceTaskId = null;
+        let traceCompleted = false;
+        try {
+            const agents = await this.agentLoaderService.getAllAgents();
+            const agent = agents.find(a => a.id === agentId);
+            const agentProvider = agent
+                ? (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude'
+                : 'claude';
+            taskId = this.taskManagementService.createTask({
+                type: 'query',
+                provider: agentProvider,
+                prompt: query,
+                agentId: agentId
+            });
+            process.env.CREWX_TASK_ID = taskId;
+            const agentDescriptor = model ? `${agentId} (model: ${model})` : agentId;
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Started query agent ${agentDescriptor}` });
+            const fileRemoteWs = agent ? this.resolveFileRemoteAgent(agent, agentId, taskId) : {};
+            const inheritedTraceId = process.env.CREWX_TRACE_ID;
+            const inheritedParentTaskId = process.env.CREWX_PARENT_TASK_ID;
+            const inheritedCallerAgentId = process.env.CREWX_CALLER_AGENT_ID;
+            const traceId = inheritedTraceId || crypto.randomUUID();
+            const resolvedModel = model ?? agent?.inline?.model ?? undefined;
+            traceTaskId = this.tracingService?.createTask({
+                id: taskId,
+                agent_id: agentId,
+                prompt: query,
+                mode: 'query',
+                model: resolvedModel,
+                platform: platform ?? 'cli',
+                crewx_version: version_1.CREWX_VERSION,
+                trace_id: traceId,
+                parent_task_id: inheritedParentTaskId,
+                caller_agent_id: inheritedCallerAgentId,
+                metadata: { provider: agentProvider, provider_version: undefined },
+                command: process.argv.join(' '),
+                thread_id: metadata?.thread,
+                workspace_id: fileRemoteWs.workspaceId,
+                workspace_name: fileRemoteWs.workspaceName,
+            }) ?? null;
+            this.logger.log(`[${taskId}] Querying agent ${agentId}: ${query.substring(0, 50)}...`);
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Query: ${query.substring(0, 100)}...` });
+            if (model) {
+                this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Model: ${model}` });
+            }
+            if (!agent) {
+                if (traceTaskId) {
+                    this.tracingService?.failTask(traceTaskId, `Agent '${agentId}' not found`);
+                    traceCompleted = true;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Agent Not Found**
+
+**Error:** Agent '${agentId}' not found.
+
+**Available Agents:** ${agents.map(a => a.id).join(', ')}
+
+Please check the agent ID and try again.`
+                        }
+                    ],
+                    success: false,
+                    agent: agentId,
+                    error: `Agent '${agentId}' not found`,
+                    availableAgents: agents.map(a => a.id),
+                    readOnlyMode: true
+                };
+            }
+            if (agent.remote?.type === 'mcp-http') {
+                try {
+                    const remoteResult = await this.remoteAgentService.queryRemoteAgent(agent, {
+                        query,
+                        context,
+                        model,
+                        platform,
+                        messages,
+                    });
+                    const normalized = this.normalizeRemoteResult(agent, taskId, remoteResult, true);
+                    const logLevel = normalized.success ? 'info' : 'error';
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: logLevel,
+                        message: normalized.success
+                            ? 'Remote agent query completed successfully'
+                            : `Remote agent query failed: ${normalized.error || 'Unknown error'}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, normalized, normalized.success !== false);
+                    if (traceTaskId) {
+                        if (normalized.success !== false) {
+                            this.tracingService?.completeTask(traceTaskId, (0, extract_text_1.extractTextFromContent)(normalized.content), normalized.exitCode);
+                        }
+                        else {
+                            this.tracingService?.failTask(traceTaskId, normalized.error || 'Unknown error', normalized.exitCode);
+                        }
+                        traceCompleted = true;
+                    }
+                    return normalized;
+                }
+                catch (error) {
+                    const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: 'error',
+                        message: `Remote agent query failed: ${errorMessage}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, { success: false, error: errorMessage }, false);
+                    if (traceTaskId) {
+                        this.tracingService?.failTask(traceTaskId, errorMessage);
+                        traceCompleted = true;
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ **Remote agent error**\n\n\
+${errorMessage}`,
+                            },
+                        ],
+                        success: false,
+                        agent: agentId,
+                        provider: 'remote',
+                        error: errorMessage,
+                        taskId,
+                        readOnlyMode: true,
+                        readOnly: true,
+                    };
+                }
+            }
+            const workingDir = agent.workingDirectory || process.cwd();
+            const securityKey = this.generateSecurityKey();
+            const contextMessages = messages && messages.length > 0 ? messages : [];
+            const documents = {};
+            const docNames = this.documentLoaderService.getDocumentNames();
+            for (const docName of docNames) {
+                const content = await this.documentLoaderService.getDocumentContent(docName);
+                const toc = await this.documentLoaderService.getDocumentToc(docName);
+                if (content) {
+                    documents[docName] = { content, toc };
+                }
+            }
+            const templateContext = {
+                user_input: query,
+                messages: contextMessages,
+                agent: {
+                    id: agent.id,
+                    name: agent.name || agent.id,
+                    provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
+                    model: model || agent.inline?.model,
+                    workingDirectory: workingDir,
+                    inline: {
+                        prompt: agent.inline?.prompt || agent.inline?.system_prompt || agent.systemPrompt || '',
+                    },
+                    specialties: agent.specialties,
+                    capabilities: agent.capabilities,
+                    description: agent.description,
+                },
+                documents,
+                vars: {
+                    security_key: securityKey,
+                },
+                props: {},
+                mode: 'query',
+                platform: platform,
+                metadata: metadata,
+                env: process.env,
+                tools: this.buildToolsContext(),
+            };
+            let systemPrompt = await this.processAgentSystemPrompt(agent, templateContext);
+            if (process.env.CREWX_APPEND_LEGACY === 'true') {
+                this.logger.debug('[WBS-14] Legacy append mode enabled (query)', {
+                    agentId: agent.id,
+                    layoutId: typeof agent.inline?.layout === 'string'
+                        ? agent.inline?.layout
+                        : agent.inline?.layout?.id ?? 'crewx/default',
+                });
+                systemPrompt += `
+
+Specialties: ${agent.specialties?.join(', ') || 'General'}
+Capabilities: ${agent.capabilities?.join(', ') || 'Analysis'}
+Working Directory: ${workingDir}`;
+            }
+            else if (process.env.CREWX_WBS14_TELEMETRY === 'true') {
+                this.logger.debug('[WBS-14] Metadata delegated to layout (query mode)', {
+                    agentId: agent.id,
+                    hasLayout: Boolean(agent.inline?.layout),
+                    layoutId: typeof agent.inline?.layout === 'string'
+                        ? agent.inline?.layout
+                        : agent.inline?.layout?.id ?? 'crewx/default',
+                    specialtiesCount: agent.specialties?.length ?? 0,
+                    capabilitiesCount: agent.capabilities?.length ?? 0,
+                    workingDirectory: workingDir,
+                });
+            }
+            let fullPrompt = systemPrompt;
+            if (context) {
+                fullPrompt += `\n\n${context}`;
+            }
+            if (!systemPrompt.includes('<user_query')) {
+                this.logger.debug('[Legacy] Adding <user_query> wrapper manually (layout not used)');
+                fullPrompt += `\n\n<user_query key="${securityKey}">
+${query}
+</user_query>`;
+            }
+            if (traceTaskId) {
+                this.tracingService?.updateTaskRenderedPrompt(traceTaskId, fullPrompt);
+            }
+            const promptLength = fullPrompt.length;
+            this.taskManagementService.addTaskLog(taskId, {
+                level: 'info',
+                message: `Prompt length: ${promptLength} characters`,
+            });
+            let runtimeResult;
+            let providerResolution;
+            let providerInput;
+            if (args.provider) {
+                providerInput = args.provider;
+            }
+            else if (Array.isArray(agent.provider)) {
+                providerInput = await this.getAvailableProvider(agent.provider);
+            }
+            else if (typeof agent.provider === 'string' && agent.provider.trim().length > 0) {
+                if (agent.provider.startsWith('api/')) {
+                    providerInput = agentId;
+                }
+                else {
+                    providerInput = agent.provider;
+                }
+            }
+            try {
+                runtimeResult = await this.providerBridgeService.createAgentRuntime({
+                    provider: providerInput,
+                    defaultAgentId: agentId,
+                    validAgents: agents.map(a => a.id),
+                });
+                providerResolution = runtimeResult.resolution;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : 'Unknown provider error';
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'error',
+                    message: `Provider resolution failed: ${errorMsg}`,
+                });
+                this.taskManagementService.completeTask(taskId, { success: false, error: errorMsg }, false);
+                if (traceTaskId) {
+                    this.tracingService?.failTask(traceTaskId, errorMsg);
+                    traceCompleted = true;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Provider Error**\n\n${errorMsg}\n\nAvailable providers: ${this.providerBridgeService.listAvailableProviders().join(', ')}`,
+                        },
+                    ],
+                    success: false,
+                    agent: agentId,
+                    provider: 'none',
+                    error: errorMsg,
+                    taskId,
+                    readOnlyMode: true,
+                    readOnly: true,
+                };
+            }
+            const resolvedProviderName = providerResolution.provider.name;
+            if (args.provider) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Using CLI-specified provider: ${args.provider} (resolved to ${resolvedProviderName})`
+                });
+            }
+            else if (providerInput) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Agent provider resolved to ${resolvedProviderName} (input: ${providerInput})`
+                });
+            }
+            else {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Using ProviderBridge fallback provider: ${resolvedProviderName}`,
+                });
+            }
+            const agentOptions = this.getOptionsForAgent(agent, 'query', resolvedProviderName);
+            const modelToUse = model || agent.inline?.model || providerResolution.defaultModel;
+            const structuredPayload = await this.buildStructuredPayload({
+                agentId,
+                provider: resolvedProviderName,
+                mode: 'query',
+                prompt: fullPrompt,
+                context,
+                messages,
+                platform: platform || 'cli',
+                model: modelToUse,
+                platformMetadata: metadata,
+            });
+            const runtimeMessages = this.toConversationMessages(messages);
+            let agentResult;
+            let pidRecorded = false;
+            const handleProcessStart = (pid) => {
+                if (!traceTaskId) {
+                    return;
+                }
+                const updated = this.tracingService?.updateTaskPid(traceTaskId, pid) ?? false;
+                if (updated) {
+                    pidRecorded = true;
+                }
+            };
+            try {
+                const originalLog = console.log;
+                console.log = (...args) => {
+                    const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+                    if (message.includes('[INFO]')) {
+                        this.taskManagementService.addTaskLog(taskId, {
+                            level: 'info',
+                            message: message.replace('[INFO] ', ''),
+                        });
+                    }
+                    originalLog.apply(console, args);
+                };
+                const processedEnv = await this.processAgentEnv(agent.env, agent);
+                try {
+                    agentResult = await runtimeResult.runtime.agent.query({
+                        agentId,
+                        prompt: fullPrompt,
+                        context,
+                        messages: runtimeMessages,
+                        model: modelToUse,
+                        options: {
+                            workingDirectory: workingDir,
+                            timeout: this.timeoutConfig.parallel,
+                            additionalArgs: agentOptions,
+                            taskId,
+                            securityKey,
+                            pipedContext: structuredPayload,
+                            env: processedEnv,
+                            runtime: agent.runtime,
+                            traceId,
+                            onProcessStart: handleProcessStart,
+                        },
+                    });
+                }
+                finally {
+                    console.log = originalLog;
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : 'Agent runtime query failed';
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'error',
+                    message: `Agent runtime query failed: ${errorMsg}`,
+                });
+                this.taskManagementService.completeTask(taskId, { success: false, error: errorMsg }, false);
+                if (traceTaskId) {
+                    this.tracingService?.failTask(traceTaskId, errorMsg);
+                    traceCompleted = true;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Provider Error**\n\n${errorMsg}\n\nAvailable providers: ${this.providerBridgeService.listAvailableProviders().join(', ')}`,
+                        },
+                    ],
+                    success: false,
+                    agent: agentId,
+                    provider: resolvedProviderName,
+                    error: errorMsg,
+                    taskId,
+                    readOnlyMode: true,
+                    readOnly: true,
+                };
+            }
+            const response = {
+                success: agentResult.success,
+                content: agentResult.content,
+                provider: agentResult.metadata?.provider ?? resolvedProviderName,
+                taskId: agentResult.metadata?.taskId ?? taskId,
+                error: agentResult.metadata?.error,
+                pid: agentResult.metadata?.pid,
+                command: agentResult.metadata?.command,
+                exitCode: agentResult.metadata?.exitCode,
+                durationMs: agentResult.metadata?.durationMs,
+                timeToFirstOutputMs: agentResult.metadata?.timeToFirstOutputMs,
+            };
+            if (traceTaskId && response.pid && !pidRecorded) {
+                this.tracingService?.updateTaskPid(traceTaskId, response.pid);
+            }
+            if (traceTaskId && response.command) {
+                this.tracingService?.updateTaskCodingAgentCommand(traceTaskId, response.command);
+            }
+            if (response.command) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Coding agent command: ${response.command}`,
+                });
+            }
+            if (response.pid !== undefined) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `PID: ${response.pid ?? 'unknown'}`,
+                });
+            }
+            if (response.exitCode !== undefined) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Exit code: ${response.exitCode ?? 'unknown'}`,
+                });
+            }
+            if (response.durationMs !== undefined) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Duration: ${response.durationMs}ms`,
+                });
+            }
+            if (response.timeToFirstOutputMs !== undefined) {
+                const firstResponseText = response.timeToFirstOutputMs === null
+                    ? 'unknown'
+                    : `${response.timeToFirstOutputMs}ms`;
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `First response: ${firstResponseText}`,
+                });
+            }
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Query completed. Success: ${response.success}` });
+            this.taskManagementService.completeTask(taskId, response, response.success);
+            if (traceTaskId) {
+                if (response.success) {
+                    this.tracingService?.completeTask(traceTaskId, response.content, response.exitCode);
+                }
+                else {
+                    this.tracingService?.failTask(traceTaskId, response.error || 'Unknown error', response.exitCode);
+                }
+                traceCompleted = true;
+            }
+            const responseText = response.success
+                ? response.content
+                : `❌ **Error**\n\`\`\`${response.error}\`\`\`\n\nAgent: ${agentId} (${response.provider}) · Task ID: \`${taskId}\``;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                taskId: taskId,
+                success: response.success,
+                agent: agentId,
+                provider: response.provider,
+                query: query,
+                response: response.content,
+                readOnlyMode: true,
+                error: response.error,
+                workingDirectory: workingDir
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            if (traceTaskId) {
+                this.tracingService?.failTask(traceTaskId, errorMessage);
+                traceCompleted = true;
+            }
+            if (taskId) {
+                this.taskManagementService.addTaskLog(taskId, { level: 'error', message: `Query failed: ${errorMessage}` });
+                this.taskManagementService.completeTask(taskId, { error: errorMessage }, false);
+                this.logger.error(`[${taskId}] Agent query failed for ${agentId}:`, errorMessage);
+            }
+            else {
+                this.logger.error(`Agent query failed for ${agentId} (no task ID):`, errorMessage);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Agent Query Failed**
+
+${taskId ? `**Task ID:** ${taskId}\n` : ''}**Agent:** ${agentId}
+**Error:** ${errorMessage}
+**Query:** ${query}
+
+Read-Only Mode: No files were modified.`
+                    }
+                ],
+                success: false,
+                agent: args.agentId,
+                error: errorMessage,
+                readOnlyMode: true
+            };
+        }
+        finally {
+            if (!traceCompleted && traceTaskId) {
+                this.tracingService?.failTask(traceTaskId, 'unexpected exit');
+            }
+        }
+    }
+    async executeAgent(args) {
+        const { agentId, task, projectPath, context, model, messages, platform, metadata } = args || {};
+        if (!agentId || !task) {
+            const missingParams = [];
+            if (!agentId)
+                missingParams.push('agentId');
+            if (!task)
+                missingParams.push('task');
+            this.logger.error(`[executeAgent] Missing required parameters: ${missingParams.join(', ')}`);
+            this.logger.debug(`[executeAgent] Received args: ${JSON.stringify(args)}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Parameter Validation Failed**
+
+**Error:** Missing required parameters: ${missingParams.join(', ')}
+
+**Received Arguments:**
+\`\`\`json
+${JSON.stringify(args, null, 2)}
+\`\`\`
+
+**Expected Parameters:**
+- \`agentId\` (required): Agent ID to execute
+- \`task\` (required): Task or implementation request for the agent
+
+Please ensure the MCP client is sending the correct JSON-RPC request format:
+\`\`\`json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "tools/call",
+  "params": {
+    "name": "crewx_executeAgent",
+    "arguments": {
+      "agentId": "your-agent-id",
+      "task": "your task description here"
+    }
+  }
+}
+\`\`\``
+                    }
+                ],
+                success: false,
+                error: `Missing required parameters: ${missingParams.join(', ')}`,
+                missingParameters: missingParams,
+                receivedArgs: args,
+                executionMode: true,
+                isError: true
+            };
+        }
+        let taskId;
+        let traceTaskId = null;
+        let traceCompleted = false;
+        try {
+            const agents = await this.agentLoaderService.getAllAgents();
+            const agent = agents.find(a => a.id === agentId);
+            const agentProvider = agent
+                ? (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude'
+                : 'claude';
+            taskId = this.taskManagementService.createTask({
+                type: 'execute',
+                provider: agentProvider,
+                prompt: task,
+                agentId: agentId
+            });
+            process.env.CREWX_TASK_ID = taskId;
+            const agentDescriptor = model ? `${agentId} (model: ${model})` : agentId;
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Started execute agent ${agentDescriptor}` });
+            const fileRemoteWs = agent ? this.resolveFileRemoteAgent(agent, agentId, taskId) : {};
+            const inheritedTraceId = process.env.CREWX_TRACE_ID;
+            const inheritedParentTaskId = metadata && 'parentTaskId' in metadata
+                ? (metadata.parentTaskId ?? null)
+                : process.env.CREWX_PARENT_TASK_ID;
+            const inheritedCallerAgentId = process.env.CREWX_CALLER_AGENT_ID;
+            const traceId = inheritedTraceId || crypto.randomUUID();
+            const resolvedModel = model ?? agent?.inline?.model ?? undefined;
+            traceTaskId = this.tracingService?.createTask({
+                id: taskId,
+                agent_id: agentId,
+                prompt: task,
+                mode: 'execute',
+                model: resolvedModel,
+                platform: platform ?? 'cli',
+                crewx_version: version_1.CREWX_VERSION,
+                trace_id: traceId,
+                parent_task_id: inheritedParentTaskId,
+                caller_agent_id: inheritedCallerAgentId,
+                metadata: { provider: agentProvider, provider_version: undefined },
+                command: process.argv.join(' '),
+                thread_id: metadata?.thread,
+                workspace_id: fileRemoteWs.workspaceId,
+                workspace_name: fileRemoteWs.workspaceName,
+            }) ?? null;
+            this.logger.log(`[${taskId}] Executing agent ${agentId}: ${task.substring(0, 50)}...`);
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Task: ${task.substring(0, 100)}...` });
+            if (model) {
+                this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Model: ${model}` });
+            }
+            if (!agent) {
+                if (traceTaskId) {
+                    this.tracingService?.failTask(traceTaskId, `Agent '${agentId}' not found`);
+                    traceCompleted = true;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Agent Not Found**
+
+**Error:** Agent '${agentId}' not found.
+
+**Available Agents:** ${agents.map(a => a.id).join(', ')}
+
+Please check the agent ID and try again.`
+                        }
+                    ],
+                    success: false,
+                    agent: agentId,
+                    error: `Agent '${agentId}' not found`,
+                    availableAgents: agents.map(a => a.id),
+                    executionMode: true
+                };
+            }
+            if (agent.remote?.type === 'mcp-http') {
+                try {
+                    const remoteResult = await this.remoteAgentService.executeRemoteAgent(agent, {
+                        task,
+                        context,
+                        model,
+                        platform,
+                        messages,
+                    });
+                    const normalized = this.normalizeRemoteResult(agent, taskId, remoteResult, false);
+                    const logLevel = normalized.success ? 'info' : 'error';
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: logLevel,
+                        message: normalized.success
+                            ? 'Remote agent execute completed successfully'
+                            : `Remote agent execute failed: ${normalized.error || 'Unknown error'}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, normalized, normalized.success !== false);
+                    if (traceTaskId) {
+                        if (normalized.success !== false) {
+                            this.tracingService?.completeTask(traceTaskId, (0, extract_text_1.extractTextFromContent)(normalized.content), normalized.exitCode);
+                        }
+                        else {
+                            this.tracingService?.failTask(traceTaskId, normalized.error || 'Unknown error', normalized.exitCode);
+                        }
+                        traceCompleted = true;
+                    }
+                    return normalized;
+                }
+                catch (error) {
+                    const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: 'error',
+                        message: `Remote agent execute failed: ${errorMessage}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, { success: false, error: errorMessage }, false);
+                    if (traceTaskId) {
+                        this.tracingService?.failTask(traceTaskId, errorMessage);
+                        traceCompleted = true;
+                    }
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ **Remote agent error**\n\n${errorMessage}`,
+                            },
+                        ],
+                        success: false,
+                        agent: agentId,
+                        provider: 'remote',
+                        error: errorMessage,
+                        taskId,
+                        executionMode: true,
+                        readOnly: false,
+                    };
+                }
+            }
+            const workingDir = projectPath || agent.workingDirectory || './';
+            const securityKey = this.generateSecurityKey();
+            const contextMessages = messages && messages.length > 0 ? messages : [];
+            const documentsForExecute = {};
+            const docNamesForExecute = this.documentLoaderService.getDocumentNames();
+            for (const docName of docNamesForExecute) {
+                const content = await this.documentLoaderService.getDocumentContent(docName);
+                const toc = await this.documentLoaderService.getDocumentToc(docName);
+                if (content) {
+                    documentsForExecute[docName] = { content, toc };
+                }
+            }
+            const templateContext = {
+                user_input: task,
+                messages: contextMessages,
+                agent: {
+                    id: agent.id,
+                    name: agent.name || agent.id,
+                    provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
+                    model: model || agent.inline?.model,
+                    workingDirectory: workingDir,
+                    inline: {
+                        prompt: agent.inline?.prompt || agent.inline?.system_prompt || agent.systemPrompt || '',
+                    },
+                    specialties: agent.specialties,
+                    capabilities: agent.capabilities,
+                    description: agent.description,
+                },
+                documents: documentsForExecute,
+                vars: {
+                    security_key: securityKey,
+                },
+                props: {},
+                mode: 'execute',
+                platform: platform,
+                metadata: metadata,
+                env: process.env,
+                tools: this.buildToolsContext(),
+            };
+            let systemPrompt = await this.processAgentSystemPrompt(agent, templateContext);
+            if (process.env.CREWX_APPEND_LEGACY === 'true') {
+                this.logger.debug('[WBS-14] Legacy append mode enabled (execute)', {
+                    agentId: agent.id,
+                    layoutId: typeof agent.inline?.layout === 'string'
+                        ? agent.inline?.layout
+                        : agent.inline?.layout?.id ?? 'crewx/default',
+                });
+                systemPrompt += `
+Specialties: ${agent.specialties?.join(', ') || 'General'}
+Capabilities: ${agent.capabilities?.join(', ') || 'Implementation'}
+Working Directory: ${workingDir}`;
+            }
+            else if (process.env.CREWX_WBS14_TELEMETRY === 'true') {
+                this.logger.debug('[WBS-14] Metadata delegated to layout (execute mode)', {
+                    agentId: agent.id,
+                    hasLayout: Boolean(agent.inline?.layout),
+                    layoutId: typeof agent.inline?.layout === 'string'
+                        ? agent.inline?.layout
+                        : agent.inline?.layout?.id ?? 'crewx/default',
+                    specialtiesCount: agent.specialties?.length ?? 0,
+                    capabilitiesCount: agent.capabilities?.length ?? 0,
+                    workingDirectory: workingDir,
+                });
+            }
+            const fullPrompt = context
+                ? `${systemPrompt}
+${context}
+
+Task: ${task}
+`
+                : `${systemPrompt}
+
+Task: ${task}
+`;
+            if (traceTaskId) {
+                this.tracingService?.updateTaskRenderedPrompt(traceTaskId, fullPrompt);
+            }
+            const promptLength = fullPrompt.length;
+            this.taskManagementService.addTaskLog(taskId, {
+                level: 'info',
+                message: `Prompt length: ${promptLength} characters`,
+            });
+            let runtimeResult;
+            let providerResolution;
+            let providerInput;
+            if (args.provider) {
+                providerInput = args.provider;
+            }
+            else if (Array.isArray(agent.provider)) {
+                providerInput = await this.getAvailableProvider(agent.provider);
+            }
+            else if (typeof agent.provider === 'string' && agent.provider.trim().length > 0) {
+                if (agent.provider.startsWith('api/')) {
+                    providerInput = agentId;
+                }
+                else {
+                    providerInput = agent.provider;
+                }
+            }
+            try {
+                runtimeResult = await this.providerBridgeService.createAgentRuntime({
+                    provider: providerInput,
+                    defaultAgentId: agentId,
+                    validAgents: agents.map(a => a.id),
+                    enableCallStack: true,
+                });
+                providerResolution = runtimeResult.resolution;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : 'Unknown provider error';
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'error',
+                    message: `Provider resolution failed: ${errorMsg}`,
+                });
+                this.taskManagementService.completeTask(taskId, { success: false, error: errorMsg }, false);
+                if (traceTaskId) {
+                    this.tracingService?.failTask(traceTaskId, errorMsg);
+                    traceCompleted = true;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Provider Error**\n\n${errorMsg}\n\nAvailable providers: ${this.providerBridgeService.listAvailableProviders().join(', ')}`,
+                        },
+                    ],
+                    success: false,
+                    agent: agentId,
+                    provider: 'none',
+                    error: errorMsg,
+                    taskId,
+                    readOnlyMode: false,
+                    readOnly: false,
+                };
+            }
+            const resolvedProviderName = providerResolution.provider.name;
+            if (args.provider) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Using CLI-specified provider: ${args.provider} (resolved to ${resolvedProviderName})`
+                });
+            }
+            else if (providerInput) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Agent provider resolved to ${resolvedProviderName} (input: ${providerInput})`
+                });
+            }
+            else {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Using ProviderBridge fallback provider: ${resolvedProviderName}`,
+                });
+            }
+            const agentOptions = this.getOptionsForAgent(agent, 'execute', resolvedProviderName);
+            const modelToUse = model || agent.inline?.model || providerResolution.defaultModel;
+            const structuredPayload = await this.buildStructuredPayload({
+                agentId,
+                provider: resolvedProviderName,
+                mode: 'execute',
+                prompt: fullPrompt,
+                context,
+                messages,
+                platform: platform || 'cli',
+                model: modelToUse,
+                platformMetadata: metadata,
+            });
+            const runtimeMessages = this.toConversationMessages(messages);
+            let agentResult;
+            let pidRecorded = false;
+            const handleProcessStart = (pid) => {
+                if (!traceTaskId) {
+                    return;
+                }
+                const updated = this.tracingService?.updateTaskPid(traceTaskId, pid) ?? false;
+                if (updated) {
+                    pidRecorded = true;
+                }
+            };
+            try {
+                const originalLog = console.log;
+                console.log = (...args) => {
+                    const message = args.map(arg => typeof arg === 'object' ? JSON.stringify(arg) : String(arg)).join(' ');
+                    if (message.includes('[INFO]')) {
+                        this.taskManagementService.addTaskLog(taskId, {
+                            level: 'info',
+                            message: message.replace('[INFO] ', ''),
+                        });
+                    }
+                    originalLog.apply(console, args);
+                };
+                const processedEnv = await this.processAgentEnv(agent.env, agent);
+                try {
+                    agentResult = await runtimeResult.runtime.agent.execute({
+                        agentId,
+                        prompt: fullPrompt,
+                        context,
+                        messages: runtimeMessages,
+                        model: modelToUse,
+                        options: {
+                            workingDirectory: workingDir,
+                            timeout: this.timeoutConfig.parallel,
+                            additionalArgs: agentOptions,
+                            taskId,
+                            pipedContext: structuredPayload,
+                            securityKey,
+                            env: processedEnv,
+                            runtime: agent.runtime,
+                            traceId,
+                            onProcessStart: handleProcessStart,
+                        },
+                    });
+                }
+                finally {
+                    console.log = originalLog;
+                }
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : 'Agent runtime execution failed';
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'error',
+                    message: `Agent runtime execution failed: ${errorMsg}`,
+                });
+                this.taskManagementService.completeTask(taskId, { success: false, error: errorMsg }, false);
+                if (traceTaskId) {
+                    this.tracingService?.failTask(traceTaskId, errorMsg);
+                    traceCompleted = true;
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Provider Error**\n\n${errorMsg}\n\nAvailable providers: ${this.providerBridgeService.listAvailableProviders().join(', ')}`,
+                        },
+                    ],
+                    success: false,
+                    agent: agentId,
+                    provider: resolvedProviderName,
+                    error: errorMsg,
+                    taskId,
+                    readOnlyMode: false,
+                    readOnly: false,
+                };
+            }
+            const response = {
+                success: agentResult.success,
+                content: agentResult.content,
+                provider: agentResult.metadata?.provider ?? resolvedProviderName,
+                taskId: agentResult.metadata?.taskId ?? taskId,
+                error: agentResult.metadata?.error,
+                pid: agentResult.metadata?.pid,
+                command: agentResult.metadata?.command,
+                exitCode: agentResult.metadata?.exitCode,
+                durationMs: agentResult.metadata?.durationMs,
+                timeToFirstOutputMs: agentResult.metadata?.timeToFirstOutputMs,
+            };
+            if (traceTaskId && response.pid && !pidRecorded) {
+                this.tracingService?.updateTaskPid(traceTaskId, response.pid);
+            }
+            if (traceTaskId && response.command) {
+                this.tracingService?.updateTaskCodingAgentCommand(traceTaskId, response.command);
+            }
+            if (response.command) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Coding agent command: ${response.command}`,
+                });
+            }
+            if (response.pid !== undefined) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `PID: ${response.pid ?? 'unknown'}`,
+                });
+            }
+            if (response.exitCode !== undefined) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Exit code: ${response.exitCode ?? 'unknown'}`,
+                });
+            }
+            if (response.durationMs !== undefined) {
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `Duration: ${response.durationMs}ms`,
+                });
+            }
+            if (response.timeToFirstOutputMs !== undefined) {
+                const firstResponseText = response.timeToFirstOutputMs === null
+                    ? 'unknown'
+                    : `${response.timeToFirstOutputMs}ms`;
+                this.taskManagementService.addTaskLog(taskId, {
+                    level: 'info',
+                    message: `First response: ${firstResponseText}`,
+                });
+            }
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Execution completed. Success: ${response.success}` });
+            this.taskManagementService.completeTask(taskId, response, response.success);
+            if (traceTaskId) {
+                if (response.success) {
+                    this.tracingService?.completeTask(traceTaskId, response.content, response.exitCode);
+                }
+                else {
+                    this.tracingService?.failTask(traceTaskId, response.error || 'Unknown error', response.exitCode);
+                }
+                traceCompleted = true;
+            }
+            const responseText = response.success ? response.content : `❌ Execution Failed: ${response.error}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: response.success,
+                taskId: taskId,
+                agent: agentId,
+                provider: response.provider,
+                implementation: response.content,
+                error: response.error,
+                recommendations: []
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            if (traceTaskId) {
+                this.tracingService?.failTask(traceTaskId, errorMessage);
+                traceCompleted = true;
+            }
+            if (taskId) {
+                this.taskManagementService.addTaskLog(taskId, { level: 'error', message: `Execution failed: ${errorMessage}` });
+                this.taskManagementService.completeTask(taskId, { error: errorMessage }, false);
+                this.logger.error(`[${taskId}] Agent execution failed for ${agentId}:`, errorMessage);
+            }
+            else {
+                this.logger.error(`Agent execution failed for ${agentId} (no task ID):`, errorMessage);
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Execution Failed: ${errorMessage}`
+                    }
+                ],
+                success: false,
+                taskId: taskId,
+                agent: agentId,
+                provider: 'unknown',
+                implementation: null,
+                error: errorMessage,
+                recommendations: []
+            };
+        }
+        finally {
+            if (!traceCompleted && traceTaskId) {
+                this.tracingService?.failTask(traceTaskId, 'unexpected exit');
+            }
+        }
+    }
+    normalizeRemoteResult(agent, taskId, remoteResult, readOnly) {
+        const normalizedAgentId = remoteResult?.agent ?? agent.remote?.agentId ?? agent.id;
+        const provider = remoteResult?.provider ?? 'remote';
+        let content = remoteResult?.content;
+        if (!Array.isArray(content) || content.length === 0) {
+            const fallback = remoteResult?.response ??
+                remoteResult?.implementation ??
+                remoteResult?.message ??
+                remoteResult?.output;
+            const text = typeof fallback === 'string'
+                ? fallback
+                : JSON.stringify(fallback ?? remoteResult, null, 2);
+            content = [
+                {
+                    type: 'text',
+                    text,
+                },
+            ];
+        }
+        return {
+            ...remoteResult,
+            content,
+            agent: normalizedAgentId,
+            provider,
+            taskId: remoteResult?.taskId ?? taskId,
+            success: remoteResult?.success !== false,
+            readOnlyMode: readOnly,
+            readOnly,
+        };
+    }
+    toConversationMessages(messages) {
+        if (!messages || messages.length === 0) {
+            return [];
+        }
+        return messages.map((message, index) => {
+            const metadata = message.metadata ?? {};
+            const rawTimestamp = metadata.timestamp;
+            let timestamp;
+            if (rawTimestamp instanceof Date) {
+                timestamp = rawTimestamp;
+            }
+            else if (typeof rawTimestamp === 'number') {
+                timestamp = new Date(rawTimestamp);
+            }
+            else if (typeof rawTimestamp === 'string') {
+                const parsed = new Date(rawTimestamp);
+                timestamp = Number.isNaN(parsed.getTime()) ? new Date() : parsed;
+            }
+            else {
+                timestamp = new Date();
+            }
+            return {
+                id: typeof metadata.id === 'string' ? metadata.id : `cli-msg-${index}`,
+                userId: typeof metadata.userId === 'string'
+                    ? metadata.userId
+                    : message.isAssistant
+                        ? 'assistant'
+                        : 'user',
+                text: message.text,
+                timestamp,
+                isAssistant: message.isAssistant,
+                metadata: metadata,
+                files: message.files,
+            };
+        });
+    }
+    getOptionsForAgent(agent, mode, provider) {
+        try {
+            if (agent.options && typeof agent.options === 'object' && !Array.isArray(agent.options)) {
+                const modeOptions = agent.options[mode];
+                if (modeOptions && typeof modeOptions === 'object' && !Array.isArray(modeOptions)) {
+                    if (provider) {
+                        const simpleProviderName = provider.includes('/') ? provider.split('/').pop() : provider;
+                        if (simpleProviderName && modeOptions[simpleProviderName]) {
+                            return modeOptions[simpleProviderName];
+                        }
+                        if (modeOptions[provider]) {
+                            return modeOptions[provider];
+                        }
+                    }
+                    if (modeOptions['default']) {
+                        return modeOptions['default'];
+                    }
+                    return [];
+                }
+                return modeOptions || [];
+            }
+            if (agent.options && Array.isArray(agent.options)) {
+                return agent.options;
+            }
+            return [];
+        }
+        catch (error) {
+            this.logger.warn(`Failed to get options for agent ${agent.id}: ${error}`);
+            return [];
+        }
+    }
+    async queryAgentParallel(args) {
+        try {
+            const { queries } = args || {};
+            this.logger.log(`Starting parallel agent queries (${queries?.length || 0} queries)`);
+            if (!queries || queries.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **No Queries Provided**
+
+Please provide at least one query in the queries array.
+
+**Example:**
+\`\`\`json
+{
+  "queries": [
+    {
+      "agentId": "gmail_mcp_developer",
+      "query": "Analyze the README"
+    },
+    {
+      "agentId": "frontend_developer", 
+      "query": "Explain the component structure"
+    }
+  ]
+}
+\`\`\``
+                        }
+                    ],
+                    success: false,
+                    error: 'No queries provided',
+                    results: []
+                };
+            }
+            queries.forEach((q, index) => {
+                const queryPreview = q.query ? q.query.substring(0, 50) : '(no query)';
+                this.logger.log(`Query ${index + 1}: ${q.agentId || '(no agent)'} -> "${queryPreview}..."`);
+            });
+            const startTime = Date.now();
+            const queryPromises = queries.map(async (q, index) => {
+                const queryStart = Date.now();
+                try {
+                    const result = await this.queryAgent({
+                        agentId: q.agentId,
+                        query: q.query,
+                        context: q.context,
+                        model: q.model,
+                        messages: q.messages,
+                        platform: q.platform
+                    });
+                    const duration = Date.now() - queryStart;
+                    return {
+                        index: index + 1,
+                        agentId: q.agentId,
+                        query: q.query,
+                        success: result.success !== false,
+                        response: result.response || result.content?.[0]?.text,
+                        provider: result.provider,
+                        duration,
+                        taskId: result.taskId
+                    };
+                }
+                catch (error) {
+                    const duration = Date.now() - queryStart;
+                    return {
+                        index: index + 1,
+                        agentId: q.agentId,
+                        query: q.query,
+                        success: false,
+                        error: error.message,
+                        duration
+                    };
+                }
+            });
+            const results = await Promise.all(queryPromises);
+            const totalDuration = Date.now() - startTime;
+            const successCount = results.filter(r => r.success).length;
+            const failureCount = results.length - successCount;
+            const summary = {
+                total: results.length,
+                successful: successCount,
+                failed: failureCount,
+                totalDuration,
+                averageDuration: results.reduce((sum, r) => sum + r.duration, 0) / results.length
+            };
+            this.logger.log(`Parallel queries completed: ${successCount} success, ${failureCount} failed, ${totalDuration}ms total`);
+            const enhancedResults = results;
+            const formattedResult = this.resultFormatterService.formatParallelResult(enhancedResults, {
+                total: summary.total,
+                success: summary.successful,
+                failed: summary.failed,
+                totalDuration: summary.totalDuration,
+                averageDuration: summary.averageDuration,
+                fastest: Math.min(...results.map(r => r.duration)),
+                slowest: Math.max(...results.map(r => r.duration)),
+                timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - summary.totalDuration)
+            }, true);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: formattedResult.mcp
+                    }
+                ],
+                success: true,
+                summary: {
+                    totalQueries: summary.total,
+                    successful: summary.successful,
+                    failed: summary.failed,
+                    totalDuration: summary.totalDuration,
+                    averageDuration: summary.averageDuration
+                },
+                results: enhancedResults,
+                performance: {
+                    fastestQuery: Math.min(...results.map(r => r.duration)),
+                    slowestQuery: Math.max(...results.map(r => r.duration)),
+                    timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - summary.totalDuration)
+                },
+                readOnlyMode: true
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error('Parallel agent queries failed:', errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Parallel Agent Queries Failed**
+
+**Error:** ${errorMessage}
+
+**Total Queries:** ${args.queries?.length || 0}
+
+Read-Only Mode: No files were modified.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                results: [],
+                readOnlyMode: true
+            };
+        }
+    }
+    async executeAgentParallel(args) {
+        try {
+            const { tasks } = args || {};
+            this.logger.log(`Starting parallel agent execution (${tasks?.length || 0} tasks)`);
+            if (!tasks || tasks.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **No Tasks Provided**
+
+Please provide at least one task in the tasks array.
+
+**Example:**
+\`\`\`json
+{
+  "tasks": [
+    {
+      "task": "Create a utility function for handling timeouts"
+    },
+    {
+      "agentId": "crewx_developer_claude",
+      "task": "Write unit tests for the new utility function"
+    },
+    {
+      "agentId": "crewx_developer_gemini",
+      "task": "Review the implementation for edge cases"
+    }
+  ]
+}
+\`\`\``
+                        }
+                    ],
+                    success: false,
+                    error: 'No tasks provided',
+                    results: []
+                };
+            }
+            tasks.forEach((t, index) => {
+                const taskPreview = t.task ? t.task.substring(0, 50) : '(no task)';
+                this.logger.log(`Task ${index + 1}: ${t.agentId || '(no agent)'} -> "${taskPreview}..."`);
+            });
+            const startTime = Date.now();
+            const results = await Promise.all(tasks.map(async (taskItem, index) => {
+                const taskStartTime = Date.now();
+                try {
+                    const result = await this.executeAgent({
+                        agentId: taskItem.agentId,
+                        task: taskItem.task,
+                        projectPath: taskItem.projectPath,
+                        context: taskItem.context,
+                    });
+                    const taskDuration = Date.now() - taskStartTime;
+                    return {
+                        index: index + 1,
+                        agentId: taskItem.agentId,
+                        task: taskItem.task,
+                        success: result.success,
+                        implementation: result.implementation || result.error,
+                        provider: result.provider,
+                        duration: taskDuration,
+                        error: result.error,
+                        context: taskItem.context,
+                        workingDirectory: taskItem.projectPath || `Default for ${taskItem.agentId}`,
+                        recommendations: result.recommendations || [],
+                        taskId: result.taskId
+                    };
+                }
+                catch (error) {
+                    const taskDuration = Date.now() - taskStartTime;
+                    return {
+                        index: index + 1,
+                        agentId: taskItem.agentId,
+                        task: taskItem.task,
+                        success: false,
+                        implementation: null,
+                        provider: 'unknown',
+                        duration: taskDuration,
+                        error: error.message || 'Unknown error occurred',
+                        context: taskItem.context,
+                        workingDirectory: taskItem.projectPath || `Default for ${taskItem.agentId}`,
+                        recommendations: [],
+                        taskId: null
+                    };
+                }
+            }));
+            const totalDuration = Date.now() - startTime;
+            const successCount = results.filter(r => r.success).length;
+            const failureCount = results.length - successCount;
+            this.logger.log(`Parallel execution completed: ${successCount} success, ${failureCount} failed, ${totalDuration}ms total`);
+            const responseText = `⚡ **Parallel Agent Execution Results**
+
+**Summary:**
+- Total Tasks: ${results.length}
+- Successful: ${successCount}
+- Failed: ${failureCount}
+- Total Duration: ${totalDuration}ms
+- Average Duration: ${Math.round(totalDuration / results.length)}ms per task
+
+**Individual Results:**
+
+${results.map(result => `---
+**${result.index}. Agent: ${result.agentId}** (${result.provider}) - ${result.duration}ms
+**Task:** ${result.task}
+**Status:** ${result.success ? '✅ Success' : '❌ Failed'}
+**Working Directory:** ${result.workingDirectory}
+${result.context ? `**Context:** ${result.context}\n` : ''}
+**Implementation:**
+${result.success ? result.implementation : `Error: ${result.error}`}
+
+${result.recommendations.length > 0 ? `**Recommendations:**
+${result.recommendations.map((recommendation) => `• ${recommendation}`).join('\n')}` : ''}
+`).join('\n')}
+
+**Performance Insights:**
+- Fastest Task: ${Math.min(...results.map(r => r.duration))}ms
+- Slowest Task: ${Math.max(...results.map(r => r.duration))}ms
+- Parallel processing saved approximately ${Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - totalDuration)}ms compared to sequential execution
+
+**⚠️ Important Notes:**
+- All tasks were executed in IMPLEMENTATION MODE with potential file modifications
+- Review all provided implementations before applying changes
+- Test in development environment first
+- Consider backing up files before making modifications`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: true,
+                summary: {
+                    totalTasks: results.length,
+                    successful: successCount,
+                    failed: failureCount,
+                    totalDuration,
+                    averageDuration: Math.round(totalDuration / results.length)
+                },
+                results: results,
+                performance: {
+                    fastestTask: Math.min(...results.map(r => r.duration)),
+                    slowestTask: Math.max(...results.map(r => r.duration)),
+                    timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - totalDuration)
+                },
+                executionMode: true
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error('Parallel agent execution failed:', errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Parallel Agent Execution Failed**
+
+**Error:** ${errorMessage}
+
+**Total Tasks:** ${args.tasks?.length || 0}
+
+Execution Mode: Implementation guidance could not be provided.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                results: [],
+                executionMode: true
+            };
+        }
+    }
+    async clearAllLogs() {
+        try {
+            const logsDir = path.join(process.cwd(), '.crewx', 'logs');
+            if (!fs.existsSync(logsDir)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `📁 **Log Directory Status**
+
+❌ **No logs directory found**
+
+The logs directory \`.crewx/logs\` does not exist. Nothing to clean.
+
+**Path checked:** \`${logsDir}\`
+`
+                        }
+                    ],
+                    success: true,
+                    message: 'No logs directory found',
+                    path: logsDir
+                };
+            }
+            const files = fs.readdirSync(logsDir);
+            const logFiles = files.filter(file => file.endsWith('.log'));
+            if (logFiles.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `📁 **Log Directory Status**
+
+✅ **Already clean**
+
+The logs directory exists but contains no log files to clean.
+
+**Directory:** \`${logsDir}\`
+**Total files:** ${files.length}
+**Log files:** 0
+`
+                        }
+                    ],
+                    success: true,
+                    message: 'No log files to clean',
+                    path: logsDir,
+                    totalFiles: files.length,
+                    logFiles: 0
+                };
+            }
+            let totalSize = 0;
+            let deletedCount = 0;
+            const deletedFiles = [];
+            for (const file of logFiles) {
+                const filePath = path.join(logsDir, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    totalSize += stats.size;
+                    fs.unlinkSync(filePath);
+                    deletedCount++;
+                    deletedFiles.push(file);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to delete log file ${file}:`, error);
+                }
+            }
+            const formatSize = (bytes) => {
+                if (bytes === 0)
+                    return '0 B';
+                const k = 1024;
+                const sizes = ['B', 'KB', 'MB', 'GB'];
+                const i = Math.floor(Math.log(bytes) / Math.log(k));
+                return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `🗑️ **Log Cleanup Complete**
+
+✅ **Successfully cleared all log files**
+
+**Directory:** \`${logsDir}\`
+**Files deleted:** ${deletedCount}
+**Total space freed:** ${formatSize(totalSize)}
+
+${deletedCount > 10 ?
+                            `**Sample deleted files:**
+${deletedFiles.slice(0, 10).map(f => `  • ${f}`).join('\n')}
+  • ... and ${deletedCount - 10} more files` :
+                            `**Deleted files:**
+${deletedFiles.map(f => `  • ${f}`).join('\n')}`}
+
+The logs directory is now clean and ready for new task logs. 🧹✨
+`
+                    }
+                ],
+                success: true,
+                message: 'All log files cleared successfully',
+                path: logsDir,
+                deletedCount,
+                totalSize,
+                deletedFiles: deletedFiles.slice(0, 20)
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to clear logs:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Log Cleanup Failed**
+
+**Error:** ${error.message}
+
+Please check permissions and try again, or manually delete files from \`.crewx/logs/\` directory.
+`
+                    }
+                ],
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    async getAvailableProvider(providerConfig) {
+        const defaultFallbackOrder = ['claude', 'gemini', 'copilot'];
+        let fallbackOrder;
+        if (!providerConfig) {
+            fallbackOrder = defaultFallbackOrder;
+        }
+        else if (Array.isArray(providerConfig)) {
+            fallbackOrder = providerConfig;
+        }
+        else {
+            fallbackOrder = [providerConfig, ...defaultFallbackOrder.filter(p => p !== providerConfig)];
+        }
+        for (const providerName of fallbackOrder) {
+            const provider = this.aiProviderService.getProvider(providerName);
+            if (provider) {
+                const isAvailable = await provider.isAvailable();
+                if (isAvailable) {
+                    if (fallbackOrder.indexOf(providerName) > 0) {
+                        this.logger.log(`Using fallback provider: ${providerName} (tried: ${fallbackOrder.slice(0, fallbackOrder.indexOf(providerName)).join(', ')})`);
+                    }
+                    return providerName;
+                }
+            }
+        }
+        this.logger.warn('No providers available, defaulting to claude');
+        return 'claude';
+    }
+    resolveFileRemoteAgent(agent, agentId, taskId) {
+        const fileRemote = this.remoteAgentService.resolveFileRemoteConfig(agent);
+        if (!fileRemote)
+            return {};
+        const targetConfig = (0, crewx_sdk_1.parseCrewxConfigFromFile)(fileRemote.configPath);
+        const targetAgent = targetConfig.agents?.find(a => a.id === fileRemote.externalAgentId);
+        if (!targetAgent) {
+            throw new Error(`Agent '${fileRemote.externalAgentId}' not found in ${fileRemote.configPath}`);
+        }
+        const targetProvider = Array.isArray(targetAgent.provider)
+            ? targetAgent.provider[0] : targetAgent.provider;
+        if (typeof targetProvider === 'string' && targetProvider.startsWith('remote/')) {
+            throw new Error(`Chained remotes not supported: ${fileRemote.externalAgentId} → ${targetProvider}`);
+        }
+        const targetDir = targetAgent.working_directory || path.dirname(fileRemote.configPath);
+        this.logger.log(`[${taskId}] file:// remote: resolving '${fileRemote.externalAgentId}' via ${targetProvider}`);
+        Object.assign(agent, targetAgent, {
+            id: agentId,
+            provider: targetProvider,
+            workingDirectory: targetDir,
+        });
+        delete agent.remote;
+        const wsInfo = this.tracingService?.resolveWorkspaceIdForPath(targetDir);
+        return {
+            workspaceId: wsInfo?.workspaceId,
+            workspaceName: wsInfo?.workspaceName,
+        };
+    }
+};
+exports.CrewXTool = CrewXTool;
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}getTaskLogs`,
+        description: 'Get task logs by task ID to monitor progress and detailed execution logs.',
+        input: {
+            taskId: zod_1.z.string().optional().describe('Task ID to get logs for. If not provided, returns all recent tasks.')
+        },
+        annotations: {
+            title: 'Get Task Logs',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "getTaskLogs", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}checkAIProviders`,
+        description: 'Check the status of available AI CLI tools (Claude, Gemini, GitHub Copilot).',
+        input: {},
+        annotations: {
+            title: 'Check AI Providers Status',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "checkAIProviders", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}listAgents`,
+        description: 'List available specialist AI agents that can be utilized. Each agent is specialized in a specific domain.',
+        input: {},
+        annotations: {
+            title: 'List Available AI Agents',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "listAgents", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}queryAgent`,
+        description: 'Query a specific specialist agent (read-only mode). You can request code analysis, explanations, reviews, etc. No file modifications will be performed.',
+        input: {
+            agentId: zod_1.z.string().describe('Agent ID to query (e.g., frontend_developer, backend_developer, devops_engineer, security_analyst, or custom agents)'),
+            query: zod_1.z.string().describe('Question or request to ask the agent'),
+            projectPath: zod_1.z.string().describe('Absolute path of the project to analyze').optional(),
+            context: zod_1.z.string().describe('Additional context or background information').optional(),
+            model: zod_1.z.string().describe('Model to use for this query (e.g., sonnet, gemini-2.5-pro, gpt-5)').optional(),
+            messages: zod_1.z.array(zod_1.z.object({
+                text: zod_1.z.string(),
+                isAssistant: zod_1.z.boolean(),
+                metadata: zod_1.z.record(zod_1.z.any()).optional(),
+                files: zod_1.z.array(zod_1.z.object({
+                    id: zod_1.z.string(),
+                    name: zod_1.z.string(),
+                    mimetype: zod_1.z.string().optional(),
+                    size: zod_1.z.number().optional(),
+                    localPath: zod_1.z.string().optional(),
+                    url: zod_1.z.string().optional(),
+                })).optional(),
+            })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+            platform: zod_1.z.enum(['cli', 'slack']).optional(),
+            metadata: zod_1.z.record(zod_1.z.any()).optional(),
+        },
+        annotations: {
+            title: 'Query Specialist Agent (Read-Only)',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "queryAgent", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}executeAgent`,
+        description: 'Execute tasks through a specialist agent. Can provide implementation guidance, code examples, and actionable solutions.',
+        input: {
+            agentId: zod_1.z.string().describe('Agent ID to execute (e.g., frontend_developer, backend_developer, devops_engineer, security_analyst, or custom agents)'),
+            task: zod_1.z.string().describe('Task or implementation request for the agent to perform'),
+            projectPath: zod_1.z.string().describe('Absolute path of the project to work on').optional(),
+            context: zod_1.z.string().describe('Additional context or background information').optional(),
+            model: zod_1.z.string().describe('Model to use for this execution (e.g., sonnet, gemini-2.5-pro, gpt-5)').optional(),
+            messages: zod_1.z.array(zod_1.z.object({
+                text: zod_1.z.string(),
+                isAssistant: zod_1.z.boolean(),
+                metadata: zod_1.z.record(zod_1.z.any()).optional(),
+                files: zod_1.z.array(zod_1.z.object({
+                    id: zod_1.z.string(),
+                    name: zod_1.z.string(),
+                    mimetype: zod_1.z.string().optional(),
+                    size: zod_1.z.number().optional(),
+                    localPath: zod_1.z.string().optional(),
+                    url: zod_1.z.string().optional(),
+                })).optional(),
+            })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+            platform: zod_1.z.enum(['cli', 'slack']).optional(),
+            metadata: zod_1.z.record(zod_1.z.any()).optional(),
+        },
+        annotations: {
+            title: 'Execute Agent Task (Can Modify Files)',
+            readOnlyHint: false,
+            desctructiveHint: true
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "executeAgent", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}queryAgentParallel`,
+        description: 'Query multiple specialist agents simultaneously in parallel (read-only mode). Efficiently send multiple tasks to the same agent or different questions to various agents.',
+        input: {
+            queries: zod_1.z.array(zod_1.z.object({
+                agentId: zod_1.z.string().describe('Agent ID to query (e.g., frontend_developer, backend_developer, gmail_mcp_developer, etc.)'),
+                query: zod_1.z.string().describe('Question or request to ask the agent'),
+                projectPath: zod_1.z.string().describe('Absolute path of the project to analyze').optional(),
+                context: zod_1.z.string().describe('Additional context or background information').optional(),
+                model: zod_1.z.string().describe('Model to use for this query').optional(),
+                messages: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string(),
+                    isAssistant: zod_1.z.boolean(),
+                    metadata: zod_1.z.record(zod_1.z.any()).optional(),
+                    files: zod_1.z.array(zod_1.z.object({
+                        id: zod_1.z.string(),
+                        name: zod_1.z.string(),
+                        mimetype: zod_1.z.string().optional(),
+                        size: zod_1.z.number().optional(),
+                        localPath: zod_1.z.string().optional(),
+                        url: zod_1.z.string().optional(),
+                    })).optional(),
+                })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+            })).describe('Array of queries to process in parallel'),
+        },
+        annotations: {
+            title: 'Query Multiple Agents in Parallel (Read-Only)',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "queryAgentParallel", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}executeAgentParallel`,
+        description: 'Execute multiple tasks through specialist agents simultaneously in parallel (execution mode). Efficiently distribute implementation work across multiple agents.',
+        input: {
+            tasks: zod_1.z.array(zod_1.z.object({
+                agentId: zod_1.z.string().describe('Agent ID to execute (e.g., frontend_developer, backend_developer, crewx_developer_claude, etc.)'),
+                task: zod_1.z.string().describe('Task or implementation request for the agent to perform'),
+                projectPath: zod_1.z.string().describe('Absolute path of the project to work on').optional(),
+                context: zod_1.z.string().describe('Additional context or background information').optional(),
+                model: zod_1.z.string().describe('Model to use for this execution').optional(),
+                messages: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string(),
+                    isAssistant: zod_1.z.boolean(),
+                    metadata: zod_1.z.record(zod_1.z.any()).optional(),
+                    files: zod_1.z.array(zod_1.z.object({
+                        id: zod_1.z.string(),
+                        name: zod_1.z.string(),
+                        mimetype: zod_1.z.string().optional(),
+                        size: zod_1.z.number().optional(),
+                        localPath: zod_1.z.string().optional(),
+                        url: zod_1.z.string().optional(),
+                    })).optional(),
+                })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+            })).describe('Array of tasks to execute in parallel'),
+        },
+        annotations: {
+            title: 'Execute Multiple Agent Tasks in Parallel (Can Modify Files)',
+            readOnlyHint: false,
+            desctructiveHint: true
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "executeAgentParallel", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}clearAllLogs`,
+        description: 'Clear all log files from the .crewx/logs directory to clean up accumulated task logs',
+        input: {},
+        annotations: {
+            title: 'Clear All Logs',
+            readOnlyHint: false,
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "clearAllLogs", null);
+exports.CrewXTool = CrewXTool = CrewXTool_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(13, (0, common_1.Inject)('LAYOUT_LOADER')),
+    __param(14, (0, common_1.Inject)('LAYOUT_RENDERER')),
+    __param(15, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [ai_service_1.AIService,
+        ai_provider_service_1.AIProviderService,
+        workspace_service_1.WorkspaceService,
+        parallel_processing_service_1.ParallelProcessingService,
+        task_management_service_1.TaskManagementService,
+        result_formatter_service_1.ResultFormatterService,
+        template_service_1.TemplateService,
+        document_loader_service_1.DocumentLoaderService,
+        tool_call_service_1.ToolCallService,
+        agent_loader_service_1.AgentLoaderService,
+        remote_agent_service_1.RemoteAgentService,
+        provider_bridge_service_1.ProviderBridgeService,
+        skill_loader_service_1.SkillLoaderService,
+        crewx_sdk_1.LayoutLoader,
+        crewx_sdk_1.LayoutRenderer,
+        tracing_service_1.TracingService])
+], CrewXTool);
+//# sourceMappingURL=crewx.tool.js.map