aiexecode 1.0.94 → 1.0.127

package/src/system/session.js

@@ -1,7 +1,8 @@
 // Agent Loop: 계획·실행·검증 사이클을 수행하는 핵심 모듈
 import { orchestrateMission, continueOrchestratorConversation, resetOrchestratorConversation, recordOrchestratorToolResult, getOrchestratorConversation, restoreOrchestratorConversation } from "../ai_based/orchestrator.js";
 import { judgeMissionCompletion } from "../ai_based/completion_judge.js";
-import { execPythonCode, execShellScript } from "./code_executer.js";
+import { execPythonCode, execShellScript, resetShellCwd } from "./code_executer.js";
+import { runInBackground, getBackgroundProcess } from "./background_process.js";
 import { FILE_READER_FUNCTIONS } from "../tools/file_reader.js";
 import { RIPGREP_FUNCTIONS } from "../tools/ripgrep.js";
 import { GLOB_FUNCTIONS } from "../tools/glob.js";
@@ -9,9 +10,10 @@ import { CODE_EDITOR_FUNCTIONS } from "../tools/code_editor.js";
 import { WEB_DOWNLOADER_FUNCTIONS } from "../tools/web_downloader.js";
 import { RESPONSE_MESSAGE_FUNCTIONS } from '../tools/response_message.js';
 import { TODO_WRITE_FUNCTIONS } from '../tools/todo_write.js';
+import { SKILL_FUNCTIONS } from '../tools/skill_tool.js';
 import { clampOutput, formatToolStdout } from "../util/output_formatter.js";
 import { buildToolHistoryEntry } from "../util/rag_helper.js";
-import { createSessionData, getLastConversationState, loadPreviousSessions, saveSessionToHistory, saveTodosToSession, restoreTodosFromSession, updateCurrentTodos, getCurrentTodos } from "./session_memory.js";
+import { createSessionData, getLastConversationState, loadPreviousSessions, saveSessionToHistory, saveTodosToSession, restoreTodosFromSession, saveTrimmedFileReadsToSession, restoreTrimmedFileReadsFromSession, updateCurrentTodos, getCurrentTodos } from "./session_memory.js";
 import { uiEvents } from "./ui_events.js";
 import { logSystem, logError, logAssistantMessage, logToolCall, logToolResult, logCodeExecution, logCodeResult, logIteration, logMissionComplete, logConversationRestored } from "./output_helper.js";
 import { requiresApproval, requestApproval } from "./tool_approval.js";
@@ -20,16 +22,55 @@ import { abortCurrentRequest } from "./ai_request.js";
 import { safeReadFile } from '../util/safe_fs.js';
 import { resolve } from 'path';
 import { createDebugLogger } from '../util/debug_log.js';
-import { ERROR_VERBOSITY } from '../config/feature_flags.js';
+import { loadSettings } from '../util/config.js';
+import {
+    MAX_REASONING_ONLY_RESPONSES,
+    DEFAULT_MAX_ITERATIONS,
+    SUB_MISSION_MAX_LENGTH
+} from '../config/constants.js';
 
 const debugLog = createDebugLogger('session.log', 'session');
 
-/**
- * 상수 정의
- */
-const MAX_REASONING_ONLY_RESPONSES = 5;
-const DEFAULT_MAX_ITERATIONS = 50;
-const SUB_MISSION_MAX_LENGTH = 120;
+// Pipe mode helper: UI 이벤트를 조건부로 처리
+const isPipeMode = () => process.app_custom?.pipeMode === true;
+
+// Pipe mode에서는 stderr로 출력, 일반 모드에서는 uiEvents 사용
+const safeUiEvents = {
+    addSystemMessage: (msg) => {
+        if (isPipeMode()) {
+            console.error(`[SYSTEM] ${msg}`);
+        } else {
+            uiEvents.addSystemMessage(msg);
+        }
+    },
+    addErrorMessage: (msg) => {
+        if (isPipeMode()) {
+            console.error(`[ERROR] ${msg}`);
+        } else {
+            uiEvents.addErrorMessage(msg);
+        }
+    },
+    sessionStart: (msg) => {
+        if (!isPipeMode()) {
+            uiEvents.sessionStart(msg);
+        }
+    },
+    sessionEnd: () => {
+        if (!isPipeMode()) {
+            uiEvents.sessionEnd();
+        }
+    },
+    on: (event, handler) => {
+        if (!isPipeMode()) {
+            uiEvents.on(event, handler);
+        }
+    },
+    off: (event, handler) => {
+        if (!isPipeMode()) {
+            uiEvents.off(event, handler);
+        }
+    }
+};
 
 
 /**
@@ -391,11 +432,14 @@ async function processOrchestratorResponses(params) {
         );
         debugLog(`Has processable output: ${hasProcessableOutput}`);
 
+        // pendingMessageOutput은 while 루프 스코프에서 유지 (function call 없이 끝날 때 출력용)
+        let pendingMessageOutput = null;
+
         if (!hasProcessableOutput) {
             debugLog(`No processable output, reasoningOnlyResponses: ${reasoningOnlyResponses}`);
             if (reasoningOnlyResponses >= MAX_REASONING_ONLY_RESPONSES) {
                 debugLog(`Reached MAX_REASONING_ONLY_RESPONSES (${MAX_REASONING_ONLY_RESPONSES}), treating as stall`);
-                uiEvents.addSystemMessage('⚠ Orchestrator stalled (reasoning only) - treating as completion');
+                safeUiEvents.addSystemMessage('⚠ Orchestrator stalled (reasoning only) - treating as completion');
                 stallDetected = true;
                 break;
             }
@@ -419,7 +463,6 @@ async function processOrchestratorResponses(params) {
         reasoningOnlyResponses = 0;
         let executedFunctionCall = false;
         let lastOutputType = null;
-        let pendingMessageOutput = null; // 출력 대기 중인 MESSAGE 저장
 
         // 각 출력 처리
         for (let outputIndex = 0; outputIndex < outputs.length; outputIndex++) {
@@ -598,8 +641,33 @@ async function processOrchestratorResponses(params) {
 
         // 완료 조건 체크
         debugLog(`Checking completion conditions...`);
-        if (!executedFunctionCall && lastOutputType === 'message') {
-            debugLog(`COMPLETION: No function call + message type - judging if mission is truly complete`);
+        debugLog(`  executedFunctionCall: ${executedFunctionCall}, hadAnyFunctionCall: ${hadAnyFunctionCall}, lastOutputType: ${lastOutputType}`);
+
+        // Case 1: Function call 없이 message만 있는 경우 (단순 대화, 인사 등)
+        // → Completion Judge 없이 바로 message 출력하고 완료
+        if (!executedFunctionCall && lastOutputType === 'message' && !hadAnyFunctionCall) {
+            debugLog(`COMPLETION: No function call at all + message type - completing immediately without Completion Judge`);
+
+            // 대기 중인 메시지 출력
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message immediately`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
+
+            missionSolved = true;
+            break;
+        }
+
+        // Case 2: Function call 실행 후 message로 결과 보고
+        // → message 먼저 출력 → Completion Judge로 추가 작업 판단
+        if (!executedFunctionCall && lastOutputType === 'message' && hadAnyFunctionCall) {
+            debugLog(`COMPLETION: Had function calls + final message - displaying message first, then judging completion`);
+
+            // 먼저 message 출력 (사용자가 바로 결과 확인 가능)
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message before completion judge`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
 
             // 세션 중단 확인 (completion_judge 호출 전)
             if (sessionInterrupted) {
@@ -646,45 +714,30 @@ async function processOrchestratorResponses(params) {
             missionSolved = judgement.shouldComplete;
 
             if (missionSolved) {
-                // 미션이 완료되었다고 판단되면 대기 중인 메시지 출력 후 종료
-                debugLog(`Mission judged as complete, displaying pending message and breaking loop`);
-                if (pendingMessageOutput) {
-                    processMessageOutput(pendingMessageOutput, true); // 이제 출력
-                }
+                // 미션이 완료되었다고 판단 (message는 이미 출력됨)
+                debugLog(`Mission judged as complete, breaking loop`);
                 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;
-                    }
-                }
+                // 미션이 완료되지 않았다고 판단되면 계속 진행
+                // (message는 이미 출력됨 - 사용자가 진행 상황 확인 가능)
+                debugLog(`Mission not complete, continuing...`);
 
                 // 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 플래그 설정
+                    improvementPointsIsAutoGenerated = true;
                     debugLog(`[_internal_only] Set improvementPointsIsAutoGenerated=true for whatUserShouldSay`);
-                    missionSolved = false;  // 완료되지 않았으므로 상위 루프 계속
-                    break;  // processOrchestratorResponses 루프 종료
+                    missionSolved = false;
+                    break;
                 } else {
                     // whatUserShouldSay가 없으면 빈 문자열로 계속 진행
                     improvementPoints = "";
                     debugLog(`Continuing mission without whatUserShouldSay`);
 
-                    // 세션 중단 확인 (continueOrchestratorConversation 호출 전)
+                    // 세션 중단 확인
                     if (sessionInterrupted) {
                         debugLog(`Session interrupted before continueOrchestratorConversation, breaking loop`);
                         break;
@@ -693,7 +746,7 @@ async function processOrchestratorResponses(params) {
                     try {
                         orchestratedResponse = await continueOrchestratorConversation();
                         debugLog(`Received response with ${orchestratedResponse?.output?.length || 0} outputs`);
-                        continue; // 루프 처음으로 돌아가서 새 응답 처리
+                        continue;
                     } catch (err) {
                         if (err.name === 'AbortError' || sessionInterrupted) {
                             debugLog(`Conversation aborted or interrupted: ${err.name}`);
@@ -706,11 +759,23 @@ async function processOrchestratorResponses(params) {
             }
         }
 
+        // Case 3: Function call이 없는 기타 경우
         if (!executedFunctionCall) {
             debugLog(`COMPLETION: No function call executed (other cases), breaking loop`);
+            if (pendingMessageOutput) {
+                debugLog(`Displaying pending message before completion`);
+                processMessageOutput(pendingMessageOutput, true);
+            }
             break;
         }
 
+        // Function call 실행 후 계속 진행하기 전에 pending message가 있으면 출력
+        // (function_call과 message가 같이 온 경우)
+        if (pendingMessageOutput) {
+            debugLog(`Displaying pending message before continuing (function_call + message case)`);
+            processMessageOutput(pendingMessageOutput, true);
+        }
+
         // continueOrchestratorConversation 호출
         debugLog(`Continuing orchestrator conversation for next iteration...`);
         try {
@@ -793,14 +858,17 @@ export async function runSession(options) {
         if (!sessionInterrupted) {
             sessionInterrupted = true;
             abortCurrentRequest(); // API 요청 즉시 중단
-            uiEvents.addErrorMessage('Session interrupted by user');
+            safeUiEvents.addErrorMessage('Session interrupted by user');
             debugLog('[runSession] Session interrupted by user');
         }
     };
-    uiEvents.on('session:interrupt', handleInterrupt);
+    safeUiEvents.on('session:interrupt', handleInterrupt);
 
     // 세션 시작 알림
-    uiEvents.sessionStart('Running agent session...');
+    safeUiEvents.sessionStart('Running agent session...');
+
+    // catch 블록에서도 접근 가능하도록 try 블록 밖에서 선언
+    let currentSessionData = null;
 
     try {
         // 현재 세션 데이터 생성
@@ -818,7 +886,7 @@ export async function runSession(options) {
         // previousSessions가 제공되지 않은 경우 자동으로 로드
         const sessionsToUse = previousSessions ?? await loadPreviousSessions(process.app_custom.sessionID);
 
-        const currentSessionData = createSessionData(process.app_custom.sessionID, mission);
+        currentSessionData = createSessionData(process.app_custom.sessionID, mission);
 
         // 파일 무결성 시스템에 현재 세션 ID 설정
         setCurrentSession(process.app_custom.sessionID);
@@ -864,6 +932,11 @@ export async function runSession(options) {
                 restoreTodosFromSession({ currentTodos: conversationState.currentTodos });
                 debugLog(`[runSession] Restored ${conversationState.currentTodos.length} todos from previous session`);
             }
+            // TrimmedFileReads 복원
+            if (conversationState.trimmedFileReads) {
+                restoreTrimmedFileReadsFromSession({ trimmedFileReads: conversationState.trimmedFileReads });
+                debugLog(`[runSession] Restored ${conversationState.trimmedFileReads.length} trimmed file reads from previous session`);
+            }
             // logSuccess('✓ Conversation state restored');
         } else {
             // logSystem('ℹ Starting with fresh conversation state');
@@ -886,6 +959,11 @@ export async function runSession(options) {
                 updateCurrentTodos([]);
                 debugLog(`[runSession] Starting fresh session - no todos in memory`);
             }
+
+            // 새 세션 시작 시 쉘의 작업 디렉토리를 프로젝트 루트로 리셋
+            // (이전 미션에서 cd한 디렉토리가 남아있지 않도록)
+            await resetShellCwd();
+            debugLog(`[runSession] Shell cwd reset to: ${process.cwd()}`);
         }
 
         // Python 사용 가능 여부 확인
@@ -899,8 +977,25 @@ export async function runSession(options) {
             ...GLOB_FUNCTIONS,
             ...RESPONSE_MESSAGE_FUNCTIONS,
             ...TODO_WRITE_FUNCTIONS,
+            ...SKILL_FUNCTIONS,  // 스킬 호출 도구
             ...mcpToolFunctions,
-            "bash": async (args) => execShellScript(args.script)
+            "bash": async (args) => {
+                if (args.background) {
+                    // 백그라운드 실행
+                    const result = await runInBackground(args.script);
+                    return {
+                        stdout: `Background process started: ${result.id} (pid: ${result.pid})`,
+                        stderr: '',
+                        code: 0,
+                        background: true,
+                        processId: result.id,
+                        pid: result.pid
+                    };
+                } else {
+                    // 일반 실행
+                    return execShellScript(args.script);
+                }
+            }
         };
 
         // Python이 있는 경우에만 Python 관련 도구 추가
@@ -1030,6 +1125,9 @@ export async function runSession(options) {
                 // Todos를 세션에 저장
                 saveTodosToSession(currentSessionData);
 
+                // TrimmedFileReads를 세션에 저장
+                saveTrimmedFileReadsToSession(currentSessionData);
+
                 debugLog(`[ITERATION ${iteration_count}] Saving session to history after completion_judge (mission_solved=${mission_solved})`);
                 await saveSessionToHistory(currentSessionData).catch(err => {
                     debugLog(`[ITERATION ${iteration_count}] Failed to save session after completion_judge: ${err.message}`);
@@ -1058,10 +1156,14 @@ export async function runSession(options) {
                 currentSessionData.orchestratorConversation = getOrchestratorConversation();
                 currentSessionData.orchestratorRequestOptions = null;
 
-                debugLog(`[ITERATION ${iteration_count}] Session interrupted - NOT saving session to history (disabled)`);
-                // await saveSessionToHistory(currentSessionData).catch(err => {
-                //     debugLog(`[ITERATION ${iteration_count}] Failed to save session: ${err.message}`);
-                // });
+                // 인터럽트 시에도 Todos와 TrimmedFileReads 저장 (다음 세션에서 복원 가능하도록)
+                saveTodosToSession(currentSessionData);
+                saveTrimmedFileReadsToSession(currentSessionData);
+
+                debugLog(`[ITERATION ${iteration_count}] Session interrupted - saving trimmedFileReads and todos`);
+                await saveSessionToHistory(currentSessionData).catch(err => {
+                    debugLog(`[ITERATION ${iteration_count}] Failed to save session on interrupt: ${err.message}`);
+                });
                 break;
             }
 
@@ -1093,8 +1195,23 @@ export async function runSession(options) {
                 const message = stallDetected
                     ? '⚠ Session ended due to orchestrator stall'
                     : '✅ No function calls detected - mission complete';
-                uiEvents.addSystemMessage(message);
+                safeUiEvents.addSystemMessage(message);
                 debugLog(`[ITERATION ${iteration_count}] ${message}`);
+
+                // completion_judge 없이 종료되는 경우에도 Todos와 TrimmedFileReads 저장
+                currentSessionData.completed_at = new Date().toISOString();
+                currentSessionData.mission_solved = true;
+                currentSessionData.iteration_count = iteration_count;
+                currentSessionData.toolUsageHistory = toolUsageHistory;
+                currentSessionData.orchestratorConversation = getOrchestratorConversation();
+                currentSessionData.orchestratorRequestOptions = null;
+                saveTodosToSession(currentSessionData);
+                saveTrimmedFileReadsToSession(currentSessionData);
+                debugLog(`[ITERATION ${iteration_count}] Saving session on no-function-call exit`);
+                await saveSessionToHistory(currentSessionData).catch(err => {
+                    debugLog(`[ITERATION ${iteration_count}] Failed to save session: ${err.message}`);
+                });
+
                 debugLog('========================================');
                 debugLog(`========== ITERATION ${iteration_count} END ==========`);
                 debugLog('========================================');
@@ -1134,12 +1251,17 @@ export async function runSession(options) {
         currentSessionData.orchestratorConversation = result.orchestratorConversation;
         currentSessionData.orchestratorRequestOptions = null; // 필요시 orchestrator에서 가져올 수 있음
 
-        debugLog(`[runSession] NOT saving final session to history (disabled - will only save after completion_judge) - sessionID: ${currentSessionData.sessionID}`);
+        // 루프 정상 종료 시에도 Todos와 TrimmedFileReads 저장
+        saveTodosToSession(currentSessionData);
+        saveTrimmedFileReadsToSession(currentSessionData);
+
+        debugLog(`[runSession] Saving final session to history - sessionID: ${currentSessionData.sessionID}`);
         debugLog(`[runSession] Session data size: ${JSON.stringify(currentSessionData).length} bytes`);
         debugLog(`[runSession] Final state - mission_solved: ${currentSessionData.mission_solved}, iteration_count: ${currentSessionData.iteration_count}`);
         debugLog(`[runSession] Tool usage history entries: ${currentSessionData.toolUsageHistory.length}`);
-        // 최종 세션 히스토리에 저장 (중복 저장이지만 최신 상태 보장) - DISABLED
-        // await saveSessionToHistory(currentSessionData);
+        await saveSessionToHistory(currentSessionData).catch(err => {
+            debugLog(`[runSession] Failed to save final session: ${err.message}`);
+        });
 
         debugLog('========================================');
         debugLog('========== runSession END ==========');
@@ -1155,9 +1277,13 @@ export async function runSession(options) {
         // 에러 메시지를 history에 표시 (한 번에 통합)
         const detailMessage = error?.error?.message || errorMessage;
 
+        // debug 설정 확인 (SHOW_API_PAYLOAD가 true면 verbose 모드)
+        const settings = await loadSettings().catch(() => ({}));
+        const isDebugMode = settings?.SHOW_API_PAYLOAD === true;
+
         let consolidatedErrorMessage;
-        if (ERROR_VERBOSITY === 'verbose') {
-            // 상세 모드: 모든 에러 정보 표시
+        if (isDebugMode) {
+            // 상세 모드 (/debug on): 모든 에러 정보 표시
             consolidatedErrorMessage = [
                 `[Session] Internal session error: ${errorType}`,
                 `  ├─ Message: ${detailMessage}`,
@@ -1168,19 +1294,48 @@ export async function runSession(options) {
                 `  └─ Stack trace: ${errorStack}`
             ].join('\n');
         } else {
-            // 간결 모드 (기본값): 에러 메시지만 표시
-            consolidatedErrorMessage = `[Session] Internal session error: ${detailMessage}`;
+            // 간결 모드 (기본값, /debug off): 사용자 친화적 에러 메시지
+            const statusNum = parseInt(errorStatus) || parseInt(error?.status);
+            let userFriendlyMessage;
+
+            if (statusNum === 503 || detailMessage.includes('503')) {
+                userFriendlyMessage = 'AI 서버가 일시적으로 응답하지 않습니다. 잠시 후 다시 시도해주세요.';
+            } else if (statusNum === 500 || detailMessage.includes('500')) {
+                userFriendlyMessage = 'AI 서버에서 오류가 발생했습니다. 잠시 후 다시 시도해주세요.';
+            } else if (statusNum === 401 || errorCode === 'invalid_api_key') {
+                userFriendlyMessage = 'API 키가 유효하지 않습니다. 설정을 확인해주세요.';
+            } else if (statusNum === 429) {
+                userFriendlyMessage = '요청 한도를 초과했습니다. 잠시 후 다시 시도해주세요.';
+            } else if (errorType === 'AbortError' || errorMessage.includes('aborted')) {
+                userFriendlyMessage = '요청이 취소되었습니다.';
+            } else {
+                userFriendlyMessage = '오류가 발생했습니다. 문제가 지속되면 /debug on 으로 상세 정보를 확인하세요.';
+            }
+
+            consolidatedErrorMessage = `[Session] ${userFriendlyMessage}`;
         }
 
-        uiEvents.addErrorMessage(consolidatedErrorMessage);
+        safeUiEvents.addErrorMessage(consolidatedErrorMessage);
+
+        // 에러 발생 시에도 Todos와 TrimmedFileReads 저장 시도
+        if (currentSessionData) {
+            currentSessionData.completed_at = new Date().toISOString();
+            currentSessionData.mission_solved = false;
+            saveTodosToSession(currentSessionData);
+            saveTrimmedFileReadsToSession(currentSessionData);
+            debugLog(`[runSession] Saving session on error`);
+            await saveSessionToHistory(currentSessionData).catch(err => {
+                debugLog(`[runSession] Failed to save session on error: ${err.message}`);
+            });
+        }
 
         // 에러를 throw하지 않고 정상적으로 종료
         return null;
     } finally {
         // 세션 중단 이벤트 리스너 제거
-        uiEvents.off('session:interrupt', handleInterrupt);
+        safeUiEvents.off('session:interrupt', handleInterrupt);
 
         // 세션 종료 알림
-        uiEvents.sessionEnd();
+        safeUiEvents.sessionEnd();
     }
 }

package/src/system/session_memory.js

@@ -4,6 +4,7 @@ import { join, resolve } from 'path';
 import chalk from 'chalk';
 import { formatToolCall, formatToolResult, getToolDisplayName, getToolDisplayConfig } from './tool_registry.js';
 import { createDebugLogger } from '../util/debug_log.js';
+import { getTrimmedFileReads, setTrimmedFileReads } from './conversation_trimmer.js';
 
 const MAX_HISTORY_SESSIONS = 1; // 최대 보관 세션 수
 
@@ -11,7 +12,7 @@ const debugLog = createDebugLogger('session_memory.log', 'session_memory');
 
 // 현재 작업 디렉토리 기준 세션 디렉토리 경로 생성
 function getSessionDir(sessionID) {
-    return join(process.cwd(), '.aiexe', sessionID);
+    return join(process.cwd(), '.aiexe', 'sessions', sessionID);
 }
 
 // 세션 히스토리 파일 경로 생성
@@ -150,7 +151,8 @@ export function getLastConversationState(sessions) {
     return {
         orchestratorConversation: lastSession.orchestratorConversation || [],
         orchestratorRequestOptions: lastSession.orchestratorRequestOptions || null,
-        currentTodos: lastSession.currentTodos || []
+        currentTodos: lastSession.currentTodos || [],
+        trimmedFileReads: lastSession.trimmedFileReads || []
     };
 }
 
@@ -450,3 +452,29 @@ export function restoreTodosFromSession(sessionData) {
         currentSessionTodos = [];
     }
 }
+
+/**
+ * 세션 데이터에 trimmedFileReads를 저장
+ * @param {Object} sessionData - 세션 데이터 객체
+ */
+export function saveTrimmedFileReadsToSession(sessionData) {
+    debugLog('========== saveTrimmedFileReadsToSession ==========');
+    const trimmedFiles = getTrimmedFileReads();
+    debugLog(`Saving ${trimmedFiles.length} trimmed file reads to session`);
+    sessionData.trimmedFileReads = trimmedFiles;
+}
+
+/**
+ * 세션 데이터에서 trimmedFileReads를 복원
+ * @param {Object} sessionData - 세션 데이터 객체
+ */
+export function restoreTrimmedFileReadsFromSession(sessionData) {
+    debugLog('========== restoreTrimmedFileReadsFromSession ==========');
+    if (sessionData && Array.isArray(sessionData.trimmedFileReads)) {
+        debugLog(`Restoring ${sessionData.trimmedFileReads.length} trimmed file reads from session`);
+        setTrimmedFileReads(sessionData.trimmedFileReads);
+    } else {
+        debugLog('No trimmed file reads to restore');
+        setTrimmedFileReads([]);
+    }
+}