aiexecode 1.0.111 → 1.0.112

package/src/ai_based/orchestrator.js

@@ -2,10 +2,10 @@ import dotenv from "dotenv";
 // 이 파일은 계획을 실제 행동으로 옮기기 위해 어떤 도구를 호출할지 결정합니다.
 import path from 'path';
 import { truncateWithOmit } from "../util/text_formatter.js";
-import { createSystemMessage, createTodoReminder, createSystemReminder } from "../util/prompt_loader.js";
+import { createSystemMessage, createTodoReminder, createSystemReminder, createTrimmedFileReminder } from "../util/prompt_loader.js";
 import { request, shouldRetryWithTrim, getModelForProvider } from "../system/ai_request.js";
 import { supportsCaching } from "../config/ai_models.js";
-import { cleanupOrphanOutputs, trimConversation } from "../system/conversation_trimmer.js";
+import { cleanupOrphanOutputs, trimConversation, getTrimmedFileReads, clearTrimmedFileReads } from "../system/conversation_trimmer.js";
 import { runPythonCodeSchema, bashSchema } from "../system/code_executer.js";
 import { readFileSchema, readFileRangeSchema } from "../tools/file_reader.js";
 import { writeFileSchema, editFileRangeSchema, editFileReplaceSchema } from "../tools/code_editor.js";
@@ -99,6 +99,20 @@ async function ensureConversationInitialized() {
             debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos as separate block (uncached)`);
         }
 
+        // Trim된 파일 읽기 알림 추가 (파일 경로 알림 기능)
+        const trimmedFiles = getTrimmedFileReads();
+        if (trimmedFiles.length > 0) {
+            const trimmedFileReminder = createTrimmedFileReminder(trimmedFiles);
+            if (trimmedFileReminder) {
+                contentBlocks.push({
+                    type: "input_text",
+                    text: trimmedFileReminder
+                    // cache_control 없음 - 동적 데이터이므로
+                });
+                debugLog(`[ensureConversationInitialized] Added trimmed file reminder for ${trimmedFiles.length} files (uncached)`);
+            }
+        }
+
         systemMessageEntry = {
             role: "system",
             content: contentBlocks
@@ -133,6 +147,16 @@ async function ensureConversationInitialized() {
             debugLog(`[ensureConversationInitialized] Added ${currentTodos.length} todos to system message`);
         }
 
+        // Trim된 파일 읽기 알림 추가 (파일 경로 알림 기능)
+        const trimmedFiles = getTrimmedFileReads();
+        if (trimmedFiles.length > 0) {
+            const trimmedFileReminder = createTrimmedFileReminder(trimmedFiles);
+            if (trimmedFileReminder) {
+                systemMessageText += '\n\n' + trimmedFileReminder;
+                debugLog(`[ensureConversationInitialized] Added trimmed file reminder for ${trimmedFiles.length} files`);
+            }
+        }
+
         systemMessageEntry = {
             role: "system",
             content: [
@@ -178,6 +202,7 @@ function appendResponseToConversation(response) {
 export function resetOrchestratorConversation() {
     orchestratorConversation.length = 0;
     orchestratorRequestOptions = null;
+    clearTrimmedFileReads(); // 세션 초기화 시 trim된 파일 목록도 초기화
 }
 
 export function getOrchestratorConversation() {

package/src/system/code_executer.js

@@ -581,14 +581,42 @@ export const runPythonCodeSchema = {
 
 export const bashSchema = {
     name: "bash",
-    description: "Executes bash shell commands. Use -y or -f flags to avoid user prompts. Chain commands with && for sequential execution. This tool handles ALL file system operations (create/delete/move/copy files and directories, check file existence, list directory contents), system operations, git commands, package management, and running CLI tools.",
+    description: `Executes bash shell commands with optional timeout.
+
+IMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file reading/searching operations - use specialized tools instead.
+
+Output Limits:
+- stdout is truncated to 8000 characters
+- stderr is truncated to 4000 characters
+- Commands timing out after 20 minutes will be terminated
+- If output exceeds limits, only the first 70% and last 30% are shown with an omission notice
+
+Avoid These Commands (Use Specialized Tools Instead):
+- File reading: Use read_file or read_file_range instead of cat, head, tail
+- Content search: Use ripgrep instead of grep or rg
+- File search: Use glob_search instead of find
+- File editing: Use edit_file_replace or write_file instead of sed, awk, echo >
+
+When Output May Be Large:
+- Limit output with: command | head -50
+- Save to file: command > output.log 2>&1
+- Filter results: command | grep "pattern"
+- Use quiet/minimal flags when available
+
+Best Practices:
+- Use auto-confirm flags: -y, -f, --yes, --quiet
+- Chain commands with && for sequential execution
+- Avoid interactive commands that require user input
+- For calculations, use non-interactive bc or Python (never mental arithmetic)
+
+This tool handles: file system operations (mkdir, rm, mv, cp, chmod), git commands, package management (npm, pip), and CLI tools.`,
     parameters: {
         type: "object",
         required: ["script"],
         properties: {
             script: {
                 type: "string",
-                description: "Bash script to execute. Will be saved to a temporary file and run with bash. Use standard bash commands like: mkdir, rm, mv, cp, ls, test, find, chmod, chown, etc."
+                description: "Bash script to execute. Will be saved to a temporary file and run with bash. Keep scripts concise and output-limited to avoid truncation."
             }
         },
         additionalProperties: false

package/src/system/conversation_trimmer.js

@@ -6,9 +6,100 @@
  */
 
 import { createDebugLogger } from "../util/debug_log.js";
+import { clearFileContentHash } from "./file_integrity.js";
 
 const debugLog = createDebugLogger('conversation_trimmer.log', 'conversation_trimmer');
 
+/**
+ * Trim 과정에서 삭제된 파일 읽기 정보를 추적합니다.
+ * Claude Code 스타일의 "파일 경로 알림" 기능을 위해 사용됩니다.
+ *
+ * 예: "Note: /path/to/file was read before trimming, but contents are too large to include."
+ */
+const trimmedFileReads = new Set();
+
+/**
+ * trimmedFileReads의 최대 개수 제한
+ * 너무 많은 파일이 추적되면 system-reminder가 길어져 토큰 낭비 발생
+ */
+const MAX_TRIMMED_FILE_READS = 50;
+
+/**
+ * Trim된 파일 읽기 목록을 반환합니다.
+ * @returns {Array<string>} 삭제된 파일 경로 배열
+ */
+export function getTrimmedFileReads() {
+    return Array.from(trimmedFileReads);
+}
+
+/**
+ * Trim된 파일 읽기 목록을 초기화합니다.
+ */
+export function clearTrimmedFileReads() {
+    trimmedFileReads.clear();
+    debugLog(`[clearTrimmedFileReads] Cleared trimmed file reads`);
+}
+
+/**
+ * Trim된 파일 읽기 목록을 설정합니다 (세션 복원용).
+ * 최대 개수 제한을 적용합니다.
+ * @param {Array<string>} paths - 복원할 파일 경로 배열
+ */
+export function setTrimmedFileReads(paths) {
+    trimmedFileReads.clear();
+    if (Array.isArray(paths)) {
+        // 최대 개수만큼만 추가 (최근 것 우선)
+        const pathsToAdd = paths.slice(-MAX_TRIMMED_FILE_READS);
+        pathsToAdd.forEach(path => trimmedFileReads.add(path));
+        debugLog(`[setTrimmedFileReads] Restored ${trimmedFileReads.size} trimmed file reads`);
+    }
+}
+
+/**
+ * 파일이 다시 읽혔을 때 trimmedFileReads에서 제거합니다.
+ * 파일을 다시 읽으면 대화에 내용이 있으므로 알림이 필요 없습니다.
+ * @param {string} filePath - 다시 읽은 파일 경로
+ */
+export function markFileAsReRead(filePath) {
+    if (trimmedFileReads.has(filePath)) {
+        trimmedFileReads.delete(filePath);
+        debugLog(`[markFileAsReRead] Removed from trimmed file reads: ${filePath}`);
+    }
+}
+
+/**
+ * 대화 항목에서 파일 읽기 정보를 추출합니다.
+ * @param {Object} entry - 대화 항목
+ * @returns {Array<string>} 추출된 파일 경로 배열
+ */
+function extractFilePathsFromEntry(entry) {
+    const filePaths = [];
+
+    if (!entry) return filePaths;
+
+    try {
+        // function_call_output에서 파일 읽기 결과 추출
+        if (entry.type === 'function_call_output' && entry.output) {
+            const output = typeof entry.output === 'string' ? JSON.parse(entry.output) : entry.output;
+
+            // read_file, read_file_range 도구의 결과인지 확인
+            if (output.tool === 'read_file' || output.tool === 'read_file_range') {
+                const result = output.original_result || output;
+                // 성공적으로 읽은 파일만 추적 (실패한 파일은 알림 불필요)
+                if (result.target_file_path && result.operation_successful === true) {
+                    filePaths.push(result.target_file_path);
+                    debugLog(`[extractFilePathsFromEntry] Found file path: ${result.target_file_path}`);
+                }
+            }
+        }
+    } catch (e) {
+        // JSON 파싱 실패 등은 무시
+        debugLog(`[extractFilePathsFromEntry] Failed to parse entry: ${e.message}`);
+    }
+
+    return filePaths;
+}
+
 /**
  * 대화에서 특정 call_id와 관련된 모든 항목을 제거합니다.
  *
@@ -103,6 +194,9 @@ export function cleanupOrphanOutputs(conversation) {
  * 컨텍스트 윈도우 초과 시 대화를 줄입니다.
  * 시스템 프롬프트(인덱스 0)를 제외한 가장 오래된 항목(인덱스 1)을 제거합니다.
  *
+ * 삭제되는 항목에서 파일 읽기 정보를 추출하여 trimmedFileReads에 저장합니다.
+ * 이 정보는 나중에 system-reminder로 에이전트에게 알려줄 때 사용됩니다.
+ *
  * @param {Array} conversation - 대화 배열
  * @returns {boolean} 제거 성공 여부
  */
@@ -119,15 +213,53 @@ export function trimConversation(conversation) {
 
     debugLog(`[trimConversation] Target entry at index 1: type=${targetEntry?.type}, call_id=${targetCallId}`);
 
+    // 삭제 전에 파일 경로 추출
+    const filePaths = extractFilePathsFromEntry(targetEntry);
+    filePaths.forEach(path => {
+        // 최대 개수 초과 시 가장 오래된 항목 제거
+        if (trimmedFileReads.size >= MAX_TRIMMED_FILE_READS) {
+            const oldest = trimmedFileReads.values().next().value;
+            trimmedFileReads.delete(oldest);
+            debugLog(`[trimConversation] Removed oldest from trimmed file reads: ${oldest}`);
+        }
+        trimmedFileReads.add(path);
+        debugLog(`[trimConversation] Added to trimmed file reads: ${path}`);
+
+        // file_integrity에서 해시도 삭제 (에이전트가 파일 내용을 모르므로 편집 불가하게)
+        const hashCleared = clearFileContentHash(path);
+        debugLog(`[trimConversation] Cleared content hash for ${path}: ${hashCleared}`);
+    });
+
     // 먼저 인덱스 1 항목 제거
     conversation.splice(1, 1);
     debugLog(`[trimConversation] Removed entry at index 1`);
 
     // call_id가 있으면 같은 call_id를 가진 다른 항목들도 제거
     if (targetCallId) {
+        // 삭제 전에 관련 항목들에서 파일 경로 추출
+        for (const entry of conversation) {
+            if (entry && entry.call_id === targetCallId) {
+                const paths = extractFilePathsFromEntry(entry);
+                paths.forEach(path => {
+                    // 최대 개수 초과 시 가장 오래된 항목 제거
+                    if (trimmedFileReads.size >= MAX_TRIMMED_FILE_READS) {
+                        const oldest = trimmedFileReads.values().next().value;
+                        trimmedFileReads.delete(oldest);
+                        debugLog(`[trimConversation] Removed oldest from trimmed file reads: ${oldest}`);
+                    }
+                    trimmedFileReads.add(path);
+                    debugLog(`[trimConversation] Added related file to trimmed reads: ${path}`);
+
+                    // file_integrity에서 해시도 삭제 (에이전트가 파일 내용을 모르므로 편집 불가하게)
+                    const hashCleared = clearFileContentHash(path);
+                    debugLog(`[trimConversation] Cleared content hash for ${path}: ${hashCleared}`);
+                });
+            }
+        }
         removeEntriesWithCallId(conversation, targetCallId);
     }
 
     debugLog(`[trimConversation] Trim completed. New conversation length: ${conversation.length}`);
+    debugLog(`[trimConversation] Total trimmed file reads: ${trimmedFileReads.size}`);
     return true;
 }

package/src/system/file_integrity.js

@@ -112,6 +112,38 @@ class FileIntegrityTracker {
         return sessionFiles.get(filePath) || null;
     }
 
+    /**
+     * 파일 콘텐츠 해시를 삭제합니다
+     * 대화가 trim되어 에이전트가 파일 내용을 알 수 없게 되었을 때 호출됩니다.
+     * 이렇게 하면 에이전트가 파일을 다시 읽기 전까지 편집할 수 없습니다.
+     * @param {string} sessionID - 세션 ID
+     * @param {string} filePath - 파일 경로
+     * @returns {boolean} 삭제 성공 여부
+     */
+    clearContentHash(sessionID, filePath) {
+        debugLog(`========== clearContentHash START ==========`);
+        debugLog(`sessionID: ${sessionID}`);
+        debugLog(`filePath: ${filePath}`);
+
+        const sessionFiles = this.contentHashes.get(sessionID);
+        if (!sessionFiles) {
+            debugLog(`No session map found for session: ${sessionID}`);
+            debugLog(`========== clearContentHash END (NO SESSION) ==========`);
+            return false;
+        }
+
+        const existed = sessionFiles.has(filePath);
+        if (existed) {
+            sessionFiles.delete(filePath);
+            debugLog(`Hash deleted for file: ${filePath}`);
+        } else {
+            debugLog(`No hash found for file: ${filePath}`);
+        }
+
+        debugLog(`========== clearContentHash END ==========`);
+        return existed;
+    }
+
     /**
      * 파일 편집 전 무결성을 검증합니다
      * @param {string} sessionID - 세션 ID
@@ -347,6 +379,31 @@ export async function assertFileIntegrity(filePath) {
     debugLog('========== assertFileIntegrity (export wrapper) END ==========');
 }
 
+/**
+ * 파일 콘텐츠 해시를 삭제합니다 (현재 세션 기준)
+ * 대화가 trim되어 에이전트가 파일 내용을 알 수 없게 되었을 때 호출됩니다.
+ * @param {string} filePath - 파일 경로
+ * @returns {boolean} 삭제 성공 여부
+ */
+export function clearFileContentHash(filePath) {
+    debugLog(`========== clearFileContentHash (export wrapper) START ==========`);
+    debugLog(`filePath: ${filePath}`);
+
+    const sessionID = fileIntegrityTracker.getCurrentSession();
+    debugLog(`Current session ID: ${sessionID || 'NULL'}`);
+
+    if (!sessionID) {
+        debugLog(`ERROR: No current session set, cannot clear hash`);
+        debugLog('========== clearFileContentHash (export wrapper) END ==========');
+        return false;
+    }
+
+    const result = fileIntegrityTracker.clearContentHash(sessionID, filePath);
+    debugLog(`Hash clear result: ${result}`);
+    debugLog('========== clearFileContentHash (export wrapper) END ==========');
+    return result;
+}
+
 /**
  * 파일 스냅샷을 저장합니다 (현재 세션 기준)
  * @param {string} filePath - 파일 경로

package/src/system/session.js

@@ -12,7 +12,7 @@ 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";
@@ -887,6 +887,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');
@@ -1054,6 +1059,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}`);
@@ -1082,10 +1090,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;
             }
 
@@ -1119,6 +1131,21 @@ export async function runSession(options) {
                     : '✅ No function calls detected - mission complete';
                 uiEvents.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('========================================');
@@ -1158,12 +1185,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 ==========');
@@ -1198,6 +1230,18 @@ export async function runSession(options) {
 
         uiEvents.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 {

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([]);
+    }
+}