aiexecode 1.0.66 → 1.0.68

package/payload_viewer/web_server.js

@@ -3,7 +3,6 @@ import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import OpenAI from 'openai';
-import Anthropic from '@anthropic-ai/sdk';
 function consolelog() { }
 
 const __filename = fileURLToPath(import.meta.url);
@@ -49,19 +48,6 @@ if (openaiApiKey) {
     consolelog('   Checked: process.env.OPENAI_API_KEY and ~/.aiexe/settings.json');
 }
 
-// Initialize Anthropic client
-let anthropic = null;
-const anthropicApiKey = process.env.ANTHROPIC_API_KEY || aiAgentSettings.ANTHROPIC_API_KEY;
-
-if (anthropicApiKey) {
-    anthropic = new Anthropic({
-        apiKey: anthropicApiKey,
-    });
-    consolelog('✅ Anthropic client initialized');
-} else {
-    consolelog('⚠️  Anthropic API key not found - Anthropic API testing will return mock responses');
-    consolelog('   Checked: process.env.ANTHROPIC_API_KEY and ~/.aiexe/settings.json');
-}
 
 // ID generation function
 function generateId() {
@@ -434,155 +420,6 @@ function startWebServer(port = 3300) {
         }
     });
 
-    // Anthropic API test endpoint
-    app.post('/api/test-anthropic', async (req, res) => {
-        try {
-            const payload = req.body;
-
-            // Actual Anthropic API call (if API key is available)
-            if (anthropic && anthropicApiKey) {
-                // Convert from unified format to Anthropic format
-                const messages = payload.messages || payload.input || [];
-                const convertedMessages = [];
-                let systemMessage = payload.system;
-
-                for (const msg of messages) {
-                    // Extract system messages
-                    if (msg.role === 'system') {
-                        if (msg.content && Array.isArray(msg.content)) {
-                            systemMessage = msg.content.map(c => c.text || c).join('\n');
-                        } else if (typeof msg.content === 'string') {
-                            systemMessage = msg.content;
-                        }
-                        continue; // Skip adding to messages array
-                    }
-
-                    // Handle different message formats
-                    if (msg.content && Array.isArray(msg.content)) {
-                        convertedMessages.push({
-                            role: msg.role,
-                            content: msg.content.map(c => {
-                                if (c.type === 'input_text' || c.type === 'output_text') {
-                                    return { type: 'text', text: c.text };
-                                }
-                                return c;
-                            })
-                        });
-                    } else if (typeof msg.content === 'string') {
-                        convertedMessages.push({
-                            role: msg.role,
-                            content: msg.content
-                        });
-                    } else {
-                        convertedMessages.push(msg);
-                    }
-                }
-
-                const anthropicPayload = {
-                    model: payload.model || 'claude-sonnet-4-5-20250929',
-                    max_tokens: payload.max_tokens || 8192,
-                    messages: convertedMessages,
-                    ...(systemMessage && { system: systemMessage }),
-                    ...(payload.tools && { tools: payload.tools }),
-                    ...(payload.temperature && { temperature: payload.temperature }),
-                    ...(payload.top_p && { top_p: payload.top_p })
-                };
-
-                const response = await anthropic.messages.create(anthropicPayload);
-
-                // Convert response to unified format
-                const unifiedResponse = {
-                    id: response.id,
-                    object: 'response',
-                    created_at: Math.floor(Date.now() / 1000),
-                    status: 'completed',
-                    model: response.model,
-                    output: response.content.map((item, idx) => {
-                        if (item.type === 'text') {
-                            return {
-                                id: `${response.id}_output_${idx}`,
-                                type: 'message',
-                                status: 'completed',
-                                content: [{ type: 'text', text: item.text }]
-                            };
-                        } else if (item.type === 'tool_use') {
-                            return {
-                                id: item.id,
-                                type: 'function_call',
-                                status: 'in_progress',
-                                name: item.name,
-                                arguments: JSON.stringify(item.input),
-                                call_id: item.id
-                            };
-                        }
-                        return item;
-                    }),
-                    usage: {
-                        input_tokens: response.usage.input_tokens,
-                        output_tokens: response.usage.output_tokens,
-                        total_tokens: response.usage.input_tokens + response.usage.output_tokens,
-                        ...(response.usage.cache_creation_input_tokens && { 
-                            cache_creation_input_tokens: response.usage.cache_creation_input_tokens 
-                        }),
-                        ...(response.usage.cache_read_input_tokens && { 
-                            cache_read_input_tokens: response.usage.cache_read_input_tokens 
-                        })
-                    },
-                    provider: 'anthropic',
-                    ...(response.stop_reason && { stop_reason: response.stop_reason }),
-                    ...(response.stop_sequence && { stop_sequence: response.stop_sequence })
-                };
-
-                res.json({
-                    success: true,
-                    provider: 'anthropic',
-                    response: unifiedResponse,
-                    originalPayload: payload
-                });
-            } else {
-                // Mock response if no API key
-                res.json({
-                    success: true,
-                    provider: 'anthropic',
-                    mock: true,
-                    response: {
-                        id: 'msg_mock_' + generateId(),
-                        object: 'response',
-                        created_at: Math.floor(Date.now() / 1000),
-                        status: 'completed',
-                        model: payload.model || 'claude-sonnet-4-5-20250929',
-                        provider: 'anthropic',
-                        output: [
-                            {
-                                id: 'output_mock_1',
-                                type: 'message',
-                                status: 'completed',
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: 'This is a mock response (Anthropic API key not configured)'
-                                    }
-                                ]
-                            }
-                        ],
-                        usage: {
-                            input_tokens: 10,
-                            output_tokens: 15,
-                            total_tokens: 25
-                        }
-                    },
-                    originalPayload: payload
-                });
-            }
-        } catch (error) {
-            res.status(500).json({
-                success: false,
-                provider: 'anthropic',
-                error: error.message,
-                originalPayload: req.body
-            });
-        }
-    });
 
     // Health check endpoint
     app.get('/api/health', (req, res) => {

package/src/ai_based/completion_judge.js

@@ -80,24 +80,39 @@ async function ensureCompletionJudgeConversationInitialized(templateVars = {}) {
 }
 
 function syncOrchestratorConversation() {
+    debugLog(`[syncOrchestratorConversation] START`);
     const sourceConversation = getOrchestratorConversation();
+    debugLog(`[syncOrchestratorConversation] Source conversation length: ${sourceConversation?.length || 0}`);
+    debugLog(`[syncOrchestratorConversation] Last snapshot length: ${lastOrchestratorSnapshotLength}`);
+    debugLog(`[syncOrchestratorConversation] Current completionJudge conversation length: ${completionJudgeConversation.length}`);
+
     if (!Array.isArray(sourceConversation) || !sourceConversation.length) {
+        debugLog(`[syncOrchestratorConversation] No source conversation to sync`);
         return;
     }
 
+    let syncedCount = 0;
     for (let i = lastOrchestratorSnapshotLength; i < sourceConversation.length; i++) {
         const entry = sourceConversation[i];
         if (!entry) continue;
 
         // Completion judge는 자체 system 메시지를 유지하므로, Orchestrator의 system 메시지는 제외
-        if (entry.role === "system") continue;
+        if (entry.role === "system") {
+            debugLog(`[syncOrchestratorConversation] Skipping system message at index ${i}`);
+            continue;
+        }
 
+        debugLog(`[syncOrchestratorConversation] Syncing entry ${i}: type=${entry.type}, role=${entry.role}`);
         // reasoning과 message를 모두 그대로 복사
         // ai_request.js에서 이미 reasoning-message 쌍이 유지되고 있음
         completionJudgeConversation.push(cloneMessage(entry));
+        syncedCount++;
     }
 
     lastOrchestratorSnapshotLength = sourceConversation.length;
+    debugLog(`[syncOrchestratorConversation] Synced ${syncedCount} entries, new snapshot length: ${lastOrchestratorSnapshotLength}`);
+    debugLog(`[syncOrchestratorConversation] CompletionJudge conversation now has ${completionJudgeConversation.length} entries`);
+    debugLog(`[syncOrchestratorConversation] END`);
 }
 
 function trimCompletionJudgeConversation() {
@@ -112,12 +127,31 @@ function trimCompletionJudgeConversation() {
 }
 
 async function dispatchCompletionJudgeRequest(options) {
+    debugLog(`[dispatchCompletionJudgeRequest] START`);
+
     if (!options) {
+        debugLog(`[dispatchCompletionJudgeRequest] ERROR - options not initialized`);
         throw new Error('Completion judge request options not initialized.');
     }
 
+    debugLog(`[dispatchCompletionJudgeRequest] Options - model: ${options.model}, taskName: ${options.taskName}`);
+
+    let attemptCount = 0;
     while (true) {
+        attemptCount++;
+        debugLog(`[dispatchCompletionJudgeRequest] Attempt ${attemptCount}`);
+
         const { model, isGpt5Model, taskName } = options;
+
+        // Conversation 구조 분석
+        const conversationTypes = {};
+        completionJudgeConversation.forEach(entry => {
+            const type = entry?.type || entry?.role || 'unknown';
+            conversationTypes[type] = (conversationTypes[type] || 0) + 1;
+        });
+        debugLog(`[dispatchCompletionJudgeRequest] Conversation structure: ${JSON.stringify(conversationTypes)}`);
+        debugLog(`[dispatchCompletionJudgeRequest] Total conversation entries: ${completionJudgeConversation.length}`);
+
         const requestPayload = {
             model,
             input: completionJudgeConversation,
@@ -140,23 +174,41 @@ async function dispatchCompletionJudgeRequest(options) {
             requestPayload.temperature = 0;
         }
 
+        // 토큰 추정
+        const conversationJson = JSON.stringify(completionJudgeConversation);
+        const estimatedTokens = Math.ceil(conversationJson.length / 4);
+        debugLog(`[dispatchCompletionJudgeRequest] Estimated tokens: ${estimatedTokens} (conversation size: ${conversationJson.length} bytes)`);
+
+        debugLog(`[dispatchCompletionJudgeRequest] Sending API request...`);
         try {
-            return await request(taskName, requestPayload);
+            const response = await request(taskName, requestPayload);
+            debugLog(`[dispatchCompletionJudgeRequest] API request successful`);
+            debugLog(`[dispatchCompletionJudgeRequest] Response output_text length: ${response?.output_text?.length || 0}`);
+            debugLog(`[dispatchCompletionJudgeRequest] END - success`);
+            return response;
         } catch (error) {
+            debugLog(`[dispatchCompletionJudgeRequest] API request failed: ${error.message}`);
+            debugLog(`[dispatchCompletionJudgeRequest] Error name: ${error.name}, type: ${error?.constructor?.name}`);
+
             // AbortError는 즉시 전파 (세션 중단)
             if (error.name === 'AbortError') {
-                debugLog(`[dispatchCompletionJudgeRequest] Request aborted by user`);
+                debugLog(`[dispatchCompletionJudgeRequest] Request aborted by user, propagating AbortError`);
                 throw error;
             }
 
             if (!isContextWindowError(error)) {
+                debugLog(`[dispatchCompletionJudgeRequest] Not a context window error, re-throwing`);
                 throw error;
             }
 
+            debugLog(`[dispatchCompletionJudgeRequest] Context window error detected, attempting to trim...`);
             const trimmed = trimCompletionJudgeConversation();
+            debugLog(`[dispatchCompletionJudgeRequest] Trim result: ${trimmed}, new conversation length: ${completionJudgeConversation.length}`);
             if (!trimmed) {
+                debugLog(`[dispatchCompletionJudgeRequest] Cannot trim further, re-throwing error`);
                 throw error;
             }
+            debugLog(`[dispatchCompletionJudgeRequest] Retrying with trimmed conversation...`);
         }
     }
 }
@@ -186,52 +238,91 @@ export function restoreCompletionJudgeConversation(savedConversation, savedSnaps
  * @returns {Promise<{shouldComplete: boolean, whatUserShouldSay: string}>}
  */
 export async function judgeMissionCompletion(templateVars = {}) {
+    debugLog('');
+    debugLog('========================================');
+    debugLog('=== judgeMissionCompletion START =======');
+    debugLog('========================================');
     debugLog(`[judgeMissionCompletion] Called with templateVars: ${JSON.stringify(Object.keys(templateVars))}`);
+    if (templateVars.what_user_requests) {
+        debugLog(`[judgeMissionCompletion] what_user_requests: ${templateVars.what_user_requests.substring(0, 200)}`);
+    }
 
     try {
+        debugLog(`[judgeMissionCompletion] Creating request options...`);
         const requestOptions = await createCompletionJudgeRequestOptions();
+        debugLog(`[judgeMissionCompletion] Request options - model: ${requestOptions.model}, isGpt5Model: ${requestOptions.isGpt5Model}`);
 
         // Completion judge 자체 system 메시지 초기화 (템플릿 변수 전달)
+        debugLog(`[judgeMissionCompletion] Initializing completion judge conversation...`);
         await ensureCompletionJudgeConversationInitialized(templateVars);
+        debugLog(`[judgeMissionCompletion] Conversation initialized, length: ${completionJudgeConversation.length}`);
+
         // Orchestrator의 대화 내용 동기화 (system 메시지 제외)
+        debugLog(`[judgeMissionCompletion] Syncing orchestrator conversation...`);
         syncOrchestratorConversation();
+        debugLog(`[judgeMissionCompletion] Sync complete, conversation length: ${completionJudgeConversation.length}`);
 
         debugLog(`[judgeMissionCompletion] Sending request with ${completionJudgeConversation.length} conversation entries`);
 
         const response = await dispatchCompletionJudgeRequest(requestOptions);
 
         debugLog(`[judgeMissionCompletion] Received response, parsing output_text`);
+        debugLog(`[judgeMissionCompletion] Raw output_text: ${response.output_text?.substring(0, 500)}`);
 
         // Completion judge 자신의 응답은 히스토리에 추가하지 않음 (Orchestrator와 동일한 히스토리 유지)
         // 대화 기록 초기화 (다음 판단을 위해)
+        debugLog(`[judgeMissionCompletion] Resetting completion judge conversation...`);
         resetCompletionJudgeConversation();
 
         try {
             const judgment = JSON.parse(response.output_text);
-            debugLog(`[judgeMissionCompletion] Parsed judgment: ${JSON.stringify(judgment)}`);
+            debugLog(`[judgeMissionCompletion] Parsed judgment successfully`);
+            debugLog(`[judgeMissionCompletion] should_complete: ${judgment.should_complete}`);
+            debugLog(`[judgeMissionCompletion] whatUserShouldSay: ${judgment.whatUserShouldSay}`);
 
-            return {
+            const result = {
                 shouldComplete: judgment.should_complete === true,
                 whatUserShouldSay: judgment.whatUserShouldSay || ""
             };
+
+            debugLog('========================================');
+            debugLog('=== judgeMissionCompletion END =========');
+            debugLog(`=== Result: shouldComplete=${result.shouldComplete}, whatUserShouldSay="${result.whatUserShouldSay.substring(0, 100)}"`);
+            debugLog('========================================');
+            debugLog('');
+
+            return result;
         } catch (parseError) {
             debugLog(`[judgeMissionCompletion] Parse error: ${parseError.message}`);
+            debugLog(`[judgeMissionCompletion] Failed to parse output_text as JSON`);
             throw new Error('Completion judge response did not include valid JSON output_text.');
         }
 
     } catch (error) {
         debugLog(`[judgeMissionCompletion] ERROR: ${error.message}, error.name: ${error.name}`);
+        debugLog(`[judgeMissionCompletion] Error stack: ${error.stack}`);
 
         // 에러 발생 시 대화 기록 초기화
+        debugLog(`[judgeMissionCompletion] Resetting completion judge conversation due to error...`);
         resetCompletionJudgeConversation();
 
         // AbortError는 즉시 전파 (세션 중단)
         if (error.name === 'AbortError') {
             debugLog(`[judgeMissionCompletion] AbortError detected, propagating to caller`);
+            debugLog('========================================');
+            debugLog('=== judgeMissionCompletion END (ABORT) =');
+            debugLog('========================================');
+            debugLog('');
             throw error;
         }
 
         // 다른 에러 발생 시 안전하게 계속 진행
+        debugLog(`[judgeMissionCompletion] Non-abort error, returning safe default (shouldComplete=false)`);
+        debugLog('========================================');
+        debugLog('=== judgeMissionCompletion END (ERROR) =');
+        debugLog('========================================');
+        debugLog('');
+
         return {
             shouldComplete: false,
             whatUserShouldSay: ""

package/src/ai_based/orchestrator.js

@@ -17,8 +17,6 @@ dotenv.config({ quiet: true });
 
 const debugLog = createDebugLogger('orchestrator.log', 'orchestrator');
 
-function consolelog() { }
-
 const orchestratorConversation = [];
 let orchestratorRequestOptions = null;
 
@@ -277,15 +275,31 @@ function trimOrchestratorConversation() {
 }
 
 async function dispatchOrchestratorRequest({ toolChoice }) {
+    debugLog(`[dispatchOrchestratorRequest] START - toolChoice: ${toolChoice}`);
+
     if (!orchestratorRequestOptions) {
+        debugLog(`[dispatchOrchestratorRequest] ERROR - orchestratorRequestOptions not initialized`);
         throw new Error('Orchestrator request options not initialized.');
     }
 
+    debugLog(`[dispatchOrchestratorRequest] Options - model: ${orchestratorRequestOptions.model}, tools count: ${orchestratorRequestOptions.tools?.length || 0}`);
+
+    let attemptCount = 0;
     while (true) {
+        attemptCount++;
+        debugLog(`[dispatchOrchestratorRequest] Attempt ${attemptCount} - starting cleanup...`);
         cleanupOrchestratorConversation();
 
         debugLog(`[dispatchOrchestratorRequest] Conversation has ${orchestratorConversation.length} entries`);
 
+        // Conversation 구조 분석
+        const conversationTypes = {};
+        orchestratorConversation.forEach(entry => {
+            const type = entry?.type || entry?.role || 'unknown';
+            conversationTypes[type] = (conversationTypes[type] || 0) + 1;
+        });
+        debugLog(`[dispatchOrchestratorRequest] Conversation structure: ${JSON.stringify(conversationTypes)}`);
+
         // function_call_output 항목들 확인
         const functionCallOutputs = orchestratorConversation.filter(item => item.type === 'function_call_output');
         debugLog(`[dispatchOrchestratorRequest] Found ${functionCallOutputs.length} function_call_output entries`);
@@ -309,31 +323,64 @@ async function dispatchOrchestratorRequest({ toolChoice }) {
             requestConfig.temperature = 0;
         }
 
-        debugLog(`[dispatchOrchestratorRequest] About to send request with ${orchestratorConversation.length} conversation entries`);
+        debugLog(`[dispatchOrchestratorRequest] Request config - model: ${model}, tool_choice: ${requestConfig.tool_choice}, tools: ${tools.length}, conversation entries: ${orchestratorConversation.length}`);
+
+        // Conversation 토큰 추정 (대략적)
+        const conversationJson = JSON.stringify(orchestratorConversation);
+        const estimatedTokens = Math.ceil(conversationJson.length / 4); // 대략 4 chars = 1 token
+        debugLog(`[dispatchOrchestratorRequest] Estimated tokens: ${estimatedTokens} (conversation size: ${conversationJson.length} bytes)`);
+
+        debugLog(`[dispatchOrchestratorRequest] Sending API request...`);
 
         try {
             const response = await request(taskName, requestConfig);
+            debugLog(`[dispatchOrchestratorRequest] API request successful`);
+            debugLog(`[dispatchOrchestratorRequest] Response outputs: ${response?.output?.length || 0}`);
+            if (response?.output) {
+                const outputTypes = {};
+                response.output.forEach(o => {
+                    const type = o?.type || 'unknown';
+                    outputTypes[type] = (outputTypes[type] || 0) + 1;
+                });
+                debugLog(`[dispatchOrchestratorRequest] Response output types: ${JSON.stringify(outputTypes)}`);
+            }
+            debugLog(`[dispatchOrchestratorRequest] END - success`);
             // consolelog(JSON.stringify(response, null, 2));
             return response;
         } catch (error) {
+            debugLog(`[dispatchOrchestratorRequest] API request failed: ${error.message}`);
+            debugLog(`[dispatchOrchestratorRequest] Error type: ${error?.constructor?.name}, code: ${error?.code}, status: ${error?.status}`);
+
             if (!isContextWindowError(error)) {
+                debugLog(`[dispatchOrchestratorRequest] Not a context window error, re-throwing`);
                 throw error;
             }
 
+            debugLog(`[dispatchOrchestratorRequest] Context window error detected, attempting to trim conversation...`);
             const trimmed = trimOrchestratorConversation();
+            debugLog(`[dispatchOrchestratorRequest] Trim result: ${trimmed}, new conversation length: ${orchestratorConversation.length}`);
             if (!trimmed) {
+                debugLog(`[dispatchOrchestratorRequest] Cannot trim further, re-throwing error`);
                 throw error;
             }
+            debugLog(`[dispatchOrchestratorRequest] Retrying with trimmed conversation...`);
         }
     }
 }
 
 export async function continueOrchestratorConversation() {
+    debugLog(`[continueOrchestratorConversation] START`);
+    debugLog(`[continueOrchestratorConversation] Current conversation length: ${orchestratorConversation.length}`);
+
     // 매번 최신 프롬프트를 반영
     await ensureConversationInitialized();
+    debugLog(`[continueOrchestratorConversation] Conversation initialized/updated`);
 
     const response = await dispatchOrchestratorRequest({ toolChoice: "auto" });
+    debugLog(`[continueOrchestratorConversation] Received response, appending to conversation...`);
     appendResponseToConversation(response);
+    debugLog(`[continueOrchestratorConversation] Conversation length after append: ${orchestratorConversation.length}`);
+    debugLog(`[continueOrchestratorConversation] END`);
     return response;
 }
 // 쉘스크립트 코딩 규칙:
@@ -347,9 +394,16 @@ export async function continueOrchestratorConversation() {
 
 // 탐색 기반으로 현재 상황을 분석하고, 다음에 취할 행동을 AI에게 결정받습니다.
 export async function orchestrateMission({ improvement_points = '', mcpToolSchemas = [], isAutoGenerated = false }) {
+    debugLog('');
+    debugLog('========================================');
+    debugLog('===== orchestrateMission START =========');
+    debugLog('========================================');
+
     const taskName = 'orchestrator';
 
     debugLog(`[orchestrateMission] Called with improvement_points: "${improvement_points?.substring(0, 100) || '(empty)'}", isAutoGenerated: ${isAutoGenerated}`);
+    debugLog(`[orchestrateMission] improvement_points length: ${improvement_points?.length || 0} characters`);
+    debugLog(`[orchestrateMission] mcpToolSchemas count: ${mcpToolSchemas.length}`);
     const improvementPointsText = typeof improvement_points === 'string' && improvement_points.trim().length ? improvement_points : '';
     debugLog(`[orchestrateMission] improvementPointsText after processing: "${improvementPointsText.substring(0, 100) || '(empty)'}"`);
     if (isAutoGenerated) {
@@ -359,6 +413,7 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
 
     // Python 사용 가능 여부 확인
     const hasPython = process.app_custom?.systemInfo?.commands?.hasPython || false;
+    debugLog(`[orchestrateMission] Python available: ${hasPython}`);
 
     // 설정 로드
     const settings = await loadSettings();
@@ -393,7 +448,10 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
     }
 
     // MCP Tools (동적으로 추가)
+    debugLog(`[orchestrateMission] Adding ${mcpToolSchemas.length} MCP tools to available tools`);
     tools.push(...mcpToolSchemas);
+    debugLog(`[orchestrateMission] Total tools after MCP: ${tools.length}`);
+
     // Planner가 선언한 도구 이름을 실제 함수 스키마로 연결해, LLM이 지시한 작업이 즉시 실행되도록 합니다.
     tools.forEach(tool => {
         tool.type = "function";
@@ -401,6 +459,7 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
 
     const model = await getModelForProvider();
     const isGpt5Model = model.startsWith("gpt-5");
+    debugLog(`[orchestrateMission] Using model: ${model}, isGpt5Model: ${isGpt5Model}`);
 
     orchestratorRequestOptions = {
         model,
@@ -409,8 +468,10 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
         taskName,
         parallel_tool_calls: true
     };
+    debugLog(`[orchestrateMission] orchestratorRequestOptions configured with ${tools.length} tools`);
 
     await ensureConversationInitialized();
+    debugLog(`[orchestrateMission] Conversation initialized, current length: ${orchestratorConversation.length}`);
 
     debugLog(`[orchestrateMission] Adding user message to conversation: "${improvementPointsText.substring(0, 100)}"`);
     const userMessage = {
@@ -432,8 +493,15 @@ export async function orchestrateMission({ improvement_points = '', mcpToolSchem
     orchestratorConversation.push(userMessage);
     debugLog(`[orchestrateMission] Conversation length after adding user message: ${orchestratorConversation.length}`);
 
+    debugLog(`[orchestrateMission] Dispatching orchestrator request with toolChoice: required`);
     const response = await dispatchOrchestratorRequest({ toolChoice: "required" });
+    debugLog(`[orchestrateMission] Received response, appending to conversation...`);
     appendResponseToConversation(response);
     debugLog(`[orchestrateMission] Conversation length after response: ${orchestratorConversation.length}`);
+
+    debugLog('========================================');
+    debugLog('===== orchestrateMission END ===========');
+    debugLog('========================================');
+    debugLog('');
     return response;
 }

package/src/ai_based/pip_package_installer.js

@@ -1,9 +1,11 @@
 import { checkValidPackageName } from "./pip_package_lookup.js";
 import { installPythonPackage, isPackageInstalled, analyzeImports } from "../system/code_executer.js";
+import { createDebugLogger } from "../util/debug_log.js";
+
+const debugLog = createDebugLogger('pip_package_installer.log', 'pip_package_installer');
 
 // 이 파일은 코드에서 필요로 하는 파이썬 패키지를 확인하고 자동으로 설치합니다.
 // Code Executer가 스크립트를 실행할 때 패키지 누락 오류가 나지 않도록 Orchestrator 실행 이전에 환경을 준비합니다.
-function consolelog() { }
 
 // 하나의 파일을 분석해 필요한 외부 패키지를 찾아 설치합니다.
 export async function installRequiredPackages(filePath) {
@@ -62,34 +64,34 @@ export async function installRequiredPackages(filePath) {
 
 export async function installPackageList(packageList) {
     try {
-        consolelog(`\n=== Installing package list ===`);
-        consolelog("Packages to install:", packageList);
+        debugLog(`\n=== Installing package list ===`);
+        debugLog("Packages to install:", packageList);
 
         const validPackageNames = await checkValidPackageName(packageList);
-        consolelog("Valid package names:", validPackageNames);
+        debugLog("Valid package names:", validPackageNames);
 
         const installResults = [];
         const alreadyInstalled = [];
         const failedInstalls = [];
 
         for (const packageName of validPackageNames) {
-            consolelog(`\n--- Processing package: ${packageName} ---`);
+            debugLog(`\n--- Processing package: ${packageName} ---`);
 
             const isInstalled = await isPackageInstalled(packageName);
             if (isInstalled) {
-                consolelog(`[SKIP] ${packageName} is already installed`);
+                debugLog(`[SKIP] ${packageName} is already installed`);
                 alreadyInstalled.push(packageName);
                 continue;
             }
 
-            consolelog(`Installing ${packageName}...`);
+            debugLog(`Installing ${packageName}...`);
             const installSuccess = await installPythonPackage(packageName);
 
             if (installSuccess) {
-                consolelog(`[OK] Successfully installed ${packageName}`);
+                debugLog(`[OK] Successfully installed ${packageName}`);
                 installResults.push(packageName);
             } else {
-                consolelog(`[FAIL] Failed to install ${packageName}`);
+                debugLog(`[FAIL] Failed to install ${packageName}`);
                 failedInstalls.push(packageName);
             }
         }
@@ -120,8 +122,8 @@ export async function installPackageList(packageList) {
 
 export async function installRequiredPackagesForFiles(filePaths) {
     try {
-        consolelog(`\n=== Analyzing multiple files ===`);
-        consolelog("Files to analyze:", filePaths);
+        debugLog(`\n=== Analyzing multiple files ===`);
+        debugLog("Files to analyze:", filePaths);
 
         const allExternalPackages = new Set();
         const analysisResults = [];
@@ -142,7 +144,7 @@ export async function installRequiredPackagesForFiles(filePaths) {
         }
 
         const uniquePackages = Array.from(allExternalPackages);
-        consolelog("All unique external packages:", uniquePackages);
+        debugLog("All unique external packages:", uniquePackages);
 
         if (uniquePackages.length === 0) {
             return {