aiexecode 1.0.56 → 1.0.58

package/src/system/session.js

@@ -1,6 +1,6 @@
 // Agent Loop: 계획·실행·검증 사이클을 수행하는 핵심 모듈
 import { orchestrateMission, continueOrchestratorConversation, resetOrchestratorConversation, recordOrchestratorToolResult, getOrchestratorConversation, restoreOrchestratorConversation } from "../ai_based/orchestrator.js";
-import { verifyResult, resetVerifierConversation, getVerifierConversation, restoreVerifierConversation } from "../ai_based/verifier.js";
+import { judgeMissionCompletion } from "../ai_based/completion_judge.js";
 import { execPythonCode, execShellScript } from "./code_executer.js";
 import { FILE_READER_FUNCTIONS } from "../tools/file_reader.js";
 import { RIPGREP_FUNCTIONS } from "../tools/ripgrep.js";
@@ -12,7 +12,7 @@ import { clampOutput, formatToolStdout } from "../util/output_formatter.js";
 import { buildToolHistoryEntry } from "../util/rag_helper.js";
 import { createSessionData, getLastConversationState, loadPreviousSessions, saveSessionToHistory } from "./session_memory.js";
 import { uiEvents } from "./ui_events.js";
-import { logSystem, logInfo, logSuccess, logWarning, logError, logAssistantMessage, logToolCall, logToolResult, logCodeExecution, logCodeResult, logIteration, logVerificationResult, logMissionComplete, logConversationRestored } from "./output_helper.js";
+import { logSystem, logInfo, logSuccess, logWarning, logError, logAssistantMessage, logToolCall, logToolResult, logCodeExecution, logCodeResult, logIteration, logMissionComplete, logConversationRestored } from "./output_helper.js";
 import { requiresApproval, requestApproval } from "./tool_approval.js";
 import { setCurrentSession, saveFileSnapshot, getFileSnapshot } from "./file_integrity.js";
 import { abortCurrentRequest } from "./ai_request.js";
@@ -23,18 +23,10 @@ import { ERROR_VERBOSITY } from '../config/feature_flags.js';
 
 const debugLog = createDebugLogger('session.log', 'session');
 
-/**
- * Verifier 사용 여부를 제어하는 상수
- * true: Verifier를 통한 검증 사이클 활성화
- * false: Verifier 없이 Orchestrator만 실행 (각 iteration마다 자동으로 다음 단계 진행)
- */
-const ENABLE_VERIFIER = false;
-
 /**
  * 상수 정의
  */
 const MAX_REASONING_ONLY_RESPONSES = 5;
-const MAX_WHAT_IT_DID_HISTORY = 12;
 const DEFAULT_MAX_ITERATIONS = 50;
 const SUB_MISSION_MAX_LENGTH = 120;
 
@@ -96,13 +88,15 @@ function cleanupExecutionResult(exeResult, rawStdout, rawStderr) {
 
 /**
  * 메시지 타입 출력을 처리하는 함수
+ * @param {Object} output - 메시지 출력 객체
+ * @param {boolean} shouldOutput - 메시지를 출력할지 여부 (기본값: false, completion_judge 판단 후 결정)
  */
-function processMessageOutput(output) {
+function processMessageOutput(output, shouldOutput = false) {
     const rawMessage = output.content?.[0]?.text ?? '';
     const truncatedMessage = clampOutput(rawMessage);
 
-    // 빈 메시지가 아닐 때만 로그 출력 (세션 종료 신호는 출력하지 않음)
-    if (rawMessage.trim()) {
+    // shouldOutput이 true이고 빈 메시지가 아닐 때만 로그 출력
+    if (shouldOutput && rawMessage.trim()) {
         logAssistantMessage(truncatedMessage);
     }
 
@@ -309,23 +303,6 @@ async function processCodeExecution(name, argument, toolMap) {
 }
 
 
-/**
- * 검증 결과 상태 맵
- */
-const VERIFICATION_DECISION_STATUS = {
-    'MISSION_COMPLETE': '✅ Complete',
-    'SUBMISSION_COMPLETE': '✅ Subtask Complete',
-    'IN_PROGRESS': '⏳ In Progress',
-    'REPLAN_NEEDED': '🔄 Needs Replanning'
-};
-
-/**
- * 루프 제어 결과 타입 정의
- */
-const LOOP_CONTROL = {
-    CONTINUE: 'continue',
-    BREAK: 'break'
-};
 
 /**
  * Orchestrator 응답을 처리하는 함수
@@ -359,6 +336,8 @@ async function processOrchestratorResponses(params) {
     let hadAnyFunctionCall = false;
     let stallDetected = false;
     let missionSolved = false;
+    let improvementPoints = '';
+    let improvementPointsIsAutoGenerated = false;
 
     debugLog(`Starting response processing loop...`);
     let loopIteration = 0;
@@ -416,6 +395,7 @@ async function processOrchestratorResponses(params) {
         reasoningOnlyResponses = 0;
         let executedFunctionCall = false;
         let lastOutputType = null;
+        let pendingMessageOutput = null; // 출력 대기 중인 MESSAGE 저장
 
         // 각 출력 처리
         for (let outputIndex = 0; outputIndex < outputs.length; outputIndex++) {
@@ -445,11 +425,13 @@ async function processOrchestratorResponses(params) {
             let content;
 
             if (MESSAGE) {
-                debugLog(`  Processing MESSAGE output...`);
-                const { exeResult, content: msgContent } = processMessageOutput(output);
+                debugLog(`  Processing MESSAGE output (without displaying)...`);
+                // 출력하지 않고 저장만 함 (shouldOutput = false)
+                const { exeResult, content: msgContent } = processMessageOutput(output, false);
                 exe_result = exeResult;
                 content = msgContent;
-                debugLog(`  MESSAGE processed: content length ${msgContent?.length || 0}`);
+                pendingMessageOutput = output; // 나중에 출력할 수 있도록 저장
+                debugLog(`  MESSAGE processed (pending): content length ${msgContent?.length || 0}`);
             }
 
             if (FUNCTION_CALL) {
@@ -593,13 +575,101 @@ async function processOrchestratorResponses(params) {
         // 완료 조건 체크
         debugLog(`Checking completion conditions...`);
         if (!executedFunctionCall && lastOutputType === 'message') {
-            debugLog(`COMPLETION: No function call + message type = mission solved`);
-            missionSolved = true;
-            break;
+            debugLog(`COMPLETION: No function call + message type - judging if mission is truly complete`);
+
+            // 세션 중단 확인 (completion_judge 호출 전)
+            if (sessionInterrupted) {
+                debugLog(`Session interrupted before judgeMissionCompletion, breaking loop`);
+                break;
+            }
+
+            // LLM을 통해 실제 완료 여부 판단
+            let judgement;
+            try {
+                judgement = await judgeMissionCompletion({
+                    what_user_requests: mission
+                });
+            } catch (err) {
+                if (err.name === 'AbortError' || sessionInterrupted) {
+                    debugLog(`judgeMissionCompletion aborted or interrupted: ${err.name}`);
+                    break;
+                }
+                throw err;
+            }
+
+            // 세션 중단 확인 (completion_judge 호출 후)
+            if (sessionInterrupted) {
+                debugLog(`Session interrupted after judgeMissionCompletion, breaking loop`);
+                break;
+            }
+
+            debugLog(`Completion judgement: shouldComplete=${judgement.shouldComplete}, reason=${judgement.reason}, whatUserShouldSay=${judgement.whatUserShouldSay}`);
+
+            missionSolved = judgement.shouldComplete;
+
+            if (missionSolved) {
+                // 미션이 완료되었다고 판단되면 대기 중인 메시지 출력 후 종료
+                debugLog(`Mission judged as complete, displaying pending message and breaking loop`);
+                if (pendingMessageOutput) {
+                    processMessageOutput(pendingMessageOutput, true); // 이제 출력
+                }
+                break;
+            } else {
+                // 미션이 완료되지 않았다고 판단되면 메시지를 출력하지 않고 계속 진행
+                debugLog(`Mission not complete, continuing without displaying message`);
+
+                // orchestratorConversation에서 방금 추가된 assistant message에 _internal_only 플래그 추가
+                const conversation = getOrchestratorConversation();
+                for (let i = conversation.length - 1; i >= 0; i--) {
+                    const entry = conversation[i];
+                    if (entry.type === 'message' && entry.role === 'assistant') {
+                        entry._internal_only = true;
+                        debugLog(`[_internal_only] Marked assistant message at index ${i} as internal-only (not for display)`);
+                        break;
+                    }
+                }
+
+                // whatUserShouldSay를 새로운 사용자 요구사항으로 처리
+                if (judgement.whatUserShouldSay && judgement.whatUserShouldSay.trim().length > 0) {
+                    debugLog(`Treating whatUserShouldSay as new user request: ${judgement.whatUserShouldSay}`);
+                    // 💬 Auto-continuing 메시지 제거
+
+                    // whatUserShouldSay를 새로운 mission으로 설정하여 루프를 빠져나감
+                    // 상위 runSession 루프에서 다시 orchestrateMission이 호출될 것임
+                    improvementPoints = judgement.whatUserShouldSay;
+                    improvementPointsIsAutoGenerated = true; // auto-generated 플래그 설정
+                    debugLog(`[_internal_only] Set improvementPointsIsAutoGenerated=true for whatUserShouldSay`);
+                    missionSolved = false;  // 완료되지 않았으므로 상위 루프 계속
+                    break;  // processOrchestratorResponses 루프 종료
+                } else {
+                    // whatUserShouldSay가 없으면 reason을 사용하여 계속 진행
+                    improvementPoints = judgement.reason;
+                    debugLog(`Continuing mission with reason: ${judgement.reason}`);
+
+                    // 세션 중단 확인 (continueOrchestratorConversation 호출 전)
+                    if (sessionInterrupted) {
+                        debugLog(`Session interrupted before continueOrchestratorConversation, breaking loop`);
+                        break;
+                    }
+
+                    try {
+                        orchestratedResponse = await continueOrchestratorConversation();
+                        debugLog(`Received response with ${orchestratedResponse?.output?.length || 0} outputs`);
+                        continue; // 루프 처음으로 돌아가서 새 응답 처리
+                    } catch (err) {
+                        if (err.name === 'AbortError' || sessionInterrupted) {
+                            debugLog(`Conversation aborted or interrupted: ${err.name}`);
+                            break;
+                        }
+                        debugLog(`ERROR in continueOrchestratorConversation: ${err.message}`);
+                        throw err;
+                    }
+                }
+            }
         }
 
         if (!executedFunctionCall) {
-            debugLog(`COMPLETION: No function call executed, breaking loop`);
+            debugLog(`COMPLETION: No function call executed (other cases), breaking loop`);
             break;
         }
 
@@ -623,76 +693,20 @@ async function processOrchestratorResponses(params) {
     debugLog(`  hadAnyFunctionCall: ${hadAnyFunctionCall}`);
     debugLog(`  stallDetected: ${stallDetected}`);
     debugLog(`  missionSolved: ${missionSolved}`);
+    debugLog(`  improvementPoints: ${improvementPoints}`);
+    debugLog(`  improvementPointsIsAutoGenerated: ${improvementPointsIsAutoGenerated}`);
     debugLog(`  Total loop iterations: ${loopIteration}`);
     debugLog(`  Final toolUsageHistory: ${toolUsageHistory.length} items`);
 
     return {
         hadAnyFunctionCall,
         stallDetected,
-        missionSolved
+        missionSolved,
+        improvementPoints,
+        improvementPointsIsAutoGenerated
     };
 }
 
-/**
- * 검증 결과에 따라 다음 동작을 결정하는 함수
- * @returns {{ loopControl: string, improvementPoints: string, missionSolved: boolean }}
- */
-function handleVerificationResult(verificationResult) {
-    const decision = verificationResult.decision;
-
-    switch (decision) {
-        case 'MISSION_COMPLETE':
-            return {
-                loopControl: LOOP_CONTROL.BREAK,
-                improvementPoints: '',
-                missionSolved: true
-            };
-
-        case 'SUBMISSION_COMPLETE':
-            uiEvents.addSystemMessage('✅ Sub-mission complete; continuing towards full mission completion.');
-            return {
-                loopControl: LOOP_CONTROL.CONTINUE,
-                improvementPoints: verificationResult.improvement_points || '',
-                missionSolved: false
-            };
-
-        case 'IN_PROGRESS':
-            return {
-                loopControl: LOOP_CONTROL.CONTINUE,
-                improvementPoints: verificationResult.improvement_points || '',
-                missionSolved: false
-            };
-
-        case 'REPLAN_NEEDED':
-            uiEvents.addSystemMessage('🔄 Revisit approach required - will try a different angle next iteration.');
-            return {
-                loopControl: LOOP_CONTROL.CONTINUE,
-                improvementPoints: verificationResult.improvement_points || '',
-                missionSolved: false
-            };
-
-        default:
-            return {
-                loopControl: LOOP_CONTROL.CONTINUE,
-                improvementPoints: '',
-                missionSolved: false
-            };
-    }
-}
-
-/**
- * 실행 요약을 생성하는 헬퍼 함수
- */
-function buildExecutionSummary(executionOutputList) {
-    return executionOutputList.map((exec_result, index) => {
-        const toolName = exec_result.more_info?.name || 'unknown';
-        const operationType = exec_result.more_info?.type || 'unknown';
-        const stdoutBlock = exec_result.stdout ? `\n\`\`\`\n${exec_result.stdout}\n\`\`\`` : '\n(empty)';
-        const stderrBlock = exec_result.stderr ? `\n\`\`\`\n${exec_result.stderr}\n\`\`\`` : '\n(empty)';
-        const ragRefLine = exec_result.rag_reference ? `- RAG Reference: ${exec_result.rag_reference}\n` : '';
-        return `### Step ${index + 1}\n- Function: \`${toolName}\`\n- Operation Type: \`${operationType}\`\n- Exit Code: ${typeof exec_result.code === 'number' ? exec_result.code : '?'}\n${ragRefLine}- STDOUT:${stdoutBlock}\n- STDERR:${stderrBlock}`;
-    }).join('\n\n');
-}
 
 
 /**
@@ -710,8 +724,6 @@ function buildExecutionSummary(executionOutputList) {
  * @typedef {Object} AgentLoopResult
  * @property {boolean} mission_solved - 미션 완료 여부
  * @property {number} iteration_count - 실행된 반복 횟수
- * @property {Array} verification_memory - 검증 메모리
- * @property {Array} whatItDidHistory - 수행 작업 히스토리
  * @property {Array} toolUsageHistory - 도구 사용 히스토리
  */
 
@@ -781,13 +793,12 @@ export async function runSession(options) {
         }
 
         // 메모리 초기화
-        const verification_memory = [];
-        const whatItDidHistory = [];
         const toolUsageHistory = [];
 
         let mission_solved = false;
         let iteration_count = 0;
         let improvement_points = '';
+        let improvement_points_is_auto_generated = false; // whatUserShouldSay에서 온 것인지 표시
 
         // 대화 상태 복원 또는 리셋
         const conversationState = getLastConversationState(sessionsToUse);
@@ -797,19 +808,10 @@ export async function runSession(options) {
                 conversationState.orchestratorConversation,
                 conversationState.orchestratorRequestOptions
             );
-            if (ENABLE_VERIFIER) {
-                restoreVerifierConversation(
-                    conversationState.verifierConversation,
-                    conversationState.lastOrchestratorSnapshotLength
-                );
-            }
             // logSuccess('✓ Conversation state restored');
         } else {
             // logSystem('ℹ Starting with fresh conversation state');
             resetOrchestratorConversation();
-            if (ENABLE_VERIFIER) {
-                resetVerifierConversation();
-            }
         }
 
         // Python 사용 가능 여부 확인
@@ -837,40 +839,68 @@ export async function runSession(options) {
             iteration_count++;
             logIteration(iteration_count);
 
-            // 세션 중단 확인
-            if (sessionInterrupted) {
-                break;
-            }
-
-
-            // 세션 중단 확인
-            if (sessionInterrupted) {
-                break;
-            }
-
             // 첫 반복에서 improvement_points 설정
+            // (이후 반복에서는 processOrchestratorResponses에서 설정된 값 유지)
             if (iteration_count === 1) {
                 improvement_points = `${mission}`;
+                improvement_points_is_auto_generated = false; // 첫 번째는 실제 사용자 입력
+                debugLog(`[ITERATION ${iteration_count}] Setting initial improvement_points: ${improvement_points.substring(0, 100)}`);
+            } else if (!improvement_points) {
+                // improvementPoints가 설정되지 않았으면 빈 문자열
+                improvement_points = '';
+                improvement_points_is_auto_generated = false;
+                debugLog(`[ITERATION ${iteration_count}] No improvement_points, setting to empty string`);
+            } else {
+                debugLog(`[ITERATION ${iteration_count}] Using existing improvement_points: ${improvement_points.substring(0, 100)}, isAutoGenerated: ${improvement_points_is_auto_generated}`);
             }
 
             // Orchestrator 실행
+            debugLog(`[ITERATION ${iteration_count}] Calling orchestrateMission with improvement_points: "${improvement_points.substring(0, 100)}", isAutoGenerated: ${improvement_points_is_auto_generated}`);
             let orchestratedMission;
             try {
                 orchestratedMission = await orchestrateMission({
                     improvement_points: improvement_points,
-                    mcpToolSchemas: mcpToolSchemas
+                    mcpToolSchemas: mcpToolSchemas,
+                    isAutoGenerated: improvement_points_is_auto_generated
                 });
             } catch (err) {
                 // AbortError는 중단으로 처리
                 if (err.name === 'AbortError' || sessionInterrupted) {
+                    // 중단 시에도 현재까지의 상태를 저장
+                    currentSessionData.completed_at = new Date().toISOString();
+                    currentSessionData.mission_solved = false;
+                    currentSessionData.iteration_count = iteration_count;
+                    currentSessionData.toolUsageHistory = toolUsageHistory;
+                    currentSessionData.orchestratorConversation = getOrchestratorConversation();
+                    currentSessionData.orchestratorRequestOptions = null;
+
+                    debugLog(`[ITERATION ${iteration_count}] Session aborted during orchestration - saving session to history`);
+                    await saveSessionToHistory(currentSessionData).catch(saveErr => {
+                        debugLog(`[ITERATION ${iteration_count}] Failed to save session: ${saveErr.message}`);
+                    });
                     break;
                 }
                 throw err;
             }
-            improvement_points = '';
+            // improvement_points_is_auto_generated 플래그 리셋 (다음 iteration을 위해)
+            improvement_points_is_auto_generated = false;
+            // improvement_points는 여기서 리셋하지 않음 (processOrchestratorResponses에서 설정될 수 있음)
+            debugLog(`[ITERATION ${iteration_count}] orchestrateMission completed`)
 
             // 세션 중단 확인
             if (sessionInterrupted) {
+                // 중단 시에도 현재까지의 상태를 저장
+                currentSessionData.completed_at = new Date().toISOString();
+                currentSessionData.mission_solved = false;
+                currentSessionData.iteration_count = iteration_count;
+                currentSessionData.toolUsageHistory = toolUsageHistory;
+                currentSessionData.orchestratorConversation = getOrchestratorConversation();
+                currentSessionData.orchestratorRequestOptions = null;
+
+                debugLog(`[ITERATION ${iteration_count}] Session interrupted after orchestration - saving session to history`);
+                await saveSessionToHistory(currentSessionData).catch(err => {
+                    debugLog(`[ITERATION ${iteration_count}] Failed to save session: ${err.message}`);
+                });
                 break;
             }
 
@@ -905,11 +935,50 @@ export async function runSession(options) {
             stallDetected = orchestratorResult.stallDetected;
             mission_solved = orchestratorResult.missionSolved;
 
+            debugLog(`[ITERATION ${iteration_count}] orchestratorResult.improvementPoints: "${orchestratorResult.improvementPoints || '(empty)'}", isAutoGenerated: ${orchestratorResult.improvementPointsIsAutoGenerated}`);
+
+            // improvementPoints가 반환된 경우 다음 iteration에 사용
+            // 반환되지 않은 경우 리셋
+            if (orchestratorResult.improvementPoints) {
+                improvement_points = orchestratorResult.improvementPoints;
+                improvement_points_is_auto_generated = orchestratorResult.improvementPointsIsAutoGenerated || false;
+                debugLog(`[ITERATION ${iteration_count}] Setting improvement_points from orchestratorResult: "${improvement_points.substring(0, 100)}", isAutoGenerated: ${improvement_points_is_auto_generated}`);
+            } else {
+                improvement_points = '';
+                improvement_points_is_auto_generated = false;
+                debugLog(`[ITERATION ${iteration_count}] No improvementPoints from orchestratorResult, resetting to empty`);
+            }
+
             // 세션 중단 확인
             if (sessionInterrupted) {
+                // 중단 시에도 현재까지의 상태를 저장
+                currentSessionData.completed_at = new Date().toISOString();
+                currentSessionData.mission_solved = false;
+                currentSessionData.iteration_count = iteration_count;
+                currentSessionData.toolUsageHistory = toolUsageHistory;
+                currentSessionData.orchestratorConversation = getOrchestratorConversation();
+                currentSessionData.orchestratorRequestOptions = null;
+
+                debugLog(`[ITERATION ${iteration_count}] Session interrupted - saving session to history`);
+                await saveSessionToHistory(currentSessionData).catch(err => {
+                    debugLog(`[ITERATION ${iteration_count}] Failed to save session: ${err.message}`);
+                });
                 break;
             }
 
+            // 매 iteration마다 세션 히스토리 저장 (실시간 저장)
+            currentSessionData.completed_at = new Date().toISOString();
+            currentSessionData.mission_solved = mission_solved;
+            currentSessionData.iteration_count = iteration_count;
+            currentSessionData.toolUsageHistory = toolUsageHistory;
+            currentSessionData.orchestratorConversation = getOrchestratorConversation();
+            currentSessionData.orchestratorRequestOptions = null;
+
+            debugLog(`[ITERATION ${iteration_count}] Saving session to history (real-time save)`);
+            await saveSessionToHistory(currentSessionData).catch(err => {
+                debugLog(`[ITERATION ${iteration_count}] Failed to save session: ${err.message}`);
+            });
+
             // 미션 완료 처리
             if (mission_solved) {
                 break;
@@ -925,63 +994,21 @@ export async function runSession(options) {
                 break;
             }
 
-            // Verifier가 비활성화된 경우 계속 진행
-            if (!ENABLE_VERIFIER) {
-                uiEvents.addSystemMessage('ℹ Verifier disabled - orchestrator continues');
-                improvement_points = '';
-                continue;
-            }
-
-
-            // Verifier 실행
-            const verification_result = await verifyResult({ what_user_requests: mission });
-            uiEvents.addSystemMessage(`${verification_result.decision}`);
-            if (false) uiEvents.addSystemMessage(`Verified ${verification_result.improvement_points}`);
-            if (verification_result.replan_needed) uiEvents.addSystemMessage(`Verified Re-Plan Required`);
-            if (verification_result.what_it_did) {
-                whatItDidHistory.push(verification_result.what_it_did);
-                if (whatItDidHistory.length > MAX_WHAT_IT_DID_HISTORY) {
-                    whatItDidHistory.shift();
-                }
-            }
-
-            // Verification memory에 추가
-            const memoryEntry = {
-                timestamp: new Date().toISOString(),
-                mission: mission,
-                iteration: iteration_count,
-                what_it_did: verification_result.what_it_did || '',
-                result: verification_result,
-                what_it_did_history: [...whatItDidHistory],
-                tool_history: [...iterationToolHistory]
-            };
-
-            verification_memory.push(memoryEntry);
-
-            // 미션 상태에 따른 처리
-            const nextAction = handleVerificationResult(verification_result);
-            improvement_points = nextAction.improvementPoints;
-            mission_solved = nextAction.missionSolved;
-
-            if (nextAction.loopControl === LOOP_CONTROL.BREAK) {
-                break;
-            }
+            // improvement_points가 설정되어 있으면 다음 iteration 계속 진행
+            debugLog(`[ITERATION ${iteration_count}] Continuing with improvement_points: "${improvement_points?.substring(0, 100) || '(empty)'}"`);
+            continue;
         }
 
         // 대화 상태 저장
         const finalOrchestratorConversation = getOrchestratorConversation();
-        const finalVerifierConversation = ENABLE_VERIFIER ? getVerifierConversation() : [];
 
         // 결과 반환
         const result = {
             mission_solved,
             iteration_count,
-            verification_memory,
-            whatItDidHistory,
             toolUsageHistory,
             // 대화 상태도 반환하여 저장할 수 있도록 함
             orchestratorConversation: finalOrchestratorConversation,
-            verifierConversation: finalVerifierConversation,
 
             previousSessions: sessionsToUse
         };
@@ -989,21 +1016,17 @@ export async function runSession(options) {
         currentSessionData.completed_at = new Date().toISOString();
         currentSessionData.mission_solved = result.mission_solved;
         currentSessionData.iteration_count = result.iteration_count;
-        currentSessionData.verification_memory = result.verification_memory;
-        currentSessionData.whatItDidHistory = result.whatItDidHistory;
         currentSessionData.toolUsageHistory = result.toolUsageHistory;
         // previousSessions는 saveSessionToHistory에서 파일로부터 로드하므로 저장하지 않음 (메모리 누적 방지)
         // currentSessionData.previousSessions = result.previousSessions;
         debugLog('[runSession] previousSessions NOT saved to currentSessionData to prevent exponential growth');
         // 대화 상태 저장
         currentSessionData.orchestratorConversation = result.orchestratorConversation;
-        currentSessionData.verifierConversation = result.verifierConversation;
-        currentSessionData.lastOrchestratorSnapshotLength = result.orchestratorConversation?.length || 0;
         currentSessionData.orchestratorRequestOptions = null; // 필요시 orchestrator에서 가져올 수 있음
 
-        debugLog(`[runSession] Saving session to history - sessionID: ${currentSessionData.sessionID}`);
+        debugLog(`[runSession] Saving final session to history - sessionID: ${currentSessionData.sessionID}`);
         debugLog(`[runSession] Session data size: ${JSON.stringify(currentSessionData).length} bytes`);
-        // 세션 히스토리에 저장
+        // 최종 세션 히스토리에 저장 (중복 저장이지만 최신 상태 보장)
         await saveSessionToHistory(currentSessionData);
 
         return currentSessionData;

package/src/system/session_memory.js

@@ -177,14 +177,6 @@ export function buildHistoricalContext(sessions, currentMission) {
         contextParts.push(`**Status**: ${session.mission_solved ? '✅ Completed' : '❌ Not completed'}`);
         contextParts.push(`**Iterations**: ${session.iteration_count || 0}`);
 
-        // 주요 수행 내역
-        if (session.whatItDidHistory && session.whatItDidHistory.length > 0) {
-            contextParts.push(`**Actions Taken**:`);
-            session.whatItDidHistory.slice(-3).forEach(action => {
-                contextParts.push(`  - ${action}`);
-            });
-        }
-
         // 도구 사용 통계
         if (session.toolUsageHistory && session.toolUsageHistory.length > 0) {
             const toolCounts = {};
@@ -194,17 +186,6 @@ export function buildHistoricalContext(sessions, currentMission) {
             contextParts.push(`**Tools Used**: ${Object.entries(toolCounts).map(([name, count]) => `${name}(${count})`).join(', ')}`);
         }
 
-        // 마지막 검증 결과
-        if (session.verification_memory && session.verification_memory.length > 0) {
-            const lastVerification = session.verification_memory[session.verification_memory.length - 1];
-            if (lastVerification.result) {
-                contextParts.push(`**Final Decision**: ${lastVerification.result.decision}`);
-                if (lastVerification.result.improvement_points) {
-                    contextParts.push(`**Lessons**: ${lastVerification.result.improvement_points.slice(0, 200)}...`);
-                }
-            }
-        }
-
         contextParts.push('');
     });
 
@@ -225,13 +206,9 @@ export function createSessionData(sessionID, mission) {
         completed_at: null,
         mission_solved: false,
         iteration_count: 0,
-        verification_memory: [],
-        whatItDidHistory: [],
         toolUsageHistory: [],
         // 대화 상태 저장
         orchestratorConversation: [],
-        verifierConversation: [],
-        lastOrchestratorSnapshotLength: 0,
         orchestratorRequestOptions: null
     };
 }
@@ -250,8 +227,6 @@ export function getLastConversationState(sessions) {
 
     return {
         orchestratorConversation: lastSession.orchestratorConversation || [],
-        verifierConversation: lastSession.verifierConversation || [],
-        lastOrchestratorSnapshotLength: lastSession.lastOrchestratorSnapshotLength || 0,
         orchestratorRequestOptions: lastSession.orchestratorRequestOptions || null
     };
 }
@@ -290,16 +265,12 @@ export function reconstructUIHistory(sessions) {
             const conversation = session.orchestratorConversation;
             debugLog(`orchestratorConversation length: ${conversation.length}`);
 
-            // 현재 세션의 시작 지점: 이전 세션의 끝 = 이전 세션의 lastOrchestratorSnapshotLength
+            // 현재 세션의 시작 지점: 항상 0부터 시작 (각 세션은 독립적)
             let startIndex = 0;
-            if (sessionIndex > 0) {
-                startIndex = sessions[sessionIndex - 1].lastOrchestratorSnapshotLength || 0;
-                debugLog(`Previous session lastOrchestratorSnapshotLength: ${startIndex}`);
-            }
 
-            // 현재 세션의 끝 지점: 현재 세션의 lastOrchestratorSnapshotLength
-            const endIndex = session.lastOrchestratorSnapshotLength || conversation.length;
-            debugLog(`Current session lastOrchestratorSnapshotLength: ${endIndex}`);
+            // 현재 세션의 끝 지점: conversation 전체 길이 사용
+            const endIndex = conversation.length;
+            debugLog(`Current session conversation length: ${endIndex}`);
             debugLog(`Processing conversation slice [${startIndex}, ${endIndex}]`);
 
             // 현재 세션에서 새로 추가된 대화만 추출
@@ -467,6 +438,12 @@ export function reconstructUIHistory(sessions) {
 
                 // message 타입 처리 (assistant 응답)
                 if (item.type === 'message' && item.role === 'assistant' && item.content) {
+                    // _internal_only 플래그가 있으면 건너뛰기
+                    if (item._internal_only) {
+                        debugLog(`[reconstructUIHistory] Skipping assistant message with _internal_only flag`);
+                        continue;
+                    }
+
                     const text = item.content[0]?.text || '';
                     if (text) {
                         uiHistory.push({
@@ -479,6 +456,12 @@ export function reconstructUIHistory(sessions) {
 
                 // user 메시지 타입 처리
                 if (item.role === 'user' && item.content) {
+                    // _internal_only 플래그가 있으면 건너뛰기
+                    if (item._internal_only) {
+                        debugLog(`[reconstructUIHistory] Skipping user message with _internal_only flag`);
+                        continue;
+                    }
+
                     const textContent = item.content.find(c => c.type === 'input_text');
                     if (textContent && textContent.text) {
                         uiHistory.push({
@@ -491,10 +474,6 @@ export function reconstructUIHistory(sessions) {
             }
         }
 
-        // whatItDidHistory와 verification_memory는 orchestratorConversation에
-        // 이미 포함되어 있으므로 중복 추가하지 않음
-
-        // mission_completed는 UI에서 필터링되므로 추가하지 않음
     });
 
     return uiHistory;