hdsp-jupyter-extension 2.0.6__py3-none-any.whl → 2.0.7__py3-none-any.whl

jupyter_ext/labextension/static/{lib_index_js.a223ea20056954479ae9.js → lib_index_js.29cf4312af19e86f82af.js}

@@ -205,30 +205,42 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
     // Todo list state (from TodoListMiddleware)
     const [todos, setTodos] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)([]);
     const [isTodoExpanded, setIsTodoExpanded] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(false);
+    // Agent thread ID for context persistence across cycles (SummarizationMiddleware support)
+    const [agentThreadId, setAgentThreadId] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
+    // Rejection feedback mode - when user clicks reject, wait for optional feedback
+    const [isRejectionMode, setIsRejectionMode] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(false);
+    const [pendingRejectionInterrupt, setPendingRejectionInterrupt] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
     const interruptMessageIdRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
     const approvalPendingRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(false);
     const pendingToolCallsRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)([]);
     const handledToolCallKeysRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(new Set());
+    const isNotebookWidget = (widget) => {
+        if (!widget)
+            return false;
+        if (widget instanceof _jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_2__.NotebookPanel)
+            return true;
+        const model = widget?.content?.model;
+        return Boolean(model && (model.cells || model.sharedModel?.cells));
+    };
     const getActiveNotebookPanel = () => {
         const app = window.jupyterapp;
-        if (app?.shell?.currentWidget) {
-            const currentWidget = app.shell.currentWidget;
-            if (currentWidget instanceof _jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_2__.NotebookPanel) {
-                return currentWidget;
-            }
-            if ('content' in currentWidget && currentWidget.content?.model) {
-                return currentWidget;
-            }
+        const currentWidget = app?.shell?.currentWidget;
+        if (isNotebookWidget(currentWidget)) {
+            return currentWidget;
         }
-        return notebookTracker?.currentWidget || null;
+        if (notebookTracker?.currentWidget && isNotebookWidget(notebookTracker.currentWidget)) {
+            return notebookTracker.currentWidget;
+        }
+        return null;
     };
     const insertCell = (notebook, cellType, source) => {
         const model = notebook.content?.model;
-        if (!model?.sharedModel) {
+        const cellCount = model?.cells?.length ?? model?.sharedModel?.cells?.length;
+        if (!model?.sharedModel || cellCount === undefined) {
             console.warn('[AgentPanel] Notebook model not ready for insert');
             return null;
         }
-        const insertIndex = model.cells.length;
+        const insertIndex = cellCount;
         model.sharedModel.insertCell(insertIndex, {
             cell_type: cellType,
             source
@@ -236,6 +248,21 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         notebook.content.activeCellIndex = insertIndex;
         return insertIndex;
     };
+    const deleteCell = (notebook, cellIndex) => {
+        const model = notebook.content?.model;
+        const cellCount = model?.cells?.length ?? model?.sharedModel?.cells?.length;
+        if (!model?.sharedModel || cellCount === undefined) {
+            console.warn('[AgentPanel] Notebook model not ready for delete');
+            return false;
+        }
+        if (cellIndex < 0 || cellIndex >= cellCount) {
+            console.warn('[AgentPanel] Invalid cell index for delete:', cellIndex);
+            return false;
+        }
+        model.sharedModel.deleteCell(cellIndex);
+        console.log('[AgentPanel] Deleted rejected cell at index:', cellIndex);
+        return true;
+    };
     const executeCell = async (notebook, cellIndex) => {
         try {
             await notebook.sessionContext.ready;
@@ -347,6 +374,7 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         approvalPendingRef.current = pendingToolCallsRef.current.length > 0;
         return next;
     };
+    const getAutoApproveEnabled = (config) => (Boolean(config?.autoApprove));
     const queueApprovalCell = (code) => {
         const notebook = getActiveNotebookPanel();
         if (!notebook) {
@@ -750,6 +778,7 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         }
     };
     // Python 에러 메시지 처리 및 파일 수정 요청
+    // Returns true if handled, false if should fall back to regular chat
     const handlePythonErrorFix = async (errorMessage) => {
         console.log('[AgentPanel] Handling Python error fix request');
         // 1. 에러가 발생한 파일 경로 추출
@@ -761,8 +790,8 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         console.log('[AgentPanel] All files:', allFilePaths);
         if (!errorFilePath && !mainFilePath) {
             // 파일 경로를 찾을 수 없으면 일반 채팅으로 처리
-            console.log('[AgentPanel] No file path found, using regular chat');
-            return;
+            console.log('[AgentPanel] No file path found, falling back to regular chat stream');
+            return false;
         }
         // 2. 주요 파일 내용 로드
         const targetFile = errorFilePath || mainFilePath;
@@ -783,7 +812,7 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
                 console.error('[AgentPanel] File fix API error:', error);
                 addErrorMessage('파일 수정 요청 실패: ' + error.message);
             }
-            return;
+            return true; // Handled (even if failed)
         }
         // 3. 관련 파일들 (imports) 로드
         const localImports = extractLocalImports(mainContent);
@@ -820,10 +849,12 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             setIsLoading(true);
             const result = await apiService.fileAction(request);
             handleFileFixResponse(result.response, result.fixedFiles);
+            return true; // Successfully handled
         }
         catch (error) {
             console.error('[AgentPanel] File fix API error:', error);
             addErrorMessage('파일 수정 요청 실패: ' + error.message);
+            return true; // Handled (even if failed)
         }
         finally {
             setIsLoading(false);
@@ -972,6 +1003,203 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
         }
     }, [messages, isStreaming]);
+    const handleNextItemSelection = async (nextText) => {
+        const trimmed = nextText.trim();
+        if (!trimmed)
+            return;
+        // Check if there's a pending interrupt (HITL approval waiting)
+        const hasPendingInterrupt = interruptData !== null;
+        // Check if all todos are completed
+        const allTodosCompleted = todos.length === 0 || todos.every(t => t.status === 'completed');
+        // Block if there's a pending interrupt OR if agent is running with incomplete todos
+        // Allow if all todos are completed even if streaming is finishing up
+        if (hasPendingInterrupt || (isAgentRunning && !allTodosCompleted)) {
+            showNotification('다른 작업이 진행 중입니다. 완료 후 다시 시도해주세요.', 'warning');
+            return;
+        }
+        await sendChatMessage({
+            displayContent: trimmed,
+            clearInput: true
+        });
+    };
+    const sendChatMessage = async ({ displayContent, llmPrompt, textarea, clearInput = true }) => {
+        const displayContentText = displayContent || (llmPrompt ? '셀 분석 요청' : '');
+        if (!displayContentText && !llmPrompt)
+            return;
+        // Check if API key is configured before sending
+        let currentConfig = llmConfig;
+        if (!currentConfig) {
+            // Config not loaded yet, try to load from localStorage
+            currentConfig = (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getLLMConfig)() || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getDefaultLLMConfig)();
+            setLlmConfig(currentConfig);
+        }
+        // Check API key using ApiKeyManager
+        const hasApiKey = (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.hasValidApiKey)(currentConfig);
+        const autoApproveEnabled = getAutoApproveEnabled(currentConfig);
+        if (!hasApiKey) {
+            // Show error message and open settings
+            const providerName = currentConfig?.provider || 'LLM';
+            const errorMessage = {
+                id: makeMessageId(),
+                role: 'assistant',
+                content: `API Key가 설정되지 않았습니다.\n\n${providerName === 'gemini' ? 'Gemini' : providerName === 'openai' ? 'OpenAI' : 'vLLM'} API Key를 먼저 설정해주세요.\n\n설정 버튼을 클릭하여 API Key를 입력하세요.`,
+                timestamp: Date.now()
+            };
+            setMessages(prev => [...prev, errorMessage]);
+            setShowSettings(true);
+            return;
+        }
+        const userMessage = {
+            id: makeMessageId(),
+            role: 'user',
+            content: displayContentText,
+            timestamp: Date.now()
+        };
+        setMessages(prev => [...prev, userMessage]);
+        if (clearInput && displayContentText) {
+            setInput('');
+        }
+        setIsLoading(true);
+        setIsStreaming(true);
+        // Clear todos only when starting a new task (all completed or no todos)
+        // Keep todos if there are pending/in_progress items (continuation of current task)
+        const hasActiveTodos = todos.some(t => t.status === 'pending' || t.status === 'in_progress');
+        if (!hasActiveTodos) {
+            setTodos([]);
+        }
+        setDebugStatus(null);
+        // Clear the data attribute and ref after using it
+        if (textarea && llmPrompt) {
+            textarea.removeAttribute('data-llm-prompt');
+            pendingLlmPromptRef.current = null;
+        }
+        // Create assistant message ID for streaming updates
+        const assistantMessageId = makeMessageId('assistant');
+        let streamedContent = '';
+        setStreamingMessageId(assistantMessageId);
+        // Add empty assistant message that will be updated during streaming
+        const initialAssistantMessage = {
+            id: assistantMessageId,
+            role: 'assistant',
+            content: '',
+            timestamp: Date.now()
+        };
+        setMessages(prev => [...prev, initialAssistantMessage]);
+        try {
+            // Use LLM prompt if available, otherwise use the display content
+            const messageToSend = llmPrompt || displayContentText;
+            console.log('[AgentPanel] Sending message with agentThreadId:', agentThreadId);
+            await apiService.sendMessageStream({
+                message: messageToSend,
+                conversationId: conversationId || undefined,
+                llmConfig: currentConfig // Include API keys with request
+            }, 
+            // onChunk callback - update message content incrementally
+            (chunk) => {
+                streamedContent += chunk;
+                setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
+                    ? { ...msg, content: streamedContent }
+                    : msg));
+            }, 
+            // onMetadata callback - update conversationId and metadata
+            (metadata) => {
+                if (metadata.conversationId && !conversationId) {
+                    setConversationId(metadata.conversationId);
+                }
+                if (metadata.provider || metadata.model) {
+                    setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
+                        ? {
+                            ...msg,
+                            metadata: {
+                                ...msg.metadata,
+                                provider: metadata.provider,
+                                model: metadata.model
+                            }
+                        }
+                        : msg));
+                }
+            }, 
+            // onDebug callback - show debug status in gray
+            (status) => {
+                setDebugStatus(status);
+            }, 
+            // onInterrupt callback - show approval dialog
+            (interrupt) => {
+                approvalPendingRef.current = true;
+                // Capture threadId from interrupt for context persistence
+                if (interrupt.threadId && !agentThreadId) {
+                    setAgentThreadId(interrupt.threadId);
+                    console.log('[AgentPanel] Captured agentThreadId from interrupt:', interrupt.threadId);
+                }
+                // Auto-approve search/file/resource tools - execute immediately without user interaction
+                if (interrupt.action === 'search_workspace_tool'
+                    || interrupt.action === 'search_notebook_cells_tool'
+                    || interrupt.action === 'check_resource_tool'
+                    || interrupt.action === 'list_files_tool'
+                    || interrupt.action === 'read_file_tool') {
+                    void handleAutoToolInterrupt(interrupt);
+                    return;
+                }
+                if (autoApproveEnabled) {
+                    void resumeFromInterrupt(interrupt, 'approve');
+                    return;
+                }
+                if (interrupt.action === 'jupyter_cell_tool' && interrupt.args?.code) {
+                    const shouldQueue = shouldExecuteInNotebook(interrupt.args.code);
+                    if (isAutoApprovedCode(interrupt.args.code)) {
+                        if (shouldQueue) {
+                            queueApprovalCell(interrupt.args.code);
+                        }
+                        void resumeFromInterrupt(interrupt, 'approve');
+                        return;
+                    }
+                    if (shouldQueue) {
+                        queueApprovalCell(interrupt.args.code);
+                    }
+                }
+                setInterruptData(interrupt);
+                upsertInterruptMessage(interrupt);
+                setIsLoading(false);
+                setIsStreaming(false);
+            }, 
+            // onTodos callback - update todo list UI
+            (newTodos) => {
+                setTodos(newTodos);
+            }, 
+            // onDebugClear callback - clear debug status
+            () => {
+                setDebugStatus(null);
+            }, 
+            // onToolCall callback - add cells to notebook
+            handleToolCall, 
+            // onComplete callback - capture thread_id for context persistence
+            (data) => {
+                if (data.threadId) {
+                    setAgentThreadId(data.threadId);
+                    console.log('[AgentPanel] Captured agentThreadId for context persistence:', data.threadId);
+                }
+            }, 
+            // threadId - pass existing thread_id to continue context
+            agentThreadId || undefined);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to send message';
+            setDebugStatus(`오류: ${message}`);
+            // Update the assistant message with error
+            setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
+                ? {
+                    ...msg,
+                    content: streamedContent + `\n\nError: ${message}`
+                }
+                : msg));
+        }
+        finally {
+            setIsLoading(false);
+            setIsStreaming(false);
+            setStreamingMessageId(null);
+            // Keep completed todos visible after the run
+        }
+    };
     // Extract and store code blocks from messages, setup button listeners
     (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
         // Use a small delay to ensure DOM is updated after message rendering
@@ -1014,6 +1242,40 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             // Use event delegation - attach single listener to container
             const handleContainerClick = async (e) => {
                 const target = e.target;
+                const nextItem = target.closest('.jp-next-items-item');
+                if (nextItem) {
+                    e.stopPropagation();
+                    e.preventDefault();
+                    const subject = nextItem.querySelector('.jp-next-items-subject')?.textContent?.trim() || '';
+                    const description = nextItem.querySelector('.jp-next-items-description')?.textContent?.trim() || '';
+                    const nextText = subject && description
+                        ? `${subject}\n\n${description}`
+                        : (subject || description);
+                    if (nextText) {
+                        void handleNextItemSelection(nextText);
+                    }
+                    return;
+                }
+                // Handle expand/collapse button
+                if (target.classList.contains('code-block-toggle') || target.closest('.code-block-toggle')) {
+                    const button = target.classList.contains('code-block-toggle')
+                        ? target
+                        : target.closest('.code-block-toggle');
+                    e.stopPropagation();
+                    e.preventDefault();
+                    const container = button.closest('.code-block-container');
+                    if (!container)
+                        return;
+                    const isExpanded = container.classList.toggle('is-expanded');
+                    button.setAttribute('aria-expanded', String(isExpanded));
+                    button.setAttribute('title', isExpanded ? '접기' : '전체 보기');
+                    button.setAttribute('aria-label', isExpanded ? '접기' : '전체 보기');
+                    const icon = button.querySelector('.code-block-toggle-icon');
+                    if (icon) {
+                        icon.textContent = isExpanded ? '▴' : '▾';
+                    }
+                    return;
+                }
                 // Handle copy button
                 if (target.classList.contains('code-block-copy') || target.closest('.code-block-copy')) {
                     const button = target.classList.contains('code-block-copy')
@@ -1570,6 +1832,12 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         if (lines.length === 0) {
             return true;
         }
+        if (lines.some(line => (line.startsWith('!')
+            || line.startsWith('%%bash')
+            || line.startsWith('%%sh')
+            || line.startsWith('%%shell')))) {
+            return false;
+        }
         const disallowedPatterns = [
             /(^|[^=!<>])=([^=]|$)/,
             /\.read_[a-zA-Z0-9_]*\s*\(/,
@@ -1591,6 +1859,160 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         ];
         return lines.every(line => allowedPatterns.some(pattern => pattern.test(line)));
     };
+    const userRequestedNotebookExecution = () => {
+        const lastUserMessage = [...messages]
+            .reverse()
+            .find((msg) => isChatMessage(msg) && msg.role === 'user');
+        const content = lastUserMessage?.content ?? '';
+        return /노트북|셀|cell|notebook|jupyter/i.test(content);
+    };
+    const isShellCell = (code) => {
+        const lines = code.split('\n');
+        const firstLine = lines.find(line => line.trim().length > 0)?.trim() || '';
+        if (firstLine.startsWith('%%bash')
+            || firstLine.startsWith('%%sh')
+            || firstLine.startsWith('%%shell')) {
+            return true;
+        }
+        return lines.some(line => line.trim().startsWith('!'));
+    };
+    const extractShellCommand = (code) => {
+        const lines = code.split('\n');
+        const firstNonEmptyIndex = lines.findIndex(line => line.trim().length > 0);
+        if (firstNonEmptyIndex === -1) {
+            return '';
+        }
+        const firstLine = lines[firstNonEmptyIndex].trim();
+        if (firstLine.startsWith('%%bash')
+            || firstLine.startsWith('%%sh')
+            || firstLine.startsWith('%%shell')) {
+            const script = lines.slice(firstNonEmptyIndex + 1).join('\n').trim();
+            if (!script) {
+                return '';
+            }
+            const escaped = script
+                .replace(/\\/g, '\\\\')
+                .replace(/'/g, "\\'")
+                .replace(/\r?\n/g, '\\n');
+            return `bash -lc $'${escaped}'`;
+        }
+        const shellLines = lines
+            .map(line => line.trim())
+            .filter(line => line.startsWith('!'))
+            .map(line => line.replace(/^!+/, '').trim())
+            .filter(Boolean);
+        return shellLines.join('\n');
+    };
+    const buildPythonCommand = (code) => (`python3 -c ${JSON.stringify(code)}`);
+    const shouldExecuteInNotebook = (code) => {
+        const notebook = getActiveNotebookPanel();
+        if (!notebook) {
+            return false;
+        }
+        if (isShellCell(code) && !userRequestedNotebookExecution()) {
+            return false;
+        }
+        return true;
+    };
+    const truncateOutputLines = (output, maxLines = 2) => {
+        const lines = output.split(/\r?\n/).filter(line => line.length > 0);
+        const text = lines.slice(0, maxLines).join('\n');
+        return { text, truncated: lines.length > maxLines };
+    };
+    const createCommandOutputMessage = (command) => {
+        const messageId = makeMessageId('command-output');
+        const outputMessage = {
+            id: messageId,
+            role: 'system',
+            content: `🐚 ${command}\n`,
+            timestamp: Date.now(),
+            metadata: {
+                kind: 'shell-output',
+                command
+            }
+        };
+        setMessages(prev => [...prev, outputMessage]);
+        return messageId;
+    };
+    const appendCommandOutputMessage = (messageId, text, stream) => {
+        if (!text)
+            return;
+        const prefix = stream === 'stderr' ? '[stderr] ' : '';
+        setMessages(prev => prev.map(msg => {
+            if (msg.id !== messageId || !('role' in msg)) {
+                return msg;
+            }
+            const chatMsg = msg;
+            return {
+                ...chatMsg,
+                content: `${chatMsg.content}${prefix}${text}`
+            };
+        }));
+    };
+    const executeSubprocessCommand = async (command, timeout, onOutput, stdin) => {
+        try {
+            const result = await apiService.executeCommandStream(command, { timeout, onOutput, stdin });
+            const stdout = typeof result.stdout === 'string' ? result.stdout : '';
+            const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+            const combined = [stdout, stderr].filter(Boolean).join('\n');
+            const summary = truncateOutputLines(combined, 2);
+            const truncated = summary.truncated || Boolean(result.truncated);
+            const output = summary.text || '(no output)';
+            if (result.success) {
+                return {
+                    success: true,
+                    output,
+                    returncode: result.returncode ?? null,
+                    command,
+                    truncated
+                };
+            }
+            const errorText = summary.text || result.error || stderr || 'Command failed';
+            return {
+                success: false,
+                output,
+                error: errorText,
+                returncode: result.returncode ?? null,
+                command,
+                truncated
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Command execution failed';
+            if (onOutput) {
+                onOutput({ stream: 'stderr', text: `${message}\n` });
+            }
+            const summary = truncateOutputLines(message, 2);
+            return {
+                success: false,
+                output: '',
+                error: summary.text || 'Command execution failed',
+                returncode: null,
+                command,
+                truncated: summary.truncated
+            };
+        }
+    };
+    const executeCodeViaSubprocess = async (code, timeout) => {
+        const isShell = isShellCell(code);
+        const command = isShell ? extractShellCommand(code) : buildPythonCommand(code);
+        if (!command) {
+            return {
+                success: false,
+                output: '',
+                error: isShell ? 'Shell command is empty' : 'Python command is empty',
+                returncode: null,
+                command,
+                truncated: false,
+                execution_method: 'subprocess'
+            };
+        }
+        const result = await executeSubprocessCommand(command, timeout);
+        return {
+            ...result,
+            execution_method: 'subprocess'
+        };
+    };
     const upsertInterruptMessage = (interrupt) => {
         const interruptMessageId = interruptMessageIdRef.current || makeMessageId('interrupt');
         interruptMessageIdRef.current = interruptMessageId;
@@ -1609,7 +2031,7 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             return [...prev, interruptMessage];
         });
     };
-    const clearInterruptMessage = () => {
+    const clearInterruptMessage = (decision) => {
         if (!interruptMessageIdRef.current)
             return;
         const messageId = interruptMessageIdRef.current;
@@ -1624,7 +2046,8 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
                         ...chatMsg.metadata,
                         interrupt: {
                             ...(chatMsg.metadata?.interrupt || {}),
-                            resolved: true
+                            resolved: true,
+                            decision: decision || 'approve' // Track approve/reject decision
                         }
                     }
                 };
@@ -1632,38 +2055,454 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             return msg;
         }));
     };
-    const resumeFromInterrupt = async (interrupt, decision) => {
-        const { threadId } = interrupt;
-        setInterruptData(null);
-        setDebugStatus(null);
-        clearInterruptMessage();
-        let resumeDecision = decision;
-        let resumeArgs = undefined;
-        if (decision === 'approve') {
-            const executed = await executePendingApproval();
-            if (executed && executed.tool === 'jupyter_cell') {
-                resumeDecision = 'edit';
-                resumeArgs = {
-                    code: executed.code,
-                    execution_result: executed.execution_result
-                };
-            }
-            else if (executed && executed.tool === 'markdown') {
-                resumeDecision = 'edit';
-                resumeArgs = {
-                    content: executed.content
-                };
-            }
+    const validateRelativePath = (path) => {
+        const trimmed = path.trim();
+        if (trimmed.startsWith('/') || trimmed.startsWith('\\') || /^[A-Za-z]:/.test(trimmed)) {
+            return { valid: false, error: 'Absolute paths are not allowed' };
         }
-        else {
-            pendingToolCallsRef.current.shift();
-            approvalPendingRef.current = pendingToolCallsRef.current.length > 0;
+        if (trimmed.includes('..')) {
+            return { valid: false, error: 'Path traversal (..) is not allowed' };
         }
-        setIsLoading(true);
-        setIsStreaming(true);
-        let interrupted = false;
-        // 항상 새 메시지 생성 - 승인 UI 아래에 append되도록
-        const assistantMessageId = makeMessageId('assistant');
+        return { valid: true };
+    };
+    const normalizeContentsPath = (path) => {
+        const trimmed = path.trim();
+        if (!trimmed || trimmed === '.' || trimmed === './') {
+            return '';
+        }
+        return trimmed
+            .replace(/^\.\/+/, '')
+            .replace(/^\/+/, '')
+            .replace(/\/+$/, '');
+    };
+    const globToRegex = (pattern) => {
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        const regex = `^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`;
+        return new RegExp(regex);
+    };
+    const fetchContentsModel = async (path, options) => {
+        try {
+            const { PageConfig, URLExt } = await Promise.resolve(/*! import() */).then(__webpack_require__.t.bind(__webpack_require__, /*! @jupyterlab/coreutils */ "webpack/sharing/consume/default/@jupyterlab/coreutils", 23));
+            const baseUrl = PageConfig.getBaseUrl();
+            const normalizedPath = normalizeContentsPath(path);
+            const apiUrl = URLExt.join(baseUrl, 'api/contents', normalizedPath);
+            const query = new URLSearchParams();
+            if (options?.content !== undefined) {
+                query.set('content', options.content ? '1' : '0');
+            }
+            if (options?.format) {
+                query.set('format', options.format);
+            }
+            const url = query.toString() ? `${apiUrl}?${query.toString()}` : apiUrl;
+            const response = await fetch(url, {
+                method: 'GET',
+                credentials: 'include',
+            });
+            if (!response.ok) {
+                return { success: false, error: `Failed to load contents: ${response.status}` };
+            }
+            const data = await response.json();
+            return { success: true, data };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to load contents';
+            return { success: false, error: message };
+        }
+    };
+    const executeListFilesTool = async (params) => {
+        const pathCheck = validateRelativePath(params.path);
+        if (!pathCheck.valid) {
+            return { success: false, error: pathCheck.error };
+        }
+        const pattern = (params.pattern || '*').trim() || '*';
+        const recursive = params.recursive ?? false;
+        const matcher = globToRegex(pattern);
+        const maxEntries = 500;
+        const files = [];
+        const pendingDirs = [normalizeContentsPath(params.path)];
+        const visited = new Set();
+        while (pendingDirs.length > 0 && files.length < maxEntries) {
+            const dirPath = pendingDirs.shift() ?? '';
+            if (visited.has(dirPath)) {
+                continue;
+            }
+            visited.add(dirPath);
+            const contentsResult = await fetchContentsModel(dirPath, { content: true });
+            if (!contentsResult.success) {
+                return { success: false, error: contentsResult.error };
+            }
+            const model = contentsResult.data;
+            if (!model || model.type !== 'directory' || !Array.isArray(model.content)) {
+                const displayPath = dirPath || '.';
+                return { success: false, error: `Not a directory: ${displayPath}` };
+            }
+            for (const entry of model.content) {
+                if (!entry) {
+                    continue;
+                }
+                const name = entry.name || entry.path?.split('/').pop() || '';
+                const entryPath = entry.path || name;
+                const isDir = entry.type === 'directory';
+                if (matcher.test(name)) {
+                    files.push({
+                        path: entryPath,
+                        isDir,
+                        size: isDir ? 0 : (entry.size ?? 0),
+                    });
+                }
+                if (recursive && isDir && entryPath) {
+                    pendingDirs.push(entryPath);
+                }
+                if (files.length >= maxEntries) {
+                    break;
+                }
+            }
+        }
+        const formatted = files.map((file) => {
+            const icon = file.isDir ? '📁' : '📄';
+            const sizeInfo = file.isDir ? '' : ` (${file.size} bytes)`;
+            return `${icon} ${file.path}${file.isDir ? '/' : sizeInfo}`;
+        }).join('\n');
+        return {
+            success: true,
+            output: formatted || '(empty directory)',
+            metadata: { count: files.length, files }
+        };
+    };
+    const executeReadFileTool = async (params) => {
+        if (!params.path) {
+            return { success: false, error: 'Path is required' };
+        }
+        const pathCheck = validateRelativePath(params.path);
+        if (!pathCheck.valid) {
+            return { success: false, error: pathCheck.error };
+        }
+        const maxLines = typeof params.maxLines === 'number' ? params.maxLines : 1000;
+        const safeMaxLines = Math.max(0, maxLines);
+        const contentsResult = await fetchContentsModel(params.path, { content: true, format: 'text' });
+        if (!contentsResult.success) {
+            return { success: false, error: contentsResult.error };
+        }
+        const model = contentsResult.data;
+        if (!model) {
+            return { success: false, error: 'File not found' };
+        }
+        if (model.type === 'directory') {
+            return { success: false, error: `Path is a directory: ${params.path}` };
+        }
+        let content = model.content ?? '';
+        if (model.format === 'base64') {
+            return { success: false, error: 'Binary file content is not supported' };
+        }
+        if (typeof content !== 'string') {
+            content = JSON.stringify(content, null, 2);
+        }
+        const lines = content.split('\n');
+        const sliced = lines.slice(0, safeMaxLines);
+        return {
+            success: true,
+            output: sliced.join('\n'),
+            metadata: {
+                lineCount: sliced.length,
+                truncated: lines.length > safeMaxLines
+            }
+        };
+    };
+    // Helper function for auto-approving search/file tools with execution results
+    const handleAutoToolInterrupt = async (interrupt) => {
+        const { threadId, action, args } = interrupt;
+        console.log('[AgentPanel] Auto-approving tool:', action, args);
+        try {
+            let executionResult;
+            if (action === 'search_workspace_tool') {
+                setDebugStatus(`🔍 검색 실행 중: ${args?.pattern || ''}`);
+                executionResult = await apiService.searchWorkspace({
+                    pattern: args?.pattern || '',
+                    file_types: args?.file_types || ['*.py', '*.ipynb'],
+                    path: args?.path || '.',
+                    max_results: args?.max_results || 50,
+                    case_sensitive: args?.case_sensitive || false
+                });
+                console.log('[AgentPanel] search_workspace result:', executionResult);
+            }
+            else if (action === 'search_notebook_cells_tool') {
+                setDebugStatus(`🔍 노트북 검색 실행 중: ${args?.pattern || ''}`);
+                executionResult = await apiService.searchNotebookCells({
+                    pattern: args?.pattern || '',
+                    notebook_path: args?.notebook_path,
+                    cell_type: args?.cell_type,
+                    max_results: args?.max_results || 30,
+                    case_sensitive: args?.case_sensitive || false
+                });
+                console.log('[AgentPanel] search_notebook_cells result:', executionResult);
+            }
+            else if (action === 'check_resource_tool') {
+                const filesList = Array.isArray(args?.files) ? args.files : (args?.files ? [args.files] : []);
+                setDebugStatus(`📊 리소스 체크 중: ${filesList.join(', ') || 'system'}`);
+                executionResult = await apiService.checkResource({
+                    files: filesList,
+                    dataframes: args?.dataframes || [],
+                    file_size_command: args?.file_size_command || '',
+                    dataframe_check_code: args?.dataframe_check_code || ''
+                });
+                console.log('[AgentPanel] check_resource result:', executionResult);
+            }
+            else if (action === 'list_files_tool') {
+                setDebugStatus('📂 파일 목록 조회 중...');
+                const listParams = {
+                    path: typeof args?.path === 'string' ? args.path : '.',
+                    recursive: args?.recursive ?? false,
+                    pattern: args?.pattern ?? undefined
+                };
+                executionResult = await executeListFilesTool(listParams);
+                console.log('[AgentPanel] list_files result:', executionResult);
+            }
+            else if (action === 'read_file_tool') {
+                setDebugStatus('📄 파일 읽는 중...');
+                const readParams = {
+                    path: typeof args?.path === 'string' ? args.path : '',
+                    encoding: typeof args?.encoding === 'string' ? args.encoding : undefined,
+                    maxLines: args?.max_lines ?? args?.maxLines
+                };
+                executionResult = await executeReadFileTool(readParams);
+                console.log('[AgentPanel] read_file result:', executionResult);
+            }
+            else {
+                console.warn('[AgentPanel] Unknown auto tool:', action);
+                return;
+            }
+            // Resume with execution result
+            const resumeArgs = {
+                ...args,
+                execution_result: executionResult
+            };
+            // Clear interrupt state (don't show approval UI for search)
+            setInterruptData(null);
+            // Create new assistant message for continued response
+            const assistantMessageId = makeMessageId('assistant');
+            setStreamingMessageId(assistantMessageId);
+            setMessages(prev => [
+                ...prev,
+                {
+                    id: assistantMessageId,
+                    role: 'assistant',
+                    content: '',
+                    timestamp: Date.now()
+                }
+            ]);
+            let streamedContent = '';
+            let interrupted = false;
+            setDebugStatus('🤔 LLM 응답 대기 중');
+            await apiService.resumeAgent(threadId, 'edit', // Use 'edit' to pass execution_result in args
+            resumeArgs, undefined, llmConfig || undefined, (chunk) => {
+                streamedContent += chunk;
+                setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
+                    ? { ...msg, content: streamedContent }
+                    : msg));
+            }, (status) => {
+                setDebugStatus(status);
+            }, (nextInterrupt) => {
+                interrupted = true;
+                approvalPendingRef.current = true;
+                const autoApproveEnabled = getAutoApproveEnabled(llmConfig || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getLLMConfig)() || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getDefaultLLMConfig)());
+                // Handle next interrupt (could be another search or code execution)
+                if (nextInterrupt.action === 'search_workspace_tool'
+                    || nextInterrupt.action === 'search_notebook_cells_tool'
+                    || nextInterrupt.action === 'check_resource_tool'
+                    || nextInterrupt.action === 'list_files_tool'
+                    || nextInterrupt.action === 'read_file_tool') {
+                    void handleAutoToolInterrupt(nextInterrupt);
+                    return;
+                }
+                if (autoApproveEnabled) {
+                    void resumeFromInterrupt(nextInterrupt, 'approve');
+                    return;
+                }
+                if (nextInterrupt.action === 'jupyter_cell_tool' && nextInterrupt.args?.code) {
+                    const shouldQueue = shouldExecuteInNotebook(nextInterrupt.args.code);
+                    if (isAutoApprovedCode(nextInterrupt.args.code)) {
+                        if (shouldQueue) {
+                            queueApprovalCell(nextInterrupt.args.code);
+                        }
+                        void resumeFromInterrupt(nextInterrupt, 'approve');
+                        return;
+                    }
+                    if (shouldQueue) {
+                        queueApprovalCell(nextInterrupt.args.code);
+                    }
+                }
+                setInterruptData(nextInterrupt);
+                upsertInterruptMessage(nextInterrupt);
+                setIsLoading(false);
+                setIsStreaming(false);
+            }, (newTodos) => {
+                setTodos(newTodos);
+            }, () => {
+                setDebugStatus(null);
+            }, handleToolCall);
+            if (!interrupted) {
+                setIsLoading(false);
+                setIsStreaming(false);
+                setStreamingMessageId(null);
+                approvalPendingRef.current = false;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Tool execution failed';
+            console.error('[AgentPanel] Auto tool error:', error);
+            setDebugStatus(`오류: ${message}`);
+            setIsLoading(false);
+            setIsStreaming(false);
+            approvalPendingRef.current = false;
+        }
+    };
+    const resumeFromInterrupt = async (interrupt, decision, feedback // Optional feedback message for rejection
+    ) => {
+        const { threadId } = interrupt;
+        setInterruptData(null);
+        setDebugStatus(null);
+        clearInterruptMessage(decision); // Pass decision to track approve/reject
+        let resumeDecision = decision;
+        let resumeArgs = undefined;
+        if (decision === 'approve') {
+            // Handle write_file_tool separately - execute file write on Jupyter server
+            if (interrupt.action === 'write_file_tool') {
+                try {
+                    setDebugStatus('📝 파일 쓰기 중...');
+                    const writeResult = await apiService.writeFile(interrupt.args?.path || '', interrupt.args?.content || '', {
+                        encoding: interrupt.args?.encoding || 'utf-8',
+                        overwrite: interrupt.args?.overwrite || false
+                    });
+                    console.log('[AgentPanel] write_file result:', writeResult);
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: writeResult
+                    };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'File write failed';
+                    console.error('[AgentPanel] write_file error:', error);
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: { success: false, error: message }
+                    };
+                }
+            }
+            else if (interrupt.action === 'execute_command_tool') {
+                const command = (interrupt.args?.command || '').trim();
+                // Default stdin to "y\n" for interactive prompts (yes/no)
+                const stdinInput = interrupt.args?.stdin ?? 'y\n';
+                setDebugStatus('🐚 셸 명령 실행 중...');
+                const outputMessageId = command ? createCommandOutputMessage(command) : null;
+                const execResult = command
+                    ? await executeSubprocessCommand(command, interrupt.args?.timeout, outputMessageId
+                        ? (chunk) => appendCommandOutputMessage(outputMessageId, chunk.text, chunk.stream)
+                        : undefined, stdinInput)
+                    : {
+                        success: false,
+                        output: '',
+                        error: 'Command is required',
+                        returncode: null,
+                        command,
+                        truncated: false
+                    };
+                resumeDecision = 'edit';
+                resumeArgs = {
+                    ...interrupt.args,
+                    execution_result: execResult
+                };
+            }
+            else if (interrupt.action === 'jupyter_cell_tool' && interrupt.args?.code) {
+                const code = interrupt.args.code;
+                if (!shouldExecuteInNotebook(code)) {
+                    setDebugStatus('🐚 서브프로세스로 코드 실행 중...');
+                    const execResult = await executeCodeViaSubprocess(code, interrupt.args?.timeout);
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        code,
+                        execution_result: execResult
+                    };
+                }
+                else {
+                    const executed = await executePendingApproval();
+                    if (executed && executed.tool === 'jupyter_cell') {
+                        resumeDecision = 'edit';
+                        resumeArgs = {
+                            code: executed.code,
+                            execution_result: executed.execution_result
+                        };
+                    }
+                    else {
+                        const notebook = getActiveNotebookPanel();
+                        if (!notebook) {
+                            setDebugStatus('🐚 노트북이 없어 서브프로세스로 실행 중...');
+                            const execResult = await executeCodeViaSubprocess(code, interrupt.args?.timeout);
+                            resumeDecision = 'edit';
+                            resumeArgs = {
+                                code,
+                                execution_result: execResult
+                            };
+                        }
+                        else {
+                            const cellIndex = insertCell(notebook, 'code', code);
+                            if (cellIndex === null) {
+                                setDebugStatus('🐚 노트북 모델이 없어 서브프로세스로 실행 중...');
+                                const execResult = await executeCodeViaSubprocess(code, interrupt.args?.timeout);
+                                resumeDecision = 'edit';
+                                resumeArgs = {
+                                    code,
+                                    execution_result: execResult
+                                };
+                            }
+                            else {
+                                await executeCell(notebook, cellIndex);
+                                const execResult = captureExecutionResult(notebook, cellIndex);
+                                resumeDecision = 'edit';
+                                resumeArgs = {
+                                    code,
+                                    execution_result: execResult
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const executed = await executePendingApproval();
+                if (executed && executed.tool === 'jupyter_cell') {
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        code: executed.code,
+                        execution_result: executed.execution_result
+                    };
+                }
+                else if (executed && executed.tool === 'markdown') {
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        content: executed.content
+                    };
+                }
+            }
+        }
+        else {
+            // Reject: delete the pending cell from notebook
+            const pendingCall = pendingToolCallsRef.current[0];
+            if (pendingCall && pendingCall.cellIndex !== undefined) {
+                const notebook = getActiveNotebookPanel();
+                if (notebook) {
+                    deleteCell(notebook, pendingCall.cellIndex);
+                }
+            }
+            pendingToolCallsRef.current.shift();
+            approvalPendingRef.current = pendingToolCallsRef.current.length > 0;
+        }
+        setIsLoading(true);
+        setIsStreaming(true);
+        let interrupted = false;
+        // 항상 새 메시지 생성 - 승인 UI 아래에 append되도록
+        const assistantMessageId = makeMessageId('assistant');
         setStreamingMessageId(assistantMessageId);
         // 새 메시지 추가 (맨 아래에 append)
         setMessages(prev => [
@@ -1676,8 +2515,12 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             }
         ]);
         let streamedContent = '';
+        // Build feedback message for rejection
+        const rejectionFeedback = resumeDecision === 'reject'
+            ? (feedback ? `사용자 피드백: ${feedback}` : 'User rejected this action')
+            : undefined;
         try {
-            await apiService.resumeAgent(threadId, resumeDecision, resumeArgs, resumeDecision === 'reject' ? 'User rejected this action' : undefined, llmConfig || undefined, (chunk) => {
+            await apiService.resumeAgent(threadId, resumeDecision, resumeArgs, rejectionFeedback, llmConfig || undefined, (chunk) => {
                 streamedContent += chunk;
                 setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
                     ? { ...msg, content: streamedContent }
@@ -1687,13 +2530,32 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             }, (nextInterrupt) => {
                 interrupted = true;
                 approvalPendingRef.current = true;
+                const autoApproveEnabled = getAutoApproveEnabled(llmConfig || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getLLMConfig)() || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getDefaultLLMConfig)());
+                // Auto-approve search/file/resource tools
+                if (nextInterrupt.action === 'search_workspace_tool'
+                    || nextInterrupt.action === 'search_notebook_cells_tool'
+                    || nextInterrupt.action === 'check_resource_tool'
+                    || nextInterrupt.action === 'list_files_tool'
+                    || nextInterrupt.action === 'read_file_tool') {
+                    void handleAutoToolInterrupt(nextInterrupt);
+                    return;
+                }
+                if (autoApproveEnabled) {
+                    void resumeFromInterrupt(nextInterrupt, 'approve');
+                    return;
+                }
                 if (nextInterrupt.action === 'jupyter_cell_tool' && nextInterrupt.args?.code) {
+                    const shouldQueue = shouldExecuteInNotebook(nextInterrupt.args.code);
                     if (isAutoApprovedCode(nextInterrupt.args.code)) {
-                        queueApprovalCell(nextInterrupt.args.code);
+                        if (shouldQueue) {
+                            queueApprovalCell(nextInterrupt.args.code);
+                        }
                         void resumeFromInterrupt(nextInterrupt, 'approve');
                         return;
                     }
-                    queueApprovalCell(nextInterrupt.args.code);
+                    if (shouldQueue) {
+                        queueApprovalCell(nextInterrupt.args.code);
+                    }
                 }
                 setInterruptData(nextInterrupt);
                 upsertInterruptMessage(nextInterrupt);
@@ -1728,6 +2590,26 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         }
     };
     const handleSendMessage = async () => {
+        // Handle rejection mode - resume with optional feedback
+        if (isRejectionMode && pendingRejectionInterrupt) {
+            const feedback = input.trim() || undefined; // Empty input means no feedback
+            // Add user message bubble if there's feedback
+            if (feedback) {
+                const userMessage = {
+                    id: makeMessageId(),
+                    role: 'user',
+                    content: feedback,
+                    timestamp: Date.now(),
+                };
+                setMessages(prev => [...prev, userMessage]);
+            }
+            setInput('');
+            setIsRejectionMode(false);
+            const interruptToResume = pendingRejectionInterrupt;
+            setPendingRejectionInterrupt(null);
+            await resumeFromInterrupt(interruptToResume, 'reject', feedback);
+            return;
+        }
         // Check if there's an LLM prompt stored (from cell action)
         const textarea = messagesEndRef.current?.parentElement?.querySelector('.jp-agent-input');
         const llmPrompt = pendingLlmPromptRef.current || textarea?.getAttribute('data-llm-prompt');
@@ -1753,19 +2635,23 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             if (!notebook) {
                 // Python 에러가 감지되면 파일 수정 모드로 전환
                 if (detectPythonError(currentInput)) {
-                    console.log('[AgentPanel] Agent mode: No notebook, but Python error detected - switching to file fix mode');
-                    // User 메시지 추가
-                    const userMessage = {
-                        id: makeMessageId(),
-                        role: 'user',
-                        content: currentInput,
-                        timestamp: Date.now(),
-                    };
-                    setMessages(prev => [...prev, userMessage]);
-                    setInput('');
-                    // Python 에러 수정 처리
-                    await handlePythonErrorFix(currentInput);
-                    return;
+                    console.log('[AgentPanel] Agent mode: No notebook, but Python error detected - attempting file fix');
+                    // Python 에러 수정 처리 시도
+                    const handled = await handlePythonErrorFix(currentInput);
+                    if (handled) {
+                        // 파일 수정 모드로 처리됨
+                        const userMessage = {
+                            id: makeMessageId(),
+                            role: 'user',
+                            content: currentInput,
+                            timestamp: Date.now(),
+                        };
+                        setMessages(prev => [...prev, userMessage]);
+                        setInput('');
+                        return;
+                    }
+                    // 파일 경로를 찾지 못함 - 아래 로직으로 계속 진행
+                    console.log('[AgentPanel] Agent mode: No file path found, continuing...');
                 }
                 // 파일 수정 관련 자연어 요청 감지 (에러, 고쳐, 수정, fix 등)
                 const fileFixRequestPatterns = [
@@ -1849,174 +2735,66 @@ SyntaxError: '(' was never closed
                 const userMessage = {
                     id: makeMessageId(),
                     role: 'user',
-                    content: currentInput,
-                    timestamp: Date.now(),
-                };
-                setMessages(prev => [...prev, userMessage]);
-                setInput('');
-                // Agent 실행
-                await handleAgentExecution(agentRequest);
-                return;
-            }
-        }
-        // Python 에러 감지 및 파일 수정 모드 (Chat 모드에서만)
-        if (inputMode === 'chat' && detectPythonError(currentInput)) {
-            console.log('[AgentPanel] Python error detected in message');
-            // User 메시지 추가
-            const userMessage = {
-                id: makeMessageId(),
-                role: 'user',
-                content: currentInput,
-                timestamp: Date.now(),
-            };
-            setMessages(prev => [...prev, userMessage]);
-            setInput('');
-            // Python 에러 수정 처리
-            await handlePythonErrorFix(currentInput);
-            return;
-        }
-        // Check if API key is configured before sending
-        let currentConfig = llmConfig;
-        if (!currentConfig) {
-            // Config not loaded yet, try to load from localStorage
-            currentConfig = (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getLLMConfig)() || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.getDefaultLLMConfig)();
-            setLlmConfig(currentConfig);
-        }
-        // Check API key using ApiKeyManager
-        const hasApiKey = (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_4__.hasValidApiKey)(currentConfig);
-        if (!hasApiKey) {
-            // Show error message and open settings
-            const providerName = llmConfig?.provider || 'LLM';
-            const errorMessage = {
-                id: makeMessageId(),
-                role: 'assistant',
-                content: `API Key가 설정되지 않았습니다.\n\n${providerName === 'gemini' ? 'Gemini' : providerName === 'openai' ? 'OpenAI' : 'vLLM'} API Key를 먼저 설정해주세요.\n\n설정 버튼을 클릭하여 API Key를 입력하세요.`,
-                timestamp: Date.now()
-            };
-            setMessages(prev => [...prev, errorMessage]);
-            setShowSettings(true);
-            return;
-        }
-        // Use the display prompt (input) for the user message, or use a fallback if input is empty
-        const displayContent = currentInput || (llmPrompt ? '셀 분석 요청' : '');
-        const userMessage = {
-            id: makeMessageId(),
-            role: 'user',
-            content: displayContent,
-            timestamp: Date.now()
-        };
-        setMessages(prev => [...prev, userMessage]);
-        // Only clear input if it was manually entered, keep it for auto-execution display
-        if (currentInput) {
-            setInput('');
-        }
-        setIsLoading(true);
-        setIsStreaming(true);
-        // Clear the data attribute and ref after using it
-        if (textarea && llmPrompt) {
-            textarea.removeAttribute('data-llm-prompt');
-            pendingLlmPromptRef.current = null;
-        }
-        // Create assistant message ID for streaming updates
-        const assistantMessageId = makeMessageId('assistant');
-        let streamedContent = '';
-        setStreamingMessageId(assistantMessageId);
-        // Add empty assistant message that will be updated during streaming
-        const initialAssistantMessage = {
-            id: assistantMessageId,
-            role: 'assistant',
-            content: '',
-            timestamp: Date.now()
-        };
-        setMessages(prev => [...prev, initialAssistantMessage]);
-        let interrupted = false;
-        try {
-            // Use LLM prompt if available, otherwise use the display content
-            const messageToSend = llmPrompt || displayContent;
-            await apiService.sendMessageStream({
-                message: messageToSend,
-                conversationId: conversationId || undefined,
-                llmConfig: currentConfig // Include API keys with request
-            }, 
-            // onChunk callback - update message content incrementally
-            (chunk) => {
-                streamedContent += chunk;
-                setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
-                    ? { ...msg, content: streamedContent }
-                    : msg));
-            }, 
-            // onMetadata callback - update conversationId and metadata
-            (metadata) => {
-                if (metadata.conversationId && !conversationId) {
-                    setConversationId(metadata.conversationId);
-                }
-                if (metadata.provider || metadata.model) {
-                    setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
-                        ? {
-                            ...msg,
-                            metadata: {
-                                ...msg.metadata,
-                                provider: metadata.provider,
-                                model: metadata.model
-                            }
-                        }
-                        : msg));
-                }
-            }, 
-            // onDebug callback - show debug status in gray
-            (status) => {
-                setDebugStatus(status);
-            }, 
-            // onInterrupt callback - show approval dialog
-            (interrupt) => {
-                interrupted = true;
-                approvalPendingRef.current = true;
-                if (interrupt.action === 'jupyter_cell_tool' && interrupt.args?.code) {
-                    if (isAutoApprovedCode(interrupt.args.code)) {
-                        queueApprovalCell(interrupt.args.code);
-                        void resumeFromInterrupt(interrupt, 'approve');
-                        return;
-                    }
-                    queueApprovalCell(interrupt.args.code);
-                }
-                setInterruptData(interrupt);
-                upsertInterruptMessage(interrupt);
-                setIsLoading(false);
-                setIsStreaming(false);
-            }, 
-            // onTodos callback - update todo list UI
-            (newTodos) => {
-                setTodos(newTodos);
-            }, 
-            // onDebugClear callback - clear debug status
-            () => {
-                setDebugStatus(null);
-            }, 
-            // onToolCall callback - add cells to notebook
-            handleToolCall);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Failed to send message';
-            setDebugStatus(`오류: ${message}`);
-            // Update the assistant message with error
-            setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
-                ? {
-                    ...msg,
-                    content: streamedContent + `\n\nError: ${message}`
-                }
-                : msg));
+                    content: currentInput,
+                    timestamp: Date.now(),
+                };
+                setMessages(prev => [...prev, userMessage]);
+                setInput('');
+                // Agent 실행
+                await handleAgentExecution(agentRequest);
+                return;
+            }
         }
-        finally {
-            setIsLoading(false);
-            setIsStreaming(false);
-            setStreamingMessageId(null);
-            // Keep completed todos visible after the run
+        // Python 에러 감지 및 파일 수정 모드 (Chat 모드에서만)
+        // 파일 경로를 추출할 수 있는 경우에만 파일 수정 모드 사용
+        // 그렇지 않으면 일반 LLM 스트림으로 처리
+        if (inputMode === 'chat' && detectPythonError(currentInput)) {
+            console.log('[AgentPanel] Python error detected in message, attempting file fix...');
+            // Python 에러 수정 처리 시도 (파일 경로를 찾을 수 있는 경우에만 처리됨)
+            const handled = await handlePythonErrorFix(currentInput);
+            if (handled) {
+                // 파일 수정 모드로 처리됨 - 사용자 메시지 추가 후 종료
+                const userMessage = {
+                    id: makeMessageId(),
+                    role: 'user',
+                    content: currentInput,
+                    timestamp: Date.now(),
+                };
+                setMessages(prev => [...prev, userMessage]);
+                setInput('');
+                return;
+            }
+            // 파일 경로를 찾지 못해 handled=false 반환됨
+            // 일반 스트림으로 폴백 (아래 로직에서 사용자 메시지 추가됨)
+            console.log('[AgentPanel] No file path found in error, using regular LLM stream');
         }
+        // Use the display prompt (input) for the user message, or use a fallback if input is empty
+        const displayContent = currentInput || (llmPrompt ? '셀 분석 요청' : '');
+        await sendChatMessage({
+            displayContent,
+            llmPrompt,
+            textarea,
+            clearInput: Boolean(currentInput)
+        });
     };
     // Handle resume after user approval/rejection
     const handleResumeAgent = async (decision) => {
         if (!interruptData)
             return;
+        if (decision === 'reject') {
+            // Enter rejection mode - wait for user feedback before resuming
+            setIsRejectionMode(true);
+            setPendingRejectionInterrupt(interruptData);
+            // Clear the interrupt UI but keep the data for later, mark as rejected
+            setInterruptData(null);
+            clearInterruptMessage('reject'); // Pass 'reject' to show "거부됨"
+            // Focus on input for user to provide feedback
+            const textarea = document.querySelector('.jp-agent-input');
+            if (textarea) {
+                textarea.focus();
+            }
+            return;
+        }
         await resumeFromInterrupt(interruptData, decision);
     };
     const handleKeyDown = (e) => {
@@ -2143,9 +2921,6 @@ SyntaxError: '(' was never closed
         if (normalized.includes('resuming execution')) {
             return '승인 반영 후 실행 재개 중...';
         }
-        if (normalized.includes('tool')) {
-            return '도구 실행 중';
-        }
         return raw;
     };
     const getStatusText = () => {
@@ -2162,6 +2937,7 @@ SyntaxError: '(' was never closed
         return null;
     };
     const statusText = getStatusText();
+    const hasActiveTodos = todos.some(todo => todo.status === 'pending' || todo.status === 'in_progress');
     return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-panel" },
         showSettings && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement(_SettingsPanel__WEBPACK_IMPORTED_MODULE_3__.SettingsPanel, { onClose: () => setShowSettings(false), onSave: handleSaveConfig, currentConfig: llmConfig || undefined })),
         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-header" },
@@ -2193,30 +2969,51 @@ SyntaxError: '(' was never closed
                 if (isChatMessage(msg)) {
                     // 일반 Chat 메시지
                     const isAssistant = msg.role === 'assistant';
+                    const isShellOutput = msg.metadata?.kind === 'shell-output';
+                    const interruptAction = msg.metadata?.interrupt?.action;
+                    const isWriteFile = interruptAction === 'write_file_tool';
+                    const writePath = (isWriteFile
+                        && typeof msg.metadata?.interrupt?.args?.path === 'string') ? msg.metadata?.interrupt?.args?.path : '';
+                    const headerRole = msg.role === 'user'
+                        ? '사용자'
+                        : msg.role === 'system'
+                            ? (isShellOutput ? 'shell 실행' : '승인 요청')
+                            : 'Agent';
                     return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { key: msg.id, className: isAssistant
                             ? 'jp-agent-message jp-agent-message-assistant-inline'
-                            : `jp-agent-message jp-agent-message-${msg.role}` },
+                            : `jp-agent-message jp-agent-message-${msg.role}${isShellOutput ? ' jp-agent-message-shell-output' : ''}` },
                         !isAssistant && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-message-header" },
-                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-message-role" }, msg.role === 'user' ? '사용자' : msg.role === 'system' ? '승인 요청' : 'Agent'),
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-message-role" }, headerRole),
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-message-time" }, new Date(msg.timestamp).toLocaleTimeString()))),
-                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: `jp-agent-message-content${streamingMessageId === msg.id ? ' streaming' : ''}` }, msg.role === 'system' && msg.metadata?.interrupt ? (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-interrupt-inline" },
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: `jp-agent-message-content${streamingMessageId === msg.id ? ' streaming' : ''}${isShellOutput ? ' jp-agent-message-content-shell' : ''}` }, msg.role === 'system' && msg.metadata?.interrupt ? (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-interrupt-inline" },
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-interrupt-description" }, msg.content),
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-interrupt-action" },
                                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-interrupt-action-args" }, (() => {
+                                    const command = msg.metadata?.interrupt?.args?.command;
                                     const code = msg.metadata?.interrupt?.args?.code || msg.metadata?.interrupt?.args?.content || '';
-                                    const lines = code.split('\n');
-                                    const preview = lines.slice(0, 8).join('\n');
-                                    const suffix = lines.length > 8 ? '\n...' : '';
+                                    const snippet = (command || code || '(no details)');
+                                    const language = command ? 'bash' : 'python';
                                     const resolved = msg.metadata?.interrupt?.resolved;
+                                    const decision = msg.metadata?.interrupt?.decision;
+                                    const resolvedText = decision === 'reject' ? '거부됨' : '승인됨';
+                                    const resolvedClass = decision === 'reject' ? 'jp-agent-interrupt-actions--rejected' : 'jp-agent-interrupt-actions--resolved';
                                     const actionHtml = resolved
-                                        ? '<div class="jp-agent-interrupt-actions jp-agent-interrupt-actions--resolved">승인됨</div>'
+                                        ? `<div class="jp-agent-interrupt-actions ${resolvedClass}">${resolvedText}</div>`
                                         : `
 <div class="code-block-actions jp-agent-interrupt-actions">
   <button class="jp-agent-interrupt-approve-btn" data-action="approve">승인</button>
   <button class="jp-agent-interrupt-reject-btn" data-action="reject">거부</button>
 </div>
 `;
-                                    return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-RenderedHTMLCommon", style: { padding: '0 4px' }, dangerouslySetInnerHTML: { __html: (0,_utils_markdownRenderer__WEBPACK_IMPORTED_MODULE_7__.formatMarkdownToHtml)(`\n\`\`\`python\n${preview}${suffix}\n\`\`\``).replace('</div>', `${actionHtml}</div>`) }, onClick: (event) => {
+                                    const renderedHtml = (() => {
+                                        let html = (0,_utils_markdownRenderer__WEBPACK_IMPORTED_MODULE_7__.formatMarkdownToHtml)(`\n\`\`\`${language}\n${snippet}\n\`\`\``);
+                                        if (isWriteFile && writePath) {
+                                            const safePath = escapeHtml(writePath);
+                                            html = html.replace(/<span class="code-block-language">[^<]*<\/span>/, `<span class="code-block-language jp-agent-interrupt-path">${safePath}</span>`);
+                                        }
+                                        return html.replace('</div>', `${actionHtml}</div>`);
+                                    })();
+                                    return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-RenderedHTMLCommon", style: { padding: '0 4px' }, dangerouslySetInnerHTML: { __html: renderedHtml }, onClick: (event) => {
                                             const target = event.target;
                                             const action = target?.getAttribute?.('data-action');
                                             if (msg.metadata?.interrupt?.resolved) {
@@ -2276,11 +3073,6 @@ SyntaxError: '(' was never closed
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: "jp-agent-file-fix-apply", onClick: () => applyFileFix(fix), title: `${fix.path} 파일에 수정 적용` }, "\uC801\uC6A9\uD558\uAE30"))))),
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: "jp-agent-file-fixes-dismiss", onClick: () => setPendingFileFixes([]), title: "\uC218\uC815 \uC81C\uC548 \uB2EB\uAE30" }, "\uB2EB\uAE30"))),
             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { ref: messagesEndRef })),
-        statusText && todos.length === 0 && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: `jp-agent-message jp-agent-message-debug${statusText.startsWith('오류:') ? ' jp-agent-message-debug-error' : ''}` },
-            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-debug-content" },
-                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-debug-branch", "aria-hidden": "true" }),
-                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-debug-text" }, statusText),
-                !statusText.startsWith('오류:') && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-debug-ellipsis", "aria-hidden": "true" }))))),
         todos.length > 0 && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-compact" },
             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-compact-header", onClick: () => setIsTodoExpanded(!isTodoExpanded) },
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-compact-left" },
@@ -2288,15 +3080,26 @@ SyntaxError: '(' was never closed
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M6 12l4-4-4-4" })),
                     (() => {
                         const currentTodo = todos.find(t => t.status === 'in_progress') || todos.find(t => t.status === 'pending');
-                        return currentTodo ? (react__WEBPACK_IMPORTED_MODULE_0___default().createElement((react__WEBPACK_IMPORTED_MODULE_0___default().Fragment), null,
-                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-compact-spinner" }),
-                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-compact-current" }, currentTodo.content))) : (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-compact-current" }, "\u2713 \uBAA8\uB4E0 \uC791\uC5C5 \uC644\uB8CC"));
+                        const isStillWorking = isStreaming || isLoading || isAgentRunning;
+                        if (currentTodo) {
+                            return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement((react__WEBPACK_IMPORTED_MODULE_0___default().Fragment), null,
+                                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-compact-spinner" }),
+                                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-compact-current" }, currentTodo.content)));
+                        }
+                        else if (isStillWorking) {
+                            return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement((react__WEBPACK_IMPORTED_MODULE_0___default().Fragment), null,
+                                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-compact-spinner" }),
+                                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-compact-current" }, "\uC791\uC5C5 \uB9C8\uBB34\uB9AC \uC911...")));
+                        }
+                        else {
+                            return (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-compact-current" }, "\u2713 \uBAA8\uB4E0 \uC791\uC5C5 \uC644\uB8CC"));
+                        }
                     })()),
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-compact-progress" },
                     todos.filter(t => t.status === 'completed').length,
                     "/",
                     todos.length)),
-            statusText && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: `jp-agent-message jp-agent-message-debug jp-agent-message-debug--inline${statusText.startsWith('오류:') ? ' jp-agent-message-debug-error' : ''}` },
+            statusText && hasActiveTodos && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: `jp-agent-message jp-agent-message-debug jp-agent-message-debug--inline${statusText.startsWith('오류:') ? ' jp-agent-message-debug-error' : ''}` },
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-debug-content" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-debug-branch", "aria-hidden": "true" }),
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-debug-text" }, statusText),
@@ -2308,12 +3111,18 @@ SyntaxError: '(' was never closed
                     todo.status === 'in_progress' && react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-todo-item-spinner" }),
                     todo.status === 'pending' && react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-todo-item-number" }, index + 1)),
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: `jp-agent-todo-item-text ${todo.status === 'completed' ? 'jp-agent-todo-item-text--done' : ''}` }, todo.content)))))))),
+        statusText && !hasActiveTodos && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: `jp-agent-message jp-agent-message-debug jp-agent-message-debug--above-input${statusText.startsWith('오류:') ? ' jp-agent-message-debug-error' : ''}` },
+            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-debug-content" },
+                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-debug-text" }, statusText),
+                !statusText.startsWith('오류:') && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-debug-ellipsis", "aria-hidden": "true" }))))),
         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-input-container" },
             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-input-wrapper" },
-                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("textarea", { className: `jp-agent-input ${inputMode === 'agent' ? 'jp-agent-input--agent-mode' : ''}`, value: input, onChange: (e) => setInput(e.target.value), onKeyDown: handleKeyDown, placeholder: inputMode === 'agent'
-                        ? '노트북 작업을 입력하세요... (예: 데이터 시각화 해줘)'
-                        : '메시지를 입력하세요...', rows: 3, disabled: isLoading || isAgentRunning }),
-                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: "jp-agent-send-button", onClick: handleSendMessage, disabled: !input.trim() || isLoading || isStreaming || isAgentRunning, title: "\uC804\uC1A1 (Enter)" }, isAgentRunning ? '실행 중...' : '전송')),
+                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("textarea", { className: `jp-agent-input ${inputMode === 'agent' ? 'jp-agent-input--agent-mode' : ''} ${isRejectionMode ? 'jp-agent-input--rejection-mode' : ''}`, value: input, onChange: (e) => setInput(e.target.value), onKeyDown: handleKeyDown, placeholder: isRejectionMode
+                        ? '다른 방향 제시'
+                        : (inputMode === 'agent'
+                            ? '노트북 작업을 입력하세요... (예: 데이터 시각화 해줘)'
+                            : '메시지를 입력하세요...'), rows: 3, disabled: isLoading || isAgentRunning }),
+                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: "jp-agent-send-button", onClick: handleSendMessage, disabled: (!input.trim() && !isRejectionMode) || isLoading || isStreaming || isAgentRunning, title: isRejectionMode ? "거부 전송 (Enter)" : "전송 (Enter)" }, isAgentRunning ? '실행 중...' : (isRejectionMode ? '거부' : '전송'))),
             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-mode-bar" },
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-mode-toggle-container" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: `jp-agent-mode-toggle ${inputMode === 'agent' ? 'jp-agent-mode-toggle--active' : ''}`, onClick: toggleMode, title: `${inputMode === 'agent' ? 'Agent' : 'Chat'} 모드 (⇧Tab)` },
@@ -2830,6 +3639,8 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
     const [openaiApiKey, setOpenaiApiKey] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.openai?.apiKey || '');
     const [openaiModel, setOpenaiModel] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.openai?.model || 'gpt-4');
     const [systemPrompt, setSystemPrompt] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.systemPrompt || '');
+    const [workspaceRoot, setWorkspaceRoot] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.workspaceRoot || '');
+    const [autoApprove, setAutoApprove] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(Boolean(initConfig.autoApprove));
     // Update state when currentConfig changes
     (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
         if (currentConfig) {
@@ -2851,6 +3662,8 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
             setOpenaiApiKey(currentConfig.openai?.apiKey || '');
             setOpenaiModel(currentConfig.openai?.model || 'gpt-4');
             setSystemPrompt(currentConfig.systemPrompt || (0,_services_ApiKeyManager__WEBPACK_IMPORTED_MODULE_1__.getDefaultLLMConfig)().systemPrompt || '');
+            setWorkspaceRoot(currentConfig.workspaceRoot || '');
+            setAutoApprove(Boolean(currentConfig.autoApprove));
         }
     }, [currentConfig]);
     // Helper: Build LLM config from state
@@ -2870,7 +3683,9 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
             apiKey: openaiApiKey,
             model: openaiModel
         },
-        systemPrompt: systemPrompt && systemPrompt.trim() ? systemPrompt : undefined
+        workspaceRoot: workspaceRoot.trim() ? workspaceRoot.trim() : undefined,
+        systemPrompt: systemPrompt && systemPrompt.trim() ? systemPrompt : undefined,
+        autoApprove
     });
     // Handlers for multiple API keys
     const handleAddKey = () => {
@@ -2964,6 +3779,11 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("option", { value: "gemini" }, "Google Gemini"),
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("option", { value: "vllm" }, "vLLM"),
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("option", { value: "openai" }, "OpenAI"))),
+                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-label", htmlFor: "jp-agent-workspace-root" },
+                        "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uB8E8\uD2B8",
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("small", { style: { fontWeight: 'normal', marginLeft: '8px', color: '#666' } }, "\uBE44\uC6B0\uBA74 \uD604\uC7AC \uB178\uD2B8\uBD81 \uD3F4\uB354 \uAE30\uC900, \uC808\uB300/\uC0C1\uB300 \uACBD\uB85C \uAC00\uB2A5")),
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { id: "jp-agent-workspace-root", type: "text", className: "jp-agent-settings-input", value: workspaceRoot, onChange: (e) => setWorkspaceRoot(e.target.value), placeholder: "\uC608: /Users/you/project", "data-testid": "workspace-root-input" })),
                 provider === 'gemini' && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-provider" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("h3", null, "Gemini \uC124\uC815"),
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
@@ -3028,6 +3848,11 @@ const SettingsPanel = ({ onClose, onSave, currentConfig }) => {
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("option", { value: "gpt-4" }, "GPT-4"),
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("option", { value: "gpt-4-turbo" }, "GPT-4 Turbo"),
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("option", { value: "gpt-3.5-turbo" }, "GPT-3.5 Turbo"))))),
+                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-label" }, "\uC790\uB3D9 \uC2E4\uD589 \uC2B9\uC778"),
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-checkbox" },
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { type: "checkbox", checked: autoApprove, onChange: (e) => setAutoApprove(e.target.checked), "data-testid": "auto-approve-checkbox" }),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", null, "\uC2B9\uC778 \uC5C6\uC774 \uBC14\uB85C \uC2E4\uD589 (\uCF54\uB4DC/\uD30C\uC77C/\uC178 \uD3EC\uD568)"))),
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-settings-group" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("label", { className: "jp-agent-settings-label" },
                         "System Prompt (LangChain)",
@@ -6908,34 +7733,38 @@ __webpack_require__.r(__webpack_exports__);
  */
 const STORAGE_KEY = 'hdsp-agent-llm-config';
 const DEFAULT_LANGCHAIN_SYSTEM_PROMPT = `You are an expert Python data scientist and Jupyter notebook assistant.
-Your role is to help users with data analysis, visualization, and Python coding tasks in Jupyter notebooks.
+Your role is to help users with data analysis, visualization, and Python coding tasks in Jupyter notebooks. You can use only Korean
 
 ## ⚠️ CRITICAL RULE: NEVER produce an empty response
 
 You MUST ALWAYS call a tool in every response. After any tool result, you MUST:
 1. Check your todo list - are there pending or in_progress items?
 2. If YES → call the next appropriate tool (jupyter_cell_tool, markdown_tool, etc.)
-3. If ALL todos are completed → call final_answer_tool with a summary
+3. When you suggest next steps for todo item '다음 단계 제시', you MUST create next steps in json format matching this schema:
+{
+  "next_items": [
+    {
+        "subject": "<subject for next step>",
+        "description": "<detailed description for the next step>"
+    }, ...
+  ]
+}
+4. If ALL todos are completed → call final_answer_tool with a summary
 
 NEVER end your turn without calling a tool. NEVER produce an empty response.
 
-## Available Tools
-1. **jupyter_cell_tool**: Execute Python code in a new notebook cell
-2. **markdown_tool**: Add a markdown explanation cell
-3. **final_answer_tool**: Complete the task with a summary - REQUIRED when done
-4. **read_file_tool**: Read file contents
-5. **write_file_tool**: Write file contents
-6. **list_files_tool**: List directory contents
-7. **search_workspace_tool**: Search for patterns in workspace files
-8. **search_notebook_cells_tool**: Search for patterns in notebook cells
-9. **write_todos**: Create and update task list for complex multi-step tasks
+## 🔴 MANDATORY: Resource Check Before Data Hanlding
+**ALWAYS call check_resource_tool FIRST** when the task involves:
+- Loading files: .csv, .parquet, .json, .xlsx, .pickle, .h5, .feather
+- Handling datasets(dataframe) with pandas, polars, dask, or similar libraries
+- Training ML models on data files
 
 ## Mandatory Workflow
 1. After EVERY tool result, immediately call the next tool
 2. Continue until ALL todos show status: "completed"
 3. ONLY THEN call final_answer_tool to summarize
-4. If \`!pip install\` fails, use \`!pip3 install\` instead
-5. For plots and charts, use English text only
+4. Only use jupyter_cell_tool for Python code or when the user explicitly asks to run in a notebook cell
+5. For plots and charts, use English text only.
 
 ## ❌ FORBIDDEN (will break the workflow)
 - Producing an empty response (no tool call, no content)
@@ -7027,7 +7856,8 @@ function getDefaultLLMConfig() {
             endpoint: 'http://localhost:8000',
             model: 'default'
         },
-        systemPrompt: DEFAULT_LANGCHAIN_SYSTEM_PROMPT
+        systemPrompt: DEFAULT_LANGCHAIN_SYSTEM_PROMPT,
+        autoApprove: false
     };
 }
 /**
@@ -7254,6 +8084,8 @@ __webpack_require__.r(__webpack_exports__);
 class ApiService {
     // 생성자에서 baseUrl을 선택적으로 받도록 하되, 없으면 자동으로 계산
     constructor(baseUrl) {
+        this.resourceUsageCache = null;
+        this.resourceUsageCacheMs = 15000;
         if (baseUrl) {
             this.baseUrl = baseUrl;
         }
@@ -7293,6 +8125,35 @@ class ApiService {
             'X-XSRFToken': this.getCsrfToken()
         };
     }
+    async getResourceUsageSnapshot() {
+        const now = Date.now();
+        if (this.resourceUsageCache
+            && now - this.resourceUsageCache.timestamp < this.resourceUsageCacheMs) {
+            return this.resourceUsageCache.resource;
+        }
+        try {
+            const response = await fetch(`${this.baseUrl}/resource-usage`, {
+                method: 'GET',
+                credentials: 'include'
+            });
+            if (!response.ok) {
+                return null;
+            }
+            const payload = await response.json().catch(() => ({}));
+            const candidate = payload?.resource ?? payload;
+            const snapshot = candidate && typeof candidate === 'object' && !Array.isArray(candidate)
+                ? candidate
+                : null;
+            if (snapshot) {
+                this.resourceUsageCache = { resource: snapshot, timestamp: now };
+            }
+            return snapshot;
+        }
+        catch (error) {
+            console.warn('[ApiService] Resource usage fetch failed:', error);
+            return null;
+        }
+    }
     // ═══════════════════════════════════════════════════════════════════════════
     // Global Rate Limit Handling with Key Rotation
     // ═══════════════════════════════════════════════════════════════════════════
@@ -7401,7 +8262,9 @@ class ApiService {
      * - Server receives ONLY ONE key per request
      * - On 429 rate limit, frontend rotates key and retries with next key
      */
-    async sendMessageStream(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall) {
+    async sendMessageStream(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall, onComplete, // Callback to capture thread_id for context persistence
+    threadId // Optional thread_id to continue existing conversation
+    ) {
         // Maximum retry attempts (should match number of keys)
         const MAX_RETRIES = 10;
         let currentConfig = request.llmConfig;
@@ -7412,7 +8275,7 @@ class ApiService {
                 ? { ...request, llmConfig: (0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.buildSingleKeyConfig)(currentConfig) }
                 : request;
             try {
-                await this.sendMessageStreamInternal(requestToSend, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall);
+                await this.sendMessageStreamInternal(requestToSend, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall, onComplete, threadId);
                 // Success - reset key rotation state
                 (0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.resetKeyRotation)();
                 return;
@@ -7462,11 +8325,16 @@ class ApiService {
      * Internal streaming implementation (without retry logic)
      * Uses LangChain agent endpoint for improved middleware support
      */
-    async sendMessageStreamInternal(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall) {
+    async sendMessageStreamInternal(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall, onComplete, threadId) {
         // Convert IChatRequest to LangChain AgentRequest format
         // Frontend's context has limited fields, map what's available
+        const resourceContext = await this.getResourceUsageSnapshot();
+        const requestConfig = resourceContext && request.llmConfig
+            ? { ...request.llmConfig, resourceContext }
+            : request.llmConfig;
         const langchainRequest = {
             request: request.message,
+            threadId: threadId,
             notebookContext: request.context ? {
                 notebook_path: request.context.notebookPath,
                 cell_count: 0,
@@ -7474,15 +8342,22 @@ class ApiService {
                 defined_variables: [],
                 recent_cells: request.context.selectedCells?.map(cell => ({ source: cell })) || []
             } : undefined,
-            llmConfig: request.llmConfig,
+            llmConfig: requestConfig,
             workspaceRoot: '.'
         };
+        // Debug: log request size
+        const requestBody = JSON.stringify(langchainRequest);
+        console.log('[ApiService] Sending langchain request:', {
+            messageLength: request.message.length,
+            bodyLength: requestBody.length,
+            threadId: threadId,
+        });
         // Use LangChain streaming endpoint
         const response = await fetch(`${this.baseUrl}/agent/langchain/stream`, {
             method: 'POST',
             headers: this.getHeaders(),
             credentials: 'include',
-            body: JSON.stringify(langchainRequest)
+            body: requestBody
         });
         if (!response.ok) {
             const error = await response.text();
@@ -7529,6 +8404,15 @@ class ApiService {
                                 if (onDebugClear) {
                                     onDebugClear();
                                 }
+                                // Capture thread_id for context persistence across cycles
+                                console.log('[ApiService] Complete event received, data:', data);
+                                if (onComplete && data.thread_id) {
+                                    console.log('[ApiService] Calling onComplete with threadId:', data.thread_id);
+                                    onComplete({ threadId: data.thread_id });
+                                }
+                                else {
+                                    console.log('[ApiService] onComplete not called - onComplete:', !!onComplete, 'thread_id:', data.thread_id);
+                                }
                                 return;
                             }
                             // Handle errors
@@ -7561,7 +8445,9 @@ class ApiService {
                                 onToolCall({
                                     tool: data.tool,
                                     code: data.code,
-                                    content: data.content
+                                    content: data.content,
+                                    command: data.command,
+                                    timeout: data.timeout
                                 });
                                 currentEventType = '';
                                 continue;
@@ -7612,6 +8498,10 @@ class ApiService {
      * Resume interrupted agent execution with user decision
      */
     async resumeAgent(threadId, decision, args, feedback, llmConfig, onChunk, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall) {
+        const resourceContext = await this.getResourceUsageSnapshot();
+        const requestConfig = resourceContext && llmConfig
+            ? { ...llmConfig, resourceContext }
+            : llmConfig;
         const resumeRequest = {
             threadId,
             decisions: [{
@@ -7619,7 +8509,7 @@ class ApiService {
                     args,
                     feedback
                 }],
-            llmConfig,
+            llmConfig: requestConfig,
             workspaceRoot: '.'
         };
         const response = await fetch(`${this.baseUrl}/agent/langchain/resume`, {
@@ -7704,7 +8594,9 @@ class ApiService {
                                 onToolCall({
                                     tool: data.tool,
                                     code: data.code,
-                                    content: data.content
+                                    content: data.content,
+                                    command: data.command,
+                                    timeout: data.timeout
                                 });
                                 currentEventType = '';
                                 continue;
@@ -7724,6 +8616,194 @@ class ApiService {
             reader.releaseLock();
         }
     }
+    async executeCommand(command, timeout, cwd, stdin) {
+        const response = await fetch(`${this.baseUrl}/execute-command`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({ command, timeout, cwd, stdin })
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = payload.error || 'Failed to execute command';
+            throw new Error(errorMessage);
+        }
+        return payload;
+    }
+    async executeCommandStream(command, options) {
+        const response = await fetch(`${this.baseUrl}/execute-command/stream`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({
+                command,
+                timeout: options?.timeout,
+                cwd: options?.cwd,
+                stdin: options?.stdin
+            })
+        });
+        if (!response.ok) {
+            const payload = await response.json().catch(() => ({}));
+            const errorMessage = payload.error || 'Failed to execute command';
+            throw new Error(errorMessage);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let result = null;
+        let streamError = null;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                let currentEventType = '';
+                for (const line of lines) {
+                    if (line.startsWith('event: ')) {
+                        currentEventType = line.slice(7).trim();
+                        continue;
+                    }
+                    if (!line.startsWith('data: ')) {
+                        continue;
+                    }
+                    let data;
+                    try {
+                        data = JSON.parse(line.slice(6));
+                    }
+                    catch (e) {
+                        continue;
+                    }
+                    if (currentEventType === 'output') {
+                        if (typeof data.text === 'string' && options?.onOutput) {
+                            options.onOutput({
+                                stream: data.stream === 'stderr' ? 'stderr' : 'stdout',
+                                text: data.text
+                            });
+                        }
+                        currentEventType = '';
+                        continue;
+                    }
+                    if (currentEventType === 'error') {
+                        streamError = data.error || 'Command execution failed';
+                        currentEventType = '';
+                        continue;
+                    }
+                    if (currentEventType === 'result') {
+                        result = data;
+                        return result;
+                    }
+                    currentEventType = '';
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        if (streamError) {
+            throw new Error(streamError);
+        }
+        if (!result) {
+            throw new Error('No command result received');
+        }
+        return result;
+    }
+    async writeFile(path, content, options) {
+        const response = await fetch(`${this.baseUrl}/write-file`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({
+                path,
+                content,
+                encoding: options?.encoding,
+                overwrite: options?.overwrite,
+                cwd: options?.cwd
+            })
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = payload.error || 'Failed to write file';
+            throw new Error(errorMessage);
+        }
+        return payload;
+    }
+    /**
+     * Search workspace for files matching pattern
+     * Executed on Jupyter server using grep/ripgrep
+     */
+    async searchWorkspace(options) {
+        const response = await fetch(`${this.baseUrl}/search-workspace`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({
+                pattern: options.pattern,
+                file_types: options.file_types || ['*.py', '*.ipynb'],
+                path: options.path || '.',
+                max_results: options.max_results || 50,
+                case_sensitive: options.case_sensitive || false
+            })
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = payload.error || 'Failed to search workspace';
+            throw new Error(errorMessage);
+        }
+        return payload;
+    }
+    /**
+     * Search notebook cells for pattern
+     * Executed on Jupyter server
+     */
+    async searchNotebookCells(options) {
+        const response = await fetch(`${this.baseUrl}/search-notebook-cells`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({
+                pattern: options.pattern,
+                notebook_path: options.notebook_path,
+                cell_type: options.cell_type,
+                max_results: options.max_results || 30,
+                case_sensitive: options.case_sensitive || false
+            })
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = payload.error || 'Failed to search notebook cells';
+            throw new Error(errorMessage);
+        }
+        return payload;
+    }
+    /**
+     * Check system resources and file sizes before data processing
+     * Executed on Jupyter server
+     */
+    async checkResource(options) {
+        const response = await fetch(`${this.baseUrl}/check-resource`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({
+                files: options.files || [],
+                dataframes: options.dataframes || [],
+                file_size_command: options.file_size_command || '',
+                dataframe_check_code: options.dataframe_check_code || ''
+            })
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = payload.error || 'Failed to check resources';
+            throw new Error(errorMessage);
+        }
+        return payload;
+    }
     /**
      * Save configuration
      */
@@ -9238,9 +10318,9 @@ class ToolExecutor {
                 },
             });
         }
-        // execute_command 도구 등록 (조건부 승인)
-        const executeCommandDef = _ToolRegistry__WEBPACK_IMPORTED_MODULE_1__.BUILTIN_TOOL_DEFINITIONS.find(t => t.name === 'execute_command');
-        if (executeCommandDef && !this.registry.hasTool('execute_command')) {
+        // execute_command_tool 도구 등록 (조건부 승인)
+        const executeCommandDef = _ToolRegistry__WEBPACK_IMPORTED_MODULE_1__.BUILTIN_TOOL_DEFINITIONS.find(t => t.name === 'execute_command_tool');
+        if (executeCommandDef && !this.registry.hasTool('execute_command_tool')) {
             this.registry.register({
                 ...executeCommandDef,
                 executor: async (params, context) => {
@@ -9620,6 +10700,11 @@ class ToolExecutor {
     isDangerousCommand(command) {
         return _ToolRegistry__WEBPACK_IMPORTED_MODULE_1__.DANGEROUS_COMMAND_PATTERNS.some(pattern => pattern.test(command));
     }
+    summarizeOutput(output, maxLines = 2) {
+        const lines = output.split(/\r?\n/).filter(line => line.length > 0);
+        const text = lines.slice(0, maxLines).join('\n');
+        return { text, truncated: lines.length > maxLines };
+    }
     /**
      * read_file 도구: 파일 읽기
      */
@@ -10037,19 +11122,19 @@ print(json.dumps(result))
         }
     }
     /**
-     * execute_command 도구: 셸 명령 실행 (조건부 승인)
+     * execute_command_tool 도구: 셸 명령 실행 (조건부 승인)
      */
     async executeCommand(params, context) {
         console.log('[ToolExecutor] executeCommand:', params.command);
-        const timeout = params.timeout || 30000;
+        const timeout = typeof params.timeout === 'number' ? params.timeout : 600000;
         // 위험 명령 검사 및 조건부 승인 요청
         if (this.isDangerousCommand(params.command)) {
             console.log('[ToolExecutor] Dangerous command detected, requesting approval');
             // 승인 요청
             const request = {
-                id: `execute_command-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-                toolName: 'execute_command',
-                toolDefinition: this.registry.getTool('execute_command'),
+                id: `execute_command_tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                toolName: 'execute_command_tool',
+                toolDefinition: this.registry.getTool('execute_command_tool'),
                 parameters: params,
                 stepNumber: context.stepNumber,
                 description: `🔴 위험 명령 실행 요청:\n\n\`${params.command}\`\n\n이 명령은 시스템에 영향을 줄 수 있습니다.`,
@@ -10066,56 +11151,32 @@ print(json.dumps(result))
                 }
             }
         }
-        // Python subprocess로 명령 실행
-        const pythonCode = `
-import json
-import subprocess
-import sys
-try:
-    command = ${JSON.stringify(params.command)}
-    timeout_sec = ${timeout / 1000}
-
-    result = subprocess.run(
-        command,
-        shell=True,
-        capture_output=True,
-        text=True,
-        timeout=timeout_sec
-    )
-
-    output = {
-        'success': result.returncode == 0,
-        'stdout': result.stdout,
-        'stderr': result.stderr,
-        'returncode': result.returncode
-    }
-except subprocess.TimeoutExpired:
-    output = {'success': False, 'error': f'Command timed out after {timeout_sec}s'}
-except Exception as e:
-    output = {'success': False, 'error': str(e)}
-print(json.dumps(output))
-`.trim();
+        if (!this.apiService) {
+            return { success: false, error: 'ApiService not available for execute_command_tool' };
+        }
         try {
-            const execResult = await this.executeInKernel(pythonCode);
-            if (execResult.status === 'ok' && execResult.stdout) {
-                const parsed = JSON.parse(execResult.stdout.trim());
-                if (parsed.success) {
-                    return {
-                        success: true,
-                        output: parsed.stdout || '(no output)',
-                    };
-                }
-                else {
-                    return {
-                        success: false,
-                        error: parsed.error || parsed.stderr || `Command failed with code ${parsed.returncode}`,
-                    };
-                }
+            const result = await this.apiService.executeCommandStream(params.command, { timeout });
+            const stdout = typeof result.stdout === 'string' ? result.stdout : '';
+            const stderr = typeof result.stderr === 'string' ? result.stderr : '';
+            const combined = [stdout, stderr].filter(Boolean).join('\n');
+            const summary = this.summarizeOutput(combined, 2);
+            const output = summary.text || '(no output)';
+            if (result.success) {
+                return {
+                    success: true,
+                    output,
+                };
             }
-            return { success: false, error: execResult.error?.evalue || 'Command execution failed' };
+            const errorText = summary.text || result.error || stderr || `Command failed with code ${result.returncode}`;
+            return {
+                success: false,
+                error: errorText,
+            };
         }
         catch (error) {
-            return { success: false, error: error.message };
+            const message = error instanceof Error ? error.message : 'Command execution failed';
+            const summary = this.summarizeOutput(String(message), 2);
+            return { success: false, error: summary.text || 'Command execution failed' };
         }
     }
     /**
@@ -11901,7 +12962,7 @@ const BUILTIN_TOOL_DEFINITIONS = [
     // 확장 도구 (시스템)
     // ─────────────────────────────────────────────────────────────────────────
     {
-        name: 'execute_command',
+        name: 'execute_command_tool',
         description: '셸 명령 실행 (위험 명령만 승인 필요)',
         riskLevel: 'critical',
         requiresApproval: false,
@@ -11986,7 +13047,7 @@ const BUILTIN_TOOL_DEFINITIONS = [
 ];
 /**
  * 위험한 셸 명령 패턴들
- * execute_command에서 이 패턴에 매칭되는 명령은 사용자 승인 필요
+ * execute_command_tool에서 이 패턴에 매칭되는 명령은 사용자 승인 필요
  */
 const DANGEROUS_COMMAND_PATTERNS = [
     // 파일 삭제/제거
@@ -12515,6 +13576,154 @@ function normalizeIndentation(code) {
     });
     return normalized.join('\n');
 }
+function extractNextItemsBlock(text) {
+    if (!text.trim())
+        return null;
+    const fencedRegex = /```(\w+)?\n([\s\S]*?)```/g;
+    let match;
+    while ((match = fencedRegex.exec(text)) !== null) {
+        const lang = (match[1] || '').toLowerCase();
+        const content = match[2].trim();
+        if (!content)
+            continue;
+        if (lang && lang !== 'json' && !content.includes('"next_items"')) {
+            continue;
+        }
+        const items = parseNextItemsPayload(content);
+        if (items) {
+            const placeholder = `__NEXT_ITEMS_${Math.random().toString(36).slice(2, 11)}__`;
+            const updated = text.slice(0, match.index) + placeholder + text.slice(match.index + match[0].length);
+            return { items, placeholder, text: updated };
+        }
+    }
+    const range = findNextItemsJsonRange(text);
+    if (!range)
+        return null;
+    const candidate = text.slice(range.start, range.end + 1);
+    const items = parseNextItemsPayload(candidate);
+    if (!items)
+        return null;
+    let replacementStart = range.start;
+    const lineStart = text.lastIndexOf('\n', range.start - 1) + 1;
+    const linePrefix = text.slice(lineStart, range.start).trim();
+    const normalizedPrefix = linePrefix.replace(/[：:]$/, '').toLowerCase();
+    if (normalizedPrefix === 'json') {
+        replacementStart = lineStart;
+    }
+    const placeholder = `__NEXT_ITEMS_${Math.random().toString(36).slice(2, 11)}__`;
+    const updated = text.slice(0, replacementStart) + placeholder + text.slice(range.end + 1);
+    return { items, placeholder, text: updated };
+}
+function findNextItemsJsonRange(text) {
+    const key = '"next_items"';
+    let searchIndex = text.indexOf(key);
+    while (searchIndex !== -1) {
+        const start = text.lastIndexOf('{', searchIndex);
+        if (start === -1)
+            return null;
+        const end = findMatchingBrace(text, start);
+        if (end !== -1) {
+            return { start, end };
+        }
+        searchIndex = text.indexOf(key, searchIndex + key.length);
+    }
+    return null;
+}
+function findMatchingBrace(text, start) {
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i++) {
+        const char = text[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{') {
+            depth += 1;
+        }
+        else if (char === '}') {
+            depth -= 1;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+function parseNextItemsPayload(payload) {
+    if (!payload.startsWith('{') || !payload.endsWith('}'))
+        return null;
+    try {
+        const parsed = JSON.parse(payload);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return null;
+        const nextItemsRaw = parsed.next_items;
+        if (!Array.isArray(nextItemsRaw))
+            return null;
+        const items = nextItemsRaw
+            .map((item) => {
+            if (!item || typeof item !== 'object')
+                return null;
+            const subject = typeof item.subject === 'string'
+                ? item.subject.trim()
+                : '';
+            const description = typeof item.description === 'string'
+                ? item.description.trim()
+                : '';
+            if (!subject && !description)
+                return null;
+            return { subject, description };
+        })
+            .filter((item) => Boolean(item));
+        return items.length > 0 ? items : null;
+    }
+    catch {
+        return null;
+    }
+}
+function renderNextItemsList(items) {
+    // Simple arrow icon
+    const arrowSvg = `
+<svg class="jp-next-items-icon" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true">
+  <path fill-rule="evenodd" d="M7.293 14.707a1 1 0 010-1.414L10.586 10 7.293 6.707a1 1 0 011.414-1.414l4 4a1 1 0 010 1.414l-4 4a1 1 0 01-1.414 0z"/>
+</svg>`;
+    const listItems = items.map((item) => {
+        const subject = escapeHtml(item.subject);
+        const description = escapeHtml(item.description);
+        const subjectHtml = subject ? `<div class="jp-next-items-subject">${subject}</div>` : '';
+        const descriptionHtml = description ? `<div class="jp-next-items-description">${description}</div>` : '';
+        return `
+<li class="jp-next-items-item" data-next-item="true" role="button" tabindex="0">
+  <div class="jp-next-items-text">
+    ${subjectHtml}
+    ${descriptionHtml}
+  </div>
+  ${arrowSvg}
+</li>`;
+    }).join('');
+    return `
+<div class="jp-next-items" data-next-items="true">
+  <div class="jp-next-items-header">다음 단계 제안</div>
+  <ul class="jp-next-items-list" role="list">
+    ${listItems}
+  </ul>
+</div>`;
+}
 /**
  * Highlight Python code with inline styles
  */
@@ -12915,9 +14124,10 @@ function parseMarkdownTable(tableText) {
  * Format markdown text to HTML with syntax highlighting
  */
 function formatMarkdownToHtml(text) {
+    const nextItemsBlock = extractNextItemsBlock(text);
     // Decode HTML entities if present
     const textarea = document.createElement('textarea');
-    textarea.innerHTML = text;
+    textarea.innerHTML = nextItemsBlock ? nextItemsBlock.text : text;
     let html = textarea.value;
     // Step 0.5: Protect DataFrame HTML tables (must be before code blocks)
     const dataframeHtmlPlaceholders = [];
@@ -12959,6 +14169,9 @@ function formatMarkdownToHtml(text) {
             '</div>' +
             '</div>' +
             '<pre class="code-block language-' + escapeHtml(lang) + '"><code id="' + blockId + '">' + highlightedCode + '</code></pre>' +
+            '<button class="code-block-toggle" data-block-id="' + blockId + '" title="전체 보기" aria-label="전체 보기" aria-expanded="false">' +
+            '<span class="code-block-toggle-icon" aria-hidden="true">▾</span>' +
+            '</button>' +
             '</div>';
         codeBlockPlaceholders.push({
             placeholder: placeholder,
@@ -13020,7 +14233,7 @@ function formatMarkdownToHtml(text) {
         return '\n' + placeholder + '\n';
     });
     // Step 4: Escape HTML for non-placeholder text
-    html = html.split(/(__(?:DATAFRAME_HTML|CODE_BLOCK|INLINE_CODE|TABLE)_[a-z0-9-]+__)/gi)
+    html = html.split(/(__(?:DATAFRAME_HTML|CODE_BLOCK|INLINE_CODE|TABLE|NEXT_ITEMS)_[a-z0-9-]+__)/gi)
         .map((part, index) => {
         // Odd indices are placeholders - keep as is
         if (index % 2 === 1)
@@ -13068,6 +14281,10 @@ function formatMarkdownToHtml(text) {
     codeBlockPlaceholders.forEach(item => {
         html = html.replace(item.placeholder, item.html);
     });
+    // Step 8.5: Restore next items list placeholders
+    if (nextItemsBlock) {
+        html = html.split(nextItemsBlock.placeholder).join(renderNextItemsList(nextItemsBlock.items));
+    }
     return html;
 }
 
@@ -13229,4 +14446,4 @@ __webpack_require__.r(__webpack_exports__);
 /***/ }
 
 }]);
-//# sourceMappingURL=lib_index_js.a223ea20056954479ae9.js.map
+//# sourceMappingURL=lib_index_js.29cf4312af19e86f82af.js.map