aiexecode 1.0.94 → 1.0.127

package/src/LLMClient/errors.js

@@ -176,15 +176,41 @@ export function normalizeError(error, provider) {
   }
 
   // Anthropic SDK error (check BEFORE OpenAI SDK error, as both have error.status && error.error)
-  if (provider === 'claude' && error.status) {
+  // Z.AI uses Anthropic SDK so handle similarly
+  if ((provider === 'claude' || provider === 'zai') && error.status) {
     // Parse Claude error from error.error object (Anthropic SDK provides parsed error)
     let errorType = ERROR_TYPE_MAP[error.status] || 'api_error';
     let code = null;
-    let message = error.message || 'Claude API error';
+    let message = error.message || (provider === 'zai' ? 'Z.AI API error' : 'Claude API error');
 
+    // Z.AI specific error format: { detail: [{ type, loc, msg, ... }] }
+    if (error.error && error.error.detail && Array.isArray(error.error.detail)) {
+      const zaiError = error.error.detail[0];
+      if (zaiError) {
+        code = zaiError.type || null;
+        message = zaiError.msg || message;
+
+        // Map Z.AI error types
+        if (zaiError.type === 'json_invalid') {
+          errorType = 'invalid_request_error';
+        }
+      }
+    }
+    // Z.AI auth error format: { error: { message, type: "401" } }
+    else if (error.error && error.error.type === '401') {
+      errorType = 'authentication_error';
+      code = 'invalid_api_key';
+      message = error.error.message || 'Invalid or expired API key';
+    }
+    // Z.AI context exceeded format: { error: { code: "1210", message: "..." } }
+    else if (error.error && (error.error.code === '1210' || error.error.code === 1210)) {
+      errorType = 'invalid_request_error';
+      code = 'context_length_exceeded';
+      message = error.error.message || 'Context length exceeded';
+    }
     // Anthropic SDK provides error.error object with structure:
     // { type: 'error', error: { type: 'not_found_error', message: '...' } }
-    if (error.error && error.error.error) {
+    else if (error.error && error.error.error) {
       const claudeError = error.error.error;
 
       if (claudeError.type) {
@@ -220,7 +246,7 @@ export function normalizeError(error, provider) {
         param: null,
         code: code,
         status: error.status,
-        provider: 'claude',
+        provider: provider,
         originalError: error
       }
     );

package/src/LLMClient/index.js

@@ -21,6 +21,11 @@ export {
   convertOllamaResponseToResponsesFormat
 } from './converters/responses-to-ollama.js';
 
+export {
+  convertResponsesRequestToZaiFormat,
+  convertZaiResponseToResponsesFormat
+} from './converters/responses-to-zai.js';
+
 // Export error classes
 export {
   LLMError,

package/src/ai_based/completion_judge.js

@@ -1,10 +1,9 @@
 import dotenv from "dotenv";
-import { request, shouldRetryWithTrim, getModelForProvider } from "../system/ai_request.js";
+import { request, getModelForProvider } from "../system/ai_request.js";
 import { getOrchestratorConversation } from "./orchestrator.js";
 import { createSystemMessage } from "../util/prompt_loader.js";
 import { createDebugLogger } from "../util/debug_log.js";
 import { getCurrentTodos } from "../system/session_memory.js";
-import { cleanupOrphanOutputs, trimConversation } from "../system/conversation_trimmer.js";
 
 dotenv.config({ quiet: true });
 
@@ -30,16 +29,6 @@ export const completionJudgmentSchema = {
     strict: true
 };
 
-// systemMessage는 judgeMissionCompletion 호출 시 동적으로 생성됨
-
-const completionJudgeConversation = [];
-let lastOrchestratorSnapshotLength = 0;
-
-function cloneMessage(message) {
-    return JSON.parse(JSON.stringify(message));
-}
-
-
 async function createCompletionJudgeRequestOptions() {
     const model = await getModelForProvider();
     return {
@@ -50,76 +39,150 @@ async function createCompletionJudgeRequestOptions() {
 }
 
 /**
- * Completion judge conversation을 초기화하거나 시스템 프롬프트를 업데이트합니다.
- * 매 요청마다 프롬프트 파일을 새로 읽어서 변경사항을 즉시 반영합니다.
+ * Orchestrator 대화에서 요약된 컨텍스트를 추출합니다.
+ * 전체 대화 대신 핵심 정보만 텍스트로 요약하여 반환합니다.
+ *
+ * @returns {Object} { toolExecutionSummary: string, lastAssistantMessage: string }
  */
-async function ensureCompletionJudgeConversationInitialized(templateVars = {}) {
-    // 매번 최신 시스템 프롬프트를 로드
-    const systemMessage = await createSystemMessage("completion_judge.txt", templateVars);
-
-    const systemMessageEntry = {
-        role: "system",
-        content: [
-            {
-                type: "input_text",
-                text: systemMessage.content
+function extractSummarizedContext() {
+    debugLog(`[extractSummarizedContext] START`);
+    const sourceConversation = getOrchestratorConversation();
+
+    if (!Array.isArray(sourceConversation) || !sourceConversation.length) {
+        debugLog(`[extractSummarizedContext] No source conversation`);
+        return { toolExecutionSummary: '', lastAssistantMessage: '' };
+    }
+
+    debugLog(`[extractSummarizedContext] Source conversation length: ${sourceConversation.length}`);
+
+    // 도구 실행 결과 추출
+    const toolExecutions = [];
+    const functionCalls = new Map(); // call_id -> { name, arguments }
+
+    for (const entry of sourceConversation) {
+        if (!entry) continue;
+
+        // function_call 정보 수집
+        if (entry.type === 'function_call') {
+            functionCalls.set(entry.call_id || entry.id, {
+                name: entry.name,
+                arguments: entry.arguments
+            });
+        }
+
+        // function_call_output에서 결과 추출
+        if (entry.type === 'function_call_output') {
+            const callId = entry.call_id;
+            const callInfo = functionCalls.get(callId);
+            const toolName = callInfo?.name || 'unknown';
+
+            let success = true;
+            let exitCode = null;
+            let errorMessage = '';
+
+            try {
+                const output = JSON.parse(entry.output || '{}');
+                if (output.exit_code !== undefined) {
+                    exitCode = output.exit_code;
+                    success = exitCode === 0;
+                }
+                if (output.operation_successful === false) {
+                    success = false;
+                }
+                if (output.error_message) {
+                    errorMessage = output.error_message;
+                }
+                if (output.stderr && output.stderr.trim()) {
+                    errorMessage = output.stderr.substring(0, 100);
+                }
+            } catch (e) {
+                // JSON 파싱 실패 시 무시
+            }
+
+            // 인자에서 주요 정보 추출 (파일 경로 등)
+            let targetInfo = '';
+            if (callInfo?.arguments) {
+                try {
+                    const args = JSON.parse(callInfo.arguments);
+                    if (args.file_path) targetInfo = ` (${args.file_path})`;
+                    else if (args.path) targetInfo = ` (${args.path})`;
+                    else if (args.script) targetInfo = ` (bash)`;
+                    else if (args.code) targetInfo = ` (python)`;
+                } catch (e) {}
             }
-        ]
-    };
 
-    // conversation이 비어있으면 새로 추가
-    if (!completionJudgeConversation.length) {
-        completionJudgeConversation.push(systemMessageEntry);
-    } else {
-        // conversation이 있으면 첫 번째 system 메시지를 업데이트
-        if (completionJudgeConversation[0]?.role === "system") {
-            completionJudgeConversation[0] = systemMessageEntry;
-        } else {
-            // system 메시지가 맨 앞에 없으면 추가
-            completionJudgeConversation.unshift(systemMessageEntry);
+            const status = success ? '✓' : '✗';
+            const exitCodeStr = exitCode !== null ? ` [exit=${exitCode}]` : '';
+            const errorStr = !success && errorMessage ? ` - ${errorMessage}` : '';
+
+            toolExecutions.push(`${status} ${toolName}${targetInfo}${exitCodeStr}${errorStr}`);
         }
     }
+
+    // 마지막 assistant 메시지 추출
+    let lastAssistantMessage = '';
+    for (let i = sourceConversation.length - 1; i >= 0; i--) {
+        const entry = sourceConversation[i];
+        if (entry?.type === 'message' && entry?.role === 'assistant') {
+            const textContent = entry.content?.find(c => c.type === 'output_text');
+            if (textContent?.text) {
+                lastAssistantMessage = textContent.text;
+                break;
+            }
+        }
+    }
+
+    const toolExecutionSummary = toolExecutions.length > 0
+        ? toolExecutions.join('\n')
+        : '(도구 실행 없음)';
+
+    debugLog(`[extractSummarizedContext] Tool executions: ${toolExecutions.length}`);
+    debugLog(`[extractSummarizedContext] Last assistant message length: ${lastAssistantMessage.length}`);
+    debugLog(`[extractSummarizedContext] END`);
+
+    return {
+        toolExecutionSummary,
+        lastAssistantMessage
+    };
 }
 
-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}`);
+/**
+ * 요약된 컨텍스트를 사용자 메시지로 포맷팅합니다.
+ */
+function buildContextMessage(mission, summarizedContext, currentTodos) {
+    const parts = [];
 
-    if (!Array.isArray(sourceConversation) || !sourceConversation.length) {
-        debugLog(`[syncOrchestratorConversation] No source conversation to sync`);
-        return;
-    }
+    parts.push(`## 원래 사용자 요청\n${mission}`);
 
-    let syncedCount = 0;
-    for (let i = lastOrchestratorSnapshotLength; i < sourceConversation.length; i++) {
-        const entry = sourceConversation[i];
-        if (!entry) continue;
+    parts.push(`\n## 실행된 도구들\n${summarizedContext.toolExecutionSummary}`);
 
-        // Completion judge는 자체 system 메시지를 유지하므로, Orchestrator의 system 메시지는 제외
-        if (entry.role === "system") {
-            debugLog(`[syncOrchestratorConversation] Skipping system message at index ${i}`);
-            continue;
+    if (summarizedContext.lastAssistantMessage) {
+        // 너무 길면 truncate
+        const maxLength = 2000;
+        let assistantMsg = summarizedContext.lastAssistantMessage;
+        if (assistantMsg.length > maxLength) {
+            assistantMsg = assistantMsg.substring(0, maxLength) + '\n... (truncated)';
         }
+        parts.push(`\n## 에이전트의 마지막 응답\n${assistantMsg}`);
+    }
 
-        debugLog(`[syncOrchestratorConversation] Syncing entry ${i}: type=${entry.type}, role=${entry.role}`);
-        // reasoning과 message를 모두 그대로 복사
-        // ai_request.js에서 이미 reasoning-message 쌍이 유지되고 있음
-        completionJudgeConversation.push(cloneMessage(entry));
-        syncedCount++;
+    if (currentTodos && currentTodos.length > 0) {
+        const todoList = currentTodos.map((todo, index) => {
+            const statusIcon = todo.status === 'completed' ? '✓' :
+                              todo.status === 'in_progress' ? '→' : '○';
+            return `${index + 1}. [${statusIcon}] ${todo.content} (${todo.status})`;
+        }).join('\n');
+        parts.push(`\n## 현재 TODO 상태\n${todoList}`);
     }
 
-    lastOrchestratorSnapshotLength = sourceConversation.length;
-    debugLog(`[syncOrchestratorConversation] Synced ${syncedCount} entries, new snapshot length: ${lastOrchestratorSnapshotLength}`);
-    debugLog(`[syncOrchestratorConversation] CompletionJudge conversation now has ${completionJudgeConversation.length} entries`);
-    debugLog(`[syncOrchestratorConversation] END`);
+    return parts.join('\n');
 }
 
-// 대화 cleanup 및 trim 함수는 conversation_trimmer 모듈에서 가져옴
-
-async function dispatchCompletionJudgeRequest(options) {
+/**
+ * 독립적인 컨텍스트로 completion judge 요청을 보냅니다.
+ * Orchestrator 대화를 복사하지 않고, 요약된 정보만 전달합니다.
+ */
+async function dispatchCompletionJudgeRequest(options, summarizedContext) {
     debugLog(`[dispatchCompletionJudgeRequest] START`);
 
     if (!options) {
@@ -127,110 +190,89 @@ async function dispatchCompletionJudgeRequest(options) {
         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} - starting cleanup...`);
-        cleanupOrphanOutputs(completionJudgeConversation);
-
-        debugLog(`[dispatchCompletionJudgeRequest] Conversation has ${completionJudgeConversation.length} entries`);
-
-        // 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)}`);
-
-        // function_call_output 항목들 확인
-        const functionCallOutputs = completionJudgeConversation.filter(item => item.type === 'function_call_output');
-        debugLog(`[dispatchCompletionJudgeRequest] Found ${functionCallOutputs.length} function_call_output entries`);
-
-        functionCallOutputs.forEach((item, index) => {
-            debugLog(`[dispatchCompletionJudgeRequest] function_call_output[${index}] - call_id: ${item.call_id}, output length: ${item.output?.length || 0}, output preview: ${item.output?.substring(0, 200)}`);
-        });
-
-        const { model, isGpt5Model, taskName } = options;
-
-        const requestPayload = {
-            model,
-            input: completionJudgeConversation,
-            text: {
-                format: {
-                    type: "json_schema",
-                    name: completionJudgmentSchema.name,
-                    strict: completionJudgmentSchema.strict,
-                    schema: completionJudgmentSchema.schema
-                }
-            },
-            reasoning: {},
-            tool_choice: "none",
-            tools: [],
-            top_p: 1,
-            store: true
-        };
+    const { model, isGpt5Model, taskName, systemMessage, mission, currentTodos } = options;
+    debugLog(`[dispatchCompletionJudgeRequest] Options - model: ${model}, taskName: ${taskName}`);
 
-        if (!isGpt5Model) {
-            requestPayload.temperature = 0;
+    // 독립적인 대화 구성 (도구 호출 기록 없음)
+    const conversation = [
+        // System 메시지
+        {
+            role: "system",
+            content: [{ type: "input_text", text: systemMessage }]
+        },
+        // User 메시지: 요약된 컨텍스트
+        {
+            role: "user",
+            content: [{
+                type: "input_text",
+                text: buildContextMessage(mission, summarizedContext, currentTodos)
+            }]
         }
+    ];
 
-        // 토큰 추정
-        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 {
-            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, propagating AbortError`);
-                throw error;
+    const requestPayload = {
+        model,
+        input: conversation,
+        text: {
+            format: {
+                type: "json_schema",
+                name: completionJudgmentSchema.name,
+                strict: completionJudgmentSchema.strict,
+                schema: completionJudgmentSchema.schema
             }
+        },
+        reasoning: {},
+        tool_choice: "none",
+        tools: [],
+        top_p: 1,
+        store: true
+    };
 
-            if (!shouldRetryWithTrim(error)) {
-                debugLog(`[dispatchCompletionJudgeRequest] Not recoverable by trimming, re-throwing`);
-                throw error;
-            }
+    if (!isGpt5Model) {
+        requestPayload.temperature = 0;
+    }
 
-            debugLog(`[dispatchCompletionJudgeRequest] Recoverable error detected, attempting to trim...`);
-            const trimmed = trimConversation(completionJudgeConversation);
-            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...`);
+    // 토큰 추정
+    const conversationJson = JSON.stringify(conversation);
+    const estimatedTokens = Math.ceil(conversationJson.length / 4);
+    debugLog(`[dispatchCompletionJudgeRequest] Estimated tokens: ${estimatedTokens} (conversation size: ${conversationJson.length} bytes)`);
+
+    const apiStartTime = Date.now();
+    debugLog(`[dispatchCompletionJudgeRequest] >>>>> Sending API request at ${new Date(apiStartTime).toISOString()}...`);
+
+    try {
+        const response = await request(taskName, requestPayload);
+        const apiDuration = Date.now() - apiStartTime;
+        debugLog(`[dispatchCompletionJudgeRequest] <<<<< API request successful in ${apiDuration}ms`);
+        debugLog(`[dispatchCompletionJudgeRequest] Response output_text length: ${response?.output_text?.length || 0}`);
+        debugLog(`[dispatchCompletionJudgeRequest] END - success`);
+        return response;
+    } catch (error) {
+        const apiDuration = Date.now() - apiStartTime;
+        debugLog(`[dispatchCompletionJudgeRequest] <<<<< API request FAILED after ${apiDuration}ms: ${error.message}`);
+        debugLog(`[dispatchCompletionJudgeRequest] Error name: ${error.name}, type: ${error?.constructor?.name}`);
+
+        // AbortError는 즉시 전파 (세션 중단)
+        if (error.name === 'AbortError') {
+            debugLog(`[dispatchCompletionJudgeRequest] Request aborted by user, propagating AbortError`);
+            throw error;
         }
+
+        throw error;
     }
 }
 
+// Legacy exports (하위 호환성 - 실제로는 더 이상 사용하지 않음)
 export function resetCompletionJudgeConversation() {
-    completionJudgeConversation.length = 0;
-    lastOrchestratorSnapshotLength = 0;
+    // No-op: 독립 컨텍스트 방식에서는 대화를 유지하지 않음
 }
 
 export function getCompletionJudgeConversation() {
-    return completionJudgeConversation;
+    return [];
 }
 
 export function restoreCompletionJudgeConversation(savedConversation, savedSnapshotLength = 0) {
-    completionJudgeConversation.length = 0;
-    if (Array.isArray(savedConversation)) {
-        completionJudgeConversation.push(...savedConversation);
-    }
-    lastOrchestratorSnapshotLength = savedSnapshotLength;
+    // No-op: 독립 컨텍스트 방식에서는 복원할 대화가 없음
 }
 
 /**
@@ -246,49 +288,77 @@ export async function judgeMissionCompletion(templateVars = {}) {
     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)}`);
+
+    const mission = templateVars.what_user_requests || '';
+    if (mission) {
+        debugLog(`[judgeMissionCompletion] what_user_requests: ${mission.substring(0, 200)}`);
     }
 
     try {
         debugLog(`[judgeMissionCompletion] Creating request options...`);
-        const requestOptions = await createCompletionJudgeRequestOptions();
-        debugLog(`[judgeMissionCompletion] Request options - model: ${requestOptions.model}, isGpt5Model: ${requestOptions.isGpt5Model}`);
+        const baseOptions = await createCompletionJudgeRequestOptions();
+        debugLog(`[judgeMissionCompletion] Request options - model: ${baseOptions.model}, isGpt5Model: ${baseOptions.isGpt5Model}`);
 
-        // 현재 todos를 가져와서 templateVars에 추가
+        // 현재 todos를 가져옴
         const currentTodos = getCurrentTodos();
         debugLog(`[judgeMissionCompletion] Current todos count: ${currentTodos.length}`);
 
-        // templateVars에 currentTodos 추가 (EJS 템플릿에서 조건부 렌더링)
+        // 시스템 메시지 로드
         const enhancedTemplateVars = {
             ...templateVars,
             currentTodos: currentTodos
         };
+        const systemMessageObj = await createSystemMessage("completion_judge.txt", enhancedTemplateVars);
+        debugLog(`[judgeMissionCompletion] System message loaded`);
+
+        // Orchestrator 대화에서 요약된 컨텍스트 추출
+        debugLog(`[judgeMissionCompletion] Extracting summarized context...`);
+        const summarizedContext = extractSummarizedContext();
+        debugLog(`[judgeMissionCompletion] Context extracted - tools: ${summarizedContext.toolExecutionSummary.split('\n').length}, assistant msg len: ${summarizedContext.lastAssistantMessage.length}`);
+
+        // 옵션에 추가 정보 포함
+        const requestOptions = {
+            ...baseOptions,
+            systemMessage: systemMessageObj.content,
+            mission: mission,
+            currentTodos: currentTodos
+        };
 
-        // Completion judge 자체 system 메시지 초기화 (템플릿 변수 전달)
-        debugLog(`[judgeMissionCompletion] Initializing completion judge conversation...`);
-        await ensureCompletionJudgeConversationInitialized(enhancedTemplateVars);
-        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] Sending request with summarized context...`);
+        const response = await dispatchCompletionJudgeRequest(requestOptions, summarizedContext);
 
         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);
+            let outputText = response.output_text || '';
+            let judgment = null;
+
+            // 1차 시도: 전체 텍스트를 JSON으로 파싱
+            try {
+                judgment = JSON.parse(outputText);
+                debugLog(`[judgeMissionCompletion] Parsed as pure JSON`);
+            } catch (e) {
+                // 2차 시도: 텍스트 끝에 붙은 JSON 추출 (GLM 모델 대응)
+                // 패턴: ...텍스트...{"should_complete":true,"whatUserShouldSay":"..."}
+                const jsonMatch = outputText.match(/\{[^{}]*"should_complete"\s*:\s*(true|false)[^{}]*\}/);
+                if (jsonMatch) {
+                    debugLog(`[judgeMissionCompletion] Extracted JSON from text: ${jsonMatch[0]}`);
+                    judgment = JSON.parse(jsonMatch[0]);
+                } else {
+                    // 3차 시도: 마지막 { } 블록 추출
+                    const lastBraceStart = outputText.lastIndexOf('{');
+                    const lastBraceEnd = outputText.lastIndexOf('}');
+                    if (lastBraceStart !== -1 && lastBraceEnd > lastBraceStart) {
+                        const jsonCandidate = outputText.substring(lastBraceStart, lastBraceEnd + 1);
+                        debugLog(`[judgeMissionCompletion] Trying last JSON block: ${jsonCandidate}`);
+                        judgment = JSON.parse(jsonCandidate);
+                    } else {
+                        throw new Error('No JSON found in output');
+                    }
+                }
+            }
+
             debugLog(`[judgeMissionCompletion] Parsed judgment successfully`);
             debugLog(`[judgeMissionCompletion] should_complete: ${judgment.should_complete}`);
             debugLog(`[judgeMissionCompletion] whatUserShouldSay: ${judgment.whatUserShouldSay}`);
@@ -308,17 +378,24 @@ export async function judgeMissionCompletion(templateVars = {}) {
         } 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.');
+            debugLog(`[judgeMissionCompletion] Raw output_text: ${response.output_text}`);
+
+            // JSON 파싱 실패 시 안전하게 완료 처리 (무한 루프 방지)
+            // orchestrator가 이미 message만 반환한 시점이므로 완료로 처리
+            debugLog(`[judgeMissionCompletion] Defaulting to complete to prevent infinite loop`);
+
+            debugLog('========================================');
+            debugLog('=== judgeMissionCompletion END (PARSE_ERROR) =');
+            debugLog('========================================');
+            debugLog('');
+
+            return { shouldComplete: true, whatUserShouldSay: "" };
         }
 
     } 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`);
@@ -329,15 +406,15 @@ export async function judgeMissionCompletion(templateVars = {}) {
             throw error;
         }
 
-        // 다른 에러 발생 시 안전하게 계속 진행
-        debugLog(`[judgeMissionCompletion] Non-abort error, returning safe default (shouldComplete=false)`);
+        // 다른 에러 발생 시 안전하게 완료 처리 (무한 루프 방지)
+        debugLog(`[judgeMissionCompletion] Non-abort error, returning safe default (shouldComplete=true to prevent loop)`);
         debugLog('========================================');
         debugLog('=== judgeMissionCompletion END (ERROR) =');
         debugLog('========================================');
         debugLog('');
 
         return {
-            shouldComplete: false,
+            shouldComplete: true,
             whatUserShouldSay: ""
         };
     }