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

jupyter_ext/labextension/static/{lib_index_js.a223ea20056954479ae9.js → lib_index_js.e4ff4b5779b5e049f84c.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,231 @@ 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 mode:', inputMode, 'agentThreadId:', agentThreadId);
+            // Chat 모드: 단순 Q&A (sendChatStream)
+            // Agent V2 모드 또는 그 외: LangChain Deep Agent (sendAgentV2Stream)
+            if (inputMode === 'chat') {
+                // 단순 Chat 모드 - /chat/stream 사용
+                await apiService.sendChatStream({
+                    message: messageToSend,
+                    conversationId: conversationId || undefined,
+                    llmConfig: currentConfig
+                }, 
+                // onChunk callback
+                (chunk) => {
+                    streamedContent += chunk;
+                    setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
+                        ? { ...msg, content: streamedContent }
+                        : msg));
+                }, 
+                // onMetadata callback
+                (metadata) => {
+                    if (metadata.conversationId && !conversationId) {
+                        setConversationId(metadata.conversationId);
+                    }
+                });
+            }
+            else {
+                // Agent V2 모드 - /agent/langchain/stream 사용 (HITL, Todo, 도구 실행)
+                await apiService.sendAgentV2Stream({
+                    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) {
+                        // 자동 승인 모드일 때도 인터럽트 메시지를 생성하여 코드블럭으로 표시
+                        upsertInterruptMessage(interrupt, true);
+                        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 +1270,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 +1860,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,7 +1887,161 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
         ];
         return lines.every(line => allowedPatterns.some(pattern => pattern.test(line)));
     };
-    const upsertInterruptMessage = (interrupt) => {
+    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, autoApproved) => {
         const interruptMessageId = interruptMessageIdRef.current || makeMessageId('interrupt');
         interruptMessageIdRef.current = interruptMessageId;
         const interruptMessage = {
@@ -1599,7 +2049,14 @@ const ChatPanel = (0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(({ apiServic
             role: 'system',
             content: interrupt.description || '코드 실행 승인이 필요합니다.',
             timestamp: Date.now(),
-            metadata: { interrupt }
+            metadata: {
+                interrupt: {
+                    ...interrupt,
+                    resolved: autoApproved || false,
+                    decision: autoApproved ? 'approve' : undefined,
+                    autoApproved: autoApproved || false
+                }
+            }
         };
         setMessages(prev => {
             const hasExisting = prev.some(msg => msg.id === interruptMessageId);
@@ -1609,7 +2066,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 +2081,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,68 +2090,781 @@ 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
-                };
+    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' };
+        }
+        if (trimmed.includes('..')) {
+            return { valid: false, error: 'Path traversal (..) is not allowed' };
+        }
+        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');
             }
-            else if (executed && executed.tool === 'markdown') {
-                resumeDecision = 'edit';
-                resumeArgs = {
-                    content: executed.content
-                };
+            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 };
         }
-        else {
-            pendingToolCallsRef.current.shift();
-            approvalPendingRef.current = pendingToolCallsRef.current.length > 0;
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to load contents';
+            return { success: false, error: message };
         }
-        setIsLoading(true);
-        setIsStreaming(true);
-        let interrupted = false;
-        // 항상 새 메시지 생성 - 승인 UI 아래에 append되도록
-        const assistantMessageId = makeMessageId('assistant');
-        setStreamingMessageId(assistantMessageId);
-        // 새 메시지 추가 (맨 아래에 append)
-        setMessages(prev => [
-            ...prev,
-            {
-                id: assistantMessageId,
-                role: 'assistant',
-                content: '',
-                timestamp: Date.now()
+    };
+    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;
             }
-        ]);
-        let streamedContent = '';
-        try {
-            await apiService.resumeAgent(threadId, resumeDecision, resumeArgs, resumeDecision === 'reject' ? 'User rejected this action' : undefined, llmConfig || undefined, (chunk) => {
-                streamedContent += chunk;
-                setMessages(prev => prev.map(msg => msg.id === assistantMessageId && isChatMessage(msg)
-                    ? { ...msg, content: streamedContent }
-                    : msg));
-            }, (status) => {
-                setDebugStatus(status);
+            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 = 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) {
+                    // 자동 승인 모드일 때도 인터럽트 메시지를 생성하여 코드블럭으로 표시
+                    upsertInterruptMessage(nextInterrupt, true);
+                    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 === 'edit_file_tool') {
+                // Handle edit_file_tool - read file, perform replacement, write back
+                try {
+                    setDebugStatus('✏️ 파일 수정 중...');
+                    const filePath = interrupt.args?.path || '';
+                    const oldString = interrupt.args?.old_string || '';
+                    const newString = interrupt.args?.new_string || '';
+                    const replaceAll = interrupt.args?.replace_all || false;
+                    // Read current file content
+                    const readResult = await apiService.readFile(filePath);
+                    if (!readResult.success || readResult.content === undefined) {
+                        throw new Error(readResult.error || 'Failed to read file');
+                    }
+                    const originalContent = readResult.content;
+                    const occurrences = (originalContent.match(new RegExp(oldString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+                    if (occurrences === 0) {
+                        throw new Error(`String not found in file: '${oldString.slice(0, 100)}...'`);
+                    }
+                    if (occurrences > 1 && !replaceAll) {
+                        throw new Error(`String appears ${occurrences} times. Use replace_all=True or provide more context.`);
+                    }
+                    // Perform replacement
+                    const newContent = replaceAll
+                        ? originalContent.split(oldString).join(newString)
+                        : originalContent.replace(oldString, newString);
+                    // Generate diff for logging
+                    const diffLines = [];
+                    const originalLines = originalContent.split('\n');
+                    const newLines = newContent.split('\n');
+                    diffLines.push(`--- ${filePath} (before)`);
+                    diffLines.push(`+++ ${filePath} (after)`);
+                    // Simple diff generation
+                    let i = 0, j = 0;
+                    while (i < originalLines.length || j < newLines.length) {
+                        if (i < originalLines.length && j < newLines.length && originalLines[i] === newLines[j]) {
+                            i++;
+                            j++;
+                        }
+                        else if (i < originalLines.length && (j >= newLines.length || originalLines[i] !== newLines[j])) {
+                            diffLines.push(`-${originalLines[i]}`);
+                            i++;
+                        }
+                        else {
+                            diffLines.push(`+${newLines[j]}`);
+                            j++;
+                        }
+                    }
+                    const diff = diffLines.join('\n');
+                    // Write the modified content
+                    const writeResult = await apiService.writeFile(filePath, newContent, {
+                        encoding: 'utf-8',
+                        overwrite: true
+                    });
+                    console.log('[AgentPanel] edit_file result:', writeResult);
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: {
+                            ...writeResult,
+                            diff,
+                            occurrences,
+                            lines_added: newLines.length - originalLines.length > 0 ? newLines.length - originalLines.length : 0,
+                            lines_removed: originalLines.length - newLines.length > 0 ? originalLines.length - newLines.length : 0,
+                        }
+                    };
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'File edit failed';
+                    console.error('[AgentPanel] edit_file error:', error);
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: { success: false, error: message }
+                    };
+                }
+            }
+            else if (interrupt.action === 'multiedit_file_tool') {
+                // Handle multiedit_file_tool - apply multiple edits atomically (Crush 패턴)
+                try {
+                    setDebugStatus('✏️ 다중 파일 수정 중...');
+                    const filePath = interrupt.args?.path || '';
+                    const edits = interrupt.args?.edits || [];
+                    if (!filePath || edits.length === 0) {
+                        throw new Error('File path and edits are required');
+                    }
+                    // Read current file content
+                    const readResult = await apiService.readFile(filePath);
+                    if (!readResult.success || readResult.content === undefined) {
+                        throw new Error(readResult.error || 'Failed to read file');
+                    }
+                    const originalContent = readResult.content;
+                    let currentContent = originalContent;
+                    let editsApplied = 0;
+                    let editsFailed = 0;
+                    const failedEdits = [];
+                    // Apply edits sequentially
+                    for (let i = 0; i < edits.length; i++) {
+                        const edit = edits[i];
+                        const oldString = edit.old_string || '';
+                        const newString = edit.new_string || '';
+                        const replaceAll = edit.replace_all || false;
+                        const occurrences = (currentContent.match(new RegExp(oldString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g')) || []).length;
+                        if (occurrences === 0) {
+                            failedEdits.push(`Edit ${i + 1}: String not found`);
+                            editsFailed++;
+                            continue;
+                        }
+                        if (occurrences > 1 && !replaceAll) {
+                            failedEdits.push(`Edit ${i + 1}: String appears ${occurrences} times (use replace_all)`);
+                            editsFailed++;
+                            continue;
+                        }
+                        // Apply this edit
+                        currentContent = replaceAll
+                            ? currentContent.split(oldString).join(newString)
+                            : currentContent.replace(oldString, newString);
+                        editsApplied++;
+                    }
+                    // Generate diff
+                    const diffLines = [];
+                    const originalLines = originalContent.split('\n');
+                    const newLines = currentContent.split('\n');
+                    diffLines.push(`--- ${filePath} (before)`);
+                    diffLines.push(`+++ ${filePath} (after)`);
+                    let i = 0, j = 0;
+                    while (i < originalLines.length || j < newLines.length) {
+                        if (i < originalLines.length && j < newLines.length && originalLines[i] === newLines[j]) {
+                            i++;
+                            j++;
+                        }
+                        else if (i < originalLines.length && (j >= newLines.length || originalLines[i] !== newLines[j])) {
+                            diffLines.push(`-${originalLines[i]}`);
+                            i++;
+                        }
+                        else {
+                            diffLines.push(`+${newLines[j]}`);
+                            j++;
+                        }
+                    }
+                    const diff = diffLines.join('\n');
+                    // Write the modified content if any edits succeeded
+                    if (editsApplied > 0) {
+                        const writeResult = await apiService.writeFile(filePath, currentContent, {
+                            encoding: 'utf-8',
+                            overwrite: true
+                        });
+                        console.log('[AgentPanel] multiedit_file result:', writeResult, 'applied:', editsApplied, 'failed:', editsFailed);
+                        resumeDecision = 'edit';
+                        resumeArgs = {
+                            ...interrupt.args,
+                            execution_result: {
+                                ...writeResult,
+                                diff,
+                                edits_applied: editsApplied,
+                                edits_failed: editsFailed,
+                                failed_details: failedEdits,
+                                lines_added: newLines.length - originalLines.length > 0 ? newLines.length - originalLines.length : 0,
+                                lines_removed: originalLines.length - newLines.length > 0 ? originalLines.length - newLines.length : 0,
+                            }
+                        };
+                    }
+                    else {
+                        throw new Error(`All ${edits.length} edits failed: ${failedEdits.join('; ')}`);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Multi-edit failed';
+                    console.error('[AgentPanel] multiedit_file error:', error);
+                    resumeDecision = 'edit';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: { success: false, error: message, edits_applied: 0, edits_failed: 0 }
+                    };
+                }
+            }
+            else if (interrupt.action === 'diagnostics_tool') {
+                // Handle diagnostics_tool - get LSP diagnostics via LSP Bridge
+                try {
+                    setDebugStatus('🔍 LSP 진단 조회 중...');
+                    const filePath = interrupt.args?.path || null;
+                    const severityFilter = interrupt.args?.severity_filter || null;
+                    // Get LSP Bridge instance
+                    const lspBridge = window._hdspLSPBridge;
+                    if (lspBridge && lspBridge.isLSPAvailable()) {
+                        const result = await lspBridge.getDiagnostics(filePath);
+                        // Apply severity filter if specified
+                        let diagnostics = result.diagnostics;
+                        if (severityFilter) {
+                            diagnostics = diagnostics.filter((d) => d.severity === severityFilter);
+                        }
+                        resumeDecision = 'approve';
+                        resumeArgs = {
+                            ...interrupt.args,
+                            execution_result: {
+                                success: true,
+                                lsp_available: true,
+                                diagnostics
+                            }
+                        };
+                    }
+                    else {
+                        // LSP not available - return empty result
+                        console.log('[AgentPanel] LSP not available, returning empty diagnostics');
+                        resumeDecision = 'approve';
+                        resumeArgs = {
+                            ...interrupt.args,
+                            execution_result: {
+                                success: true,
+                                lsp_available: false,
+                                diagnostics: []
+                            }
+                        };
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Diagnostics failed';
+                    console.error('[AgentPanel] diagnostics_tool error:', error);
+                    resumeDecision = 'approve';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: { success: false, lsp_available: false, error: message, diagnostics: [] }
+                    };
+                }
+            }
+            else if (interrupt.action === 'references_tool') {
+                // Handle references_tool - find symbol references
+                try {
+                    setDebugStatus('🔗 참조 검색 중...');
+                    const symbol = interrupt.args?.symbol || '';
+                    const filePath = interrupt.args?.path || null;
+                    // Get LSP Bridge instance
+                    const lspBridge = window._hdspLSPBridge;
+                    if (lspBridge && lspBridge.isLSPAvailable()) {
+                        const result = await lspBridge.getReferences(symbol, filePath, interrupt.args?.line, interrupt.args?.character);
+                        resumeDecision = 'approve';
+                        resumeArgs = {
+                            ...interrupt.args,
+                            execution_result: {
+                                success: result.success,
+                                lsp_available: true,
+                                locations: result.locations,
+                                used_grep: false
+                            }
+                        };
+                    }
+                    else {
+                        // LSP not available - suggest using search_workspace_tool
+                        console.log('[AgentPanel] LSP not available for references, suggesting grep fallback');
+                        resumeDecision = 'approve';
+                        resumeArgs = {
+                            ...interrupt.args,
+                            execution_result: {
+                                success: false,
+                                lsp_available: false,
+                                locations: [],
+                                used_grep: false
+                            }
+                        };
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'References search failed';
+                    console.error('[AgentPanel] references_tool error:', error);
+                    resumeDecision = 'approve';
+                    resumeArgs = {
+                        ...interrupt.args,
+                        execution_result: { success: false, lsp_available: false, error: message, locations: [] }
+                    };
+                }
+            }
+            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 => [
+            ...prev,
+            {
+                id: assistantMessageId,
+                role: 'assistant',
+                content: '',
+                timestamp: Date.now()
+            }
+        ]);
+        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, rejectionFeedback, 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)());
+                // 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) {
+                    // 자동 승인 모드일 때도 인터럽트 메시지를 생성하여 코드블럭으로 표시
+                    upsertInterruptMessage(nextInterrupt, true);
+                    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;
                     }
-                    queueApprovalCell(nextInterrupt.args.code);
+                    if (shouldQueue) {
+                        queueApprovalCell(nextInterrupt.args.code);
+                    }
                 }
                 setInterruptData(nextInterrupt);
                 upsertInterruptMessage(nextInterrupt);
@@ -1728,6 +2899,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');
@@ -1751,22 +2942,24 @@ 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;
-                }
+                // [DISABLED] Python 에러가 감지되면 파일 수정 모드로 전환
+                // 이 레거시 기능은 /file/action API가 구현되지 않아 비활성화됨
+                // if (detectPythonError(currentInput)) {
+                //   console.log('[AgentPanel] Agent mode: No notebook, but Python error detected - attempting file fix');
+                //   const handled = await handlePythonErrorFix(currentInput);
+                //   if (handled) {
+                //     const userMessage: IChatMessage = {
+                //       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 = [
                     /에러.*해결/i,
@@ -1859,164 +3052,52 @@ SyntaxError: '(' was never closed
                 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;
-        }
+        // [DISABLED] Python 에러 감지 및 파일 수정 모드 (Chat 모드에서만)
+        // 이 레거시 기능은 /file/action API가 구현되지 않아 비활성화됨
+        // LangChain agent의 edit_file_tool을 사용하도록 변경됨
+        // if (inputMode === 'chat' && detectPythonError(currentInput)) {
+        //   console.log('[AgentPanel] Python error detected in message, attempting file fix...');
+        //   const handled = await handlePythonErrorFix(currentInput);
+        //   if (handled) {
+        //     const userMessage: IChatMessage = {
+        //       id: makeMessageId(),
+        //       role: 'user',
+        //       content: currentInput,
+        //       timestamp: Date.now(),
+        //     };
+        //     setMessages(prev => [...prev, userMessage]);
+        //     setInput('');
+        //     return;
+        //   }
+        //   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 ? '셀 분석 요청' : '');
-        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));
-        }
-        finally {
-            setIsLoading(false);
-            setIsStreaming(false);
-            setStreamingMessageId(null);
-            // Keep completed todos visible after the run
-        }
+        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) => {
@@ -2025,26 +3106,26 @@ SyntaxError: '(' was never closed
             e.preventDefault();
             handleSendMessage();
         }
-        // Shift+Tab: 모드 전환 (chat ↔ agent)
+        // Shift+Tab: 모드 전환 (chat → agent → agent_v2 → chat 순환)
         if (e.key === 'Tab' && e.shiftKey) {
             e.preventDefault();
-            setInputMode(prev => prev === 'chat' ? 'agent' : 'chat');
+            setInputMode(prev => prev === 'chat' ? 'agent' : prev === 'agent' ? 'agent_v2' : 'chat');
             return;
         }
         // Cmd/Ctrl + . : 모드 전환 (대체 단축키)
         if (e.key === '.' && (e.metaKey || e.ctrlKey)) {
             e.preventDefault();
-            setInputMode(prev => prev === 'chat' ? 'agent' : 'chat');
+            setInputMode(prev => prev === 'chat' ? 'agent' : prev === 'agent' ? 'agent_v2' : 'chat');
         }
         // Tab (without Shift): Agent 모드일 때 드롭다운 토글
-        if (e.key === 'Tab' && !e.shiftKey && inputMode === 'agent') {
+        if (e.key === 'Tab' && !e.shiftKey && inputMode !== 'chat') {
             e.preventDefault();
             setShowModeDropdown(prev => !prev);
         }
     };
-    // 모드 토글 함수
+    // 모드 토글 함수 (chat → agent → agent_v2 → chat 순환)
     const toggleMode = () => {
-        setInputMode(prev => prev === 'chat' ? 'agent' : 'chat');
+        setInputMode(prev => prev === 'chat' ? 'agent' : prev === 'agent' ? 'agent_v2' : 'chat');
         setShowModeDropdown(false);
     };
     const clearChat = () => {
@@ -2143,9 +3224,6 @@ SyntaxError: '(' was never closed
         if (normalized.includes('resuming execution')) {
             return '승인 반영 후 실행 재개 중...';
         }
-        if (normalized.includes('tool')) {
-            return '도구 실행 중';
-        }
         return raw;
     };
     const getStatusText = () => {
@@ -2162,6 +3240,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" },
@@ -2189,34 +3268,88 @@ SyntaxError: '(' was never closed
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("p", null, "\uC548\uB155\uD558\uC138\uC694! HDSP Agent\uC785\uB2C8\uB2E4."),
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("p", { className: "jp-agent-empty-hint" }, inputMode === 'agent'
                     ? '노트북 작업을 자연어로 요청하세요. 예: "데이터 시각화 해줘"'
-                    : '메시지를 입력하거나 아래 버튼으로 Agent 모드를 선택하세요.'))) : (messages.map(msg => {
+                    : inputMode === 'agent_v2'
+                        ? 'Deep Agent 모드입니다. HITL 승인을 통해 도구 실행을 제어할 수 있습니다.'
+                        : '메시지를 입력하거나 아래 버튼으로 Agent 모드를 선택하세요.'))) : (messages.map(msg => {
                 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 isEditFile = interruptAction === 'edit_file_tool';
+                    const writePath = (isWriteFile
+                        && typeof msg.metadata?.interrupt?.args?.path === 'string') ? msg.metadata?.interrupt?.args?.path : '';
+                    const editPath = (isEditFile
+                        && typeof msg.metadata?.interrupt?.args?.path === 'string') ? msg.metadata?.interrupt?.args?.path : '';
+                    const autoApproved = msg.metadata?.interrupt?.autoApproved;
+                    const headerRole = msg.role === 'user'
+                        ? '사용자'
+                        : msg.role === 'system'
+                            ? (isShellOutput ? 'shell 실행' : (autoApproved ? '자동 승인됨' : '승인 요청'))
+                            : '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-interrupt-description" }, msg.content),
+                        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${msg.metadata?.interrupt?.autoApproved ? ' jp-agent-interrupt-auto-approved' : ''}` },
+                            !msg.metadata?.interrupt?.autoApproved && (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...' : '';
+                                    // Handle edit_file_tool with diff preview
+                                    let snippet;
+                                    let language;
+                                    if (isEditFile) {
+                                        const oldStr = msg.metadata?.interrupt?.args?.old_string || '';
+                                        const newStr = msg.metadata?.interrupt?.args?.new_string || '';
+                                        const replaceAll = msg.metadata?.interrupt?.args?.replace_all;
+                                        // Generate simple diff preview
+                                        const oldPreview = oldStr.length > 500 ? oldStr.slice(0, 500) + '...' : oldStr;
+                                        const newPreview = newStr.length > 500 ? newStr.slice(0, 500) + '...' : newStr;
+                                        snippet = `--- ${editPath} (before)\n+++ ${editPath} (after)\n` +
+                                            oldPreview.split('\n').map((line) => `-${line}`).join('\n') + '\n' +
+                                            newPreview.split('\n').map((line) => `+${line}`).join('\n') +
+                                            (replaceAll ? '\n\n(replace_all: true)' : '');
+                                        language = 'diff';
+                                    }
+                                    else {
+                                        snippet = (command || code || '(no details)');
+                                        language = command ? 'bash' : 'python';
+                                    }
                                     const resolved = msg.metadata?.interrupt?.resolved;
-                                    const actionHtml = resolved
-                                        ? '<div class="jp-agent-interrupt-actions jp-agent-interrupt-actions--resolved">승인됨</div>'
-                                        : `
+                                    const decision = msg.metadata?.interrupt?.decision;
+                                    const autoApproved = msg.metadata?.interrupt?.autoApproved;
+                                    // 자동 승인일 때는 코드블럭 헤더에 배지가 표시되므로 actionHtml에는 표시하지 않음
+                                    const resolvedText = autoApproved ? '' : (decision === 'reject' ? '거부됨' : '승인됨');
+                                    const resolvedClass = autoApproved ? '' : (decision === 'reject' ? 'jp-agent-interrupt-actions--rejected' : 'jp-agent-interrupt-actions--resolved');
+                                    const actionHtml = resolved && !autoApproved
+                                        ? `<div class="jp-agent-interrupt-actions ${resolvedClass}">${resolvedText}</div>`
+                                        : resolved && autoApproved
+                                            ? '' // 자동 승인일 때는 actionHtml 비움 (코드블럭 헤더에 배지 표시)
+                                            : `
 <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>`);
+                                        }
+                                        if (isEditFile && editPath) {
+                                            const safePath = escapeHtml(editPath);
+                                            html = html.replace(/<span class="code-block-language">[^<]*<\/span>/, `<span class="code-block-language jp-agent-interrupt-path">✏️ ${safePath}</span>`);
+                                        }
+                                        // actionHtml이 비어있지 않을 때만 추가
+                                        return actionHtml ? html.replace('</div>', `${actionHtml}</div>`) : html;
+                                    })();
+                                    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,27 +3409,33 @@ 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" },
+        inputMode !== 'chat' && 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" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("svg", { className: `jp-agent-todo-expand-icon ${isTodoExpanded ? 'jp-agent-todo-expand-icon--expanded' : ''}`, viewBox: "0 0 16 16", fill: "currentColor", width: "12", height: "12" },
                         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,21 +3447,31 @@ 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 !== 'chat' ? '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'
+                            ? '노트북 작업을 입력하세요... (예: 데이터 시각화 해줘)'
+                            : inputMode === 'agent_v2'
+                                ? 'Deep Agent 요청을 입력하세요... (HITL 승인 모드)'
+                                : '메시지를 입력하세요...'), 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)` },
-                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("svg", { className: "jp-agent-mode-icon", viewBox: "0 0 16 16", fill: "currentColor", width: "14", height: "14" }, inputMode === 'agent' ? (
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: `jp-agent-mode-toggle ${inputMode !== 'chat' ? 'jp-agent-mode-toggle--active' : ''}`, onClick: toggleMode, title: `${inputMode === 'chat' ? 'Chat' : inputMode === 'agent' ? 'Agent' : 'Agent V2'} 모드 (⇧Tab)` },
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("svg", { className: "jp-agent-mode-icon", viewBox: "0 0 16 16", fill: "currentColor", width: "14", height: "14" }, inputMode === 'chat' ? (
+                        // 채팅 아이콘 (Chat 모드)
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M8 1C3.58 1 0 4.13 0 8c0 1.5.5 2.88 1.34 4.04L.5 15l3.37-.92A8.56 8.56 0 008 15c4.42 0 8-3.13 8-7s-3.58-7-8-7zM4.5 9a1 1 0 110-2 1 1 0 010 2zm3.5 0a1 1 0 110-2 1 1 0 010 2zm3.5 0a1 1 0 110-2 1 1 0 010 2z" })) : inputMode === 'agent' ? (
                         // 무한대 아이콘 (Agent 모드)
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M4.5 8c0-1.38 1.12-2.5 2.5-2.5.9 0 1.68.48 2.12 1.2L8 8l1.12 1.3c-.44.72-1.22 1.2-2.12 1.2-1.38 0-2.5-1.12-2.5-2.5zm6.88 1.3c.44-.72 1.22-1.2 2.12-1.2 1.38 0 2.5 1.12 2.5 2.5s-1.12 2.5-2.5 2.5c-.9 0-1.68-.48-2.12-1.2L12.5 10.6c.3.24.68.4 1.1.4.83 0 1.5-.67 1.5-1.5S14.43 8 13.6 8c-.42 0-.8.16-1.1.4l-1.12 1.3zM7 9.5c-.42 0-.8-.16-1.1-.4L4.78 7.8c-.44.72-1.22 1.2-2.12 1.2C1.28 9 .17 7.88.17 6.5S1.29 4 2.67 4c.9 0 1.68.48 2.12 1.2L5.9 6.5c-.3-.24-.68-.4-1.1-.4C3.97 6.1 3.3 6.77 3.3 7.6s.67 1.5 1.5 1.5c.42 0 .8-.16 1.1-.4l1.12-1.3L8 8l-1 1.5z" })) : (
-                        // 채팅 아이콘 (Chat 모드)
-                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M8 1C3.58 1 0 4.13 0 8c0 1.5.5 2.88 1.34 4.04L.5 15l3.37-.92A8.56 8.56 0 008 15c4.42 0 8-3.13 8-7s-3.58-7-8-7zM4.5 9a1 1 0 110-2 1 1 0 010 2zm3.5 0a1 1 0 110-2 1 1 0 010 2zm3.5 0a1 1 0 110-2 1 1 0 010 2z" }))),
-                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-mode-label" }, inputMode === 'agent' ? 'Agent' : 'Chat'),
+                        // 뇌 아이콘 (Agent V2 모드)
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M8 0a8 8 0 100 16A8 8 0 008 0zm.5 11.5h-1v-1h1v1zm1.7-4.3c-.4.5-.7.8-.7 1.3v.5h-1v-.5c0-.8.4-1.3.8-1.8.4-.4.7-.7.7-1.2 0-.6-.4-1-1-1-.5 0-.9.3-1 .8l-1-.2c.2-.9 1-1.6 2-1.6 1.1 0 2 .8 2 1.9 0 .8-.4 1.3-.8 1.8z" }))),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-mode-label" }, inputMode === 'chat' ? 'Chat' : inputMode === 'agent' ? 'Agent' : 'Agent V2'),
                         react__WEBPACK_IMPORTED_MODULE_0___default().createElement("svg", { className: "jp-agent-mode-chevron", viewBox: "0 0 16 16", fill: "currentColor", width: "12", height: "12" },
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M4.47 5.47a.75.75 0 011.06 0L8 7.94l2.47-2.47a.75.75 0 111.06 1.06l-3 3a.75.75 0 01-1.06 0l-3-3a.75.75 0 010-1.06z" }))),
                     showModeDropdown && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-mode-dropdown" },
@@ -2335,7 +3484,12 @@ SyntaxError: '(' was never closed
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("svg", { viewBox: "0 0 16 16", fill: "currentColor", width: "14", height: "14" },
                                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M4.5 8c0-1.38 1.12-2.5 2.5-2.5.9 0 1.68.48 2.12 1.2L8 8l1.12 1.3c-.44.72-1.22 1.2-2.12 1.2-1.38 0-2.5-1.12-2.5-2.5z" })),
                             react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", null, "Agent"),
-                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-mode-shortcut" }, "\uB178\uD2B8\uBD81 \uC790\uB3D9 \uC2E4\uD589"))))),
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-mode-shortcut" }, "\uB178\uD2B8\uBD81 \uC790\uB3D9 \uC2E4\uD589")),
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("button", { className: `jp-agent-mode-option ${inputMode === 'agent_v2' ? 'jp-agent-mode-option--selected' : ''}`, onClick: () => { setInputMode('agent_v2'); setShowModeDropdown(false); } },
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("svg", { viewBox: "0 0 16 16", fill: "currentColor", width: "14", height: "14" },
+                                react__WEBPACK_IMPORTED_MODULE_0___default().createElement("path", { d: "M8 0a8 8 0 100 16A8 8 0 008 0zm.5 11.5h-1v-1h1v1zm1.7-4.3c-.4.5-.7.8-.7 1.3v.5h-1v-.5c0-.8.4-1.3.8-1.8.4-.4.7-.7.7-1.2 0-.6-.4-1-1-1-.5 0-.9.3-1 .8l-1-.2c.2-.9 1-1.6 2-1.6 1.1 0 2 .8 2 1.9 0 .8-.4 1.3-.8 1.8z" })),
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", null, "Agent V2"),
+                            react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-mode-shortcut" }, "Deep Agent (HITL)"))))),
                 react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", { className: "jp-agent-mode-hints" },
                     react__WEBPACK_IMPORTED_MODULE_0___default().createElement("span", { className: "jp-agent-mode-hint" }, "\u21E7Tab \uBAA8\uB4DC \uC804\uD658")))),
         fileSelectionMetadata && (react__WEBPACK_IMPORTED_MODULE_0___default().createElement(_FileSelectionDialog__WEBPACK_IMPORTED_MODULE_8__.FileSelectionDialog, { filename: fileSelectionMetadata.pattern, options: fileSelectionMetadata.options, message: fileSelectionMetadata.message, onSelect: handleFileSelect, onCancel: handleFileSelectCancel }))));
@@ -2830,6 +3984,9 @@ 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));
+    const [idleTimeoutMinutes, setIdleTimeoutMinutes] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(initConfig.idleTimeoutMinutes ?? 60);
     // Update state when currentConfig changes
     (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
         if (currentConfig) {
@@ -2851,6 +4008,9 @@ 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));
+            setIdleTimeoutMinutes(currentConfig.idleTimeoutMinutes ?? 60);
         }
     }, [currentConfig]);
     // Helper: Build LLM config from state
@@ -2870,7 +4030,10 @@ 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,
+        idleTimeoutMinutes
     });
     // Handlers for multiple API keys
     const handleAddKey = () => {
@@ -2964,6 +4127,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 +4196,16 @@ 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", htmlFor: "jp-agent-idle-timeout" },
+                        "Idle Timeout (\uBD84)",
+                        react__WEBPACK_IMPORTED_MODULE_0___default().createElement("small", { style: { fontWeight: 'normal', marginLeft: '8px', color: '#666' } }, "\uBE44\uD65C\uB3D9 \uC2DC \uC790\uB3D9 \uC885\uB8CC (0 = \uBE44\uD65C\uC131\uD654)")),
+                    react__WEBPACK_IMPORTED_MODULE_0___default().createElement("input", { id: "jp-agent-idle-timeout", type: "number", className: "jp-agent-settings-input", value: idleTimeoutMinutes, onChange: (e) => setIdleTimeoutMinutes(Math.max(0, parseInt(e.target.value) || 0)), min: 0, max: 1440, placeholder: "60", style: { width: '120px' }, "data-testid": "idle-timeout-input" })),
                 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)",
@@ -3183,6 +4361,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _plugins_cell_buttons_plugin__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./plugins/cell-buttons-plugin */ "./lib/plugins/cell-buttons-plugin.js");
 /* harmony import */ var _plugins_prompt_generation_plugin__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./plugins/prompt-generation-plugin */ "./lib/plugins/prompt-generation-plugin.js");
 /* harmony import */ var _plugins_save_interceptor_plugin__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./plugins/save-interceptor-plugin */ "./lib/plugins/save-interceptor-plugin.js");
+/* harmony import */ var _plugins_idle_monitor_plugin__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./plugins/idle-monitor-plugin */ "./lib/plugins/idle-monitor-plugin.js");
+/* harmony import */ var _plugins_lsp_bridge_plugin__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./plugins/lsp-bridge-plugin */ "./lib/plugins/lsp-bridge-plugin.js");
 /**
  * Jupyter Agent Extension Entry Point
  */
@@ -3191,6 +4371,8 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
 // Import styles
 // import '../style/index.css';
 /**
@@ -3202,7 +4384,9 @@ const plugins = [
     _plugins_sidebar_plugin__WEBPACK_IMPORTED_MODULE_0__.sidebarPlugin,
     _plugins_cell_buttons_plugin__WEBPACK_IMPORTED_MODULE_1__.cellButtonsPlugin,
     _plugins_prompt_generation_plugin__WEBPACK_IMPORTED_MODULE_2__.promptGenerationPlugin,
-    _plugins_save_interceptor_plugin__WEBPACK_IMPORTED_MODULE_3__.saveInterceptorPlugin
+    _plugins_save_interceptor_plugin__WEBPACK_IMPORTED_MODULE_3__.saveInterceptorPlugin,
+    _plugins_idle_monitor_plugin__WEBPACK_IMPORTED_MODULE_4__.idleMonitorPlugin,
+    _plugins_lsp_bridge_plugin__WEBPACK_IMPORTED_MODULE_5__.lspBridgePlugin
 ];
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (plugins);
 
@@ -4002,60 +5186,1020 @@ function showCustomPromptDialog(cell) {
             showNotification('질문 내용을 입력해주세요.', 'warning');
             return;
         }
-        dialogOverlay.remove();
-        // Get cell output
-        const cellOutput = getCellOutput(cell);
-        // Create display prompt: "Cell x: Custom request"
-        const displayPrompt = `${cellIndex}번째 셀: ${promptText}`;
-        // Create LLM prompt with code and output
-        let llmPrompt = `${promptText}\n\n셀 내용:\n\`\`\`\n${cellContent}\n\`\`\``;
-        if (cellOutput) {
-            llmPrompt += `\n\n실행 결과:\n\`\`\`\n${cellOutput}\n\`\`\``;
+        dialogOverlay.remove();
+        // Get cell output
+        const cellOutput = getCellOutput(cell);
+        // Create display prompt: "Cell x: Custom request"
+        const displayPrompt = `${cellIndex}번째 셀: ${promptText}`;
+        // Create LLM prompt with code and output
+        let llmPrompt = `${promptText}\n\n셀 내용:\n\`\`\`\n${cellContent}\n\`\`\``;
+        if (cellOutput) {
+            llmPrompt += `\n\n실행 결과:\n\`\`\`\n${cellOutput}\n\`\`\``;
+        }
+        const agentPanel = window._hdspAgentPanel;
+        if (agentPanel) {
+            // Activate the sidebar panel
+            const app = window.jupyterapp;
+            if (app) {
+                app.shell.activateById(agentPanel.id);
+            }
+            // Send both prompts with cell ID and cell index
+            if (agentPanel.addCellActionMessage) {
+                // cellIndex is 1-based (for display), convert to 0-based for array access
+                const cellIndexZeroBased = cellIndex - 1;
+                agentPanel.addCellActionMessage(_types__WEBPACK_IMPORTED_MODULE_1__.CellAction.CUSTOM_PROMPT, cellContent, displayPrompt, llmPrompt, cellId, cellIndexZeroBased);
+            }
+        }
+    };
+    submitBtn.addEventListener('click', handleSubmit);
+    submitBtn.addEventListener('mouseenter', () => {
+        submitBtn.style.background = 'rgba(25, 118, 210, 0.1)';
+    });
+    submitBtn.addEventListener('mouseleave', () => {
+        submitBtn.style.background = 'transparent';
+    });
+    // Enter 키로 제출 (Shift+Enter는 줄바꿈)
+    inputField?.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter' && !e.shiftKey) {
+            e.preventDefault();
+            handleSubmit();
+        }
+    });
+    // 오버레이 클릭 시 다이얼로그 닫기
+    dialogOverlay.addEventListener('click', (e) => {
+        if (e.target === dialogOverlay) {
+            dialogOverlay.remove();
+        }
+    });
+    // ESC 키로 다이얼로그 닫기
+    const handleEscapeKey = (e) => {
+        if (e.key === 'Escape') {
+            dialogOverlay.remove();
+            document.removeEventListener('keydown', handleEscapeKey);
+        }
+    };
+    document.addEventListener('keydown', handleEscapeKey);
+}
+
+
+/***/ },
+
+/***/ "./lib/plugins/idle-monitor-plugin.js"
+/*!********************************************!*\
+  !*** ./lib/plugins/idle-monitor-plugin.js ***!
+  \********************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   getIdleMonitor: () => (/* binding */ getIdleMonitor),
+/* harmony export */   idleMonitorPlugin: () => (/* binding */ idleMonitorPlugin)
+/* harmony export */ });
+/* harmony import */ var _jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyterlab/notebook */ "webpack/sharing/consume/default/@jupyterlab/notebook");
+/* harmony import */ var _jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _jupyterlab_terminal__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @jupyterlab/terminal */ "webpack/sharing/consume/default/@jupyterlab/terminal");
+/* harmony import */ var _jupyterlab_terminal__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_terminal__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _jupyterlab_coreutils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @jupyterlab/coreutils */ "webpack/sharing/consume/default/@jupyterlab/coreutils");
+/* harmony import */ var _jupyterlab_coreutils__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_coreutils__WEBPACK_IMPORTED_MODULE_2__);
+/**
+ * Idle Monitor Plugin
+ *
+ * Monitors user activity and triggers shutdown after idle timeout.
+ * Activity is tracked by:
+ * - Keyboard events
+ * - Mouse events
+ * - Notebook cell execution (kernel busy status)
+ * - Terminal output
+ */
+
+
+
+/**
+ * Plugin namespace
+ */
+const PLUGIN_ID = '@hdsp-agent/idle-monitor';
+const CONFIG_STORAGE_KEY = 'hdsp-agent-llm-config';
+/**
+ * Default idle timeout (in minutes)
+ */
+const DEFAULT_IDLE_TIMEOUT_MINUTES = 60;
+// Check intervals - must be shorter than warning period to detect it
+const CHECK_INTERVAL_NORMAL_MS = 10 * 1000; // Check every 10 seconds (normal mode)
+const CHECK_INTERVAL_WARNING_MS = 1000; // Check every second (warning mode for countdown)
+// Warning period: show countdown before timeout (minimum 30 seconds, or 25% of timeout)
+const MIN_WARNING_PERIOD_MS = 30 * 1000; // Minimum 30 seconds warning
+/**
+ * Idle Monitor Service
+ */
+class IdleMonitorService {
+    constructor() {
+        this.checkIntervalId = null;
+        this.countdownElement = null;
+        this.isShuttingDown = false;
+        this.notebookTracker = null;
+        this.terminalTracker = null;
+        this.isInWarningMode = false;
+        this.isDisabled = false;
+        /**
+         * Throttle mousemove events to reduce performance impact
+         */
+        this.mouseMoveThrottleTime = 0;
+        this.lastActivityTime = Date.now();
+        // Initialize timeout from localStorage config
+        this.idleTimeoutMinutes = this.loadTimeoutFromConfig();
+        this.isDisabled = this.idleTimeoutMinutes === 0;
+        this.idleTimeoutMs = this.idleTimeoutMinutes * 60 * 1000;
+        // Warning period: 25% of timeout or minimum 30 seconds
+        const warningPeriod = Math.max(MIN_WARNING_PERIOD_MS, this.idleTimeoutMs * 0.25);
+        this.warningStartMs = this.idleTimeoutMs - warningPeriod;
+        this.setupActivityListeners();
+        this.setupStorageListener();
+        this.createCountdownElement();
+        if (!this.isDisabled) {
+            this.startIdleCheck();
+        }
+        console.log('[IdleMonitor] Service initialized. Idle timeout:', this.idleTimeoutMinutes, 'minutes, warning at:', Math.round(this.warningStartMs / 1000), 'sec', this.isDisabled ? '(DISABLED)' : '');
+    }
+    /**
+     * Load timeout configuration from localStorage
+     */
+    loadTimeoutFromConfig() {
+        try {
+            const stored = localStorage.getItem(CONFIG_STORAGE_KEY);
+            if (stored) {
+                const config = JSON.parse(stored);
+                if (typeof config.idleTimeoutMinutes === 'number') {
+                    return config.idleTimeoutMinutes;
+                }
+            }
+        }
+        catch (e) {
+            console.warn('[IdleMonitor] Failed to load config from localStorage:', e);
+        }
+        return DEFAULT_IDLE_TIMEOUT_MINUTES;
+    }
+    /**
+     * Setup listener for localStorage changes (config updates from settings panel)
+     */
+    setupStorageListener() {
+        window.addEventListener('storage', (e) => {
+            if (e.key === CONFIG_STORAGE_KEY) {
+                const newTimeout = this.loadTimeoutFromConfig();
+                if (newTimeout !== this.idleTimeoutMinutes) {
+                    this.updateTimeout(newTimeout);
+                }
+            }
+        });
+        // Also listen for custom event (same-tab config changes)
+        window.addEventListener('hdsp-config-updated', () => {
+            const newTimeout = this.loadTimeoutFromConfig();
+            if (newTimeout !== this.idleTimeoutMinutes) {
+                this.updateTimeout(newTimeout);
+            }
+        });
+    }
+    /**
+     * Update timeout dynamically
+     */
+    updateTimeout(minutes) {
+        const wasDisabled = this.isDisabled;
+        this.idleTimeoutMinutes = minutes;
+        this.isDisabled = minutes === 0;
+        this.idleTimeoutMs = minutes * 60 * 1000;
+        // Warning period: 25% of timeout or minimum 30 seconds
+        const warningPeriod = Math.max(MIN_WARNING_PERIOD_MS, this.idleTimeoutMs * 0.25);
+        this.warningStartMs = this.idleTimeoutMs - warningPeriod;
+        console.log('[IdleMonitor] Timeout updated to:', minutes, 'minutes', this.isDisabled ? '(DISABLED)' : '');
+        // Stop idle check if disabled
+        if (this.isDisabled) {
+            this.stopIdleCheck();
+            this.hideCountdown();
+        }
+        else if (wasDisabled) {
+            // Re-enable if was disabled
+            this.resetIdleTimer();
+            this.startIdleCheck();
+        }
+    }
+    /**
+     * Stop idle check interval
+     */
+    stopIdleCheck() {
+        if (this.checkIntervalId !== null) {
+            clearInterval(this.checkIntervalId);
+            this.checkIntervalId = null;
+        }
+        this.isInWarningMode = false;
+        console.log('[IdleMonitor] Idle check stopped');
+    }
+    /**
+     * Set notebook tracker for monitoring cell execution
+     */
+    setNotebookTracker(tracker) {
+        this.notebookTracker = tracker;
+        // Monitor cell execution changes
+        tracker.currentChanged.connect(() => {
+            this.resetIdleTimer();
+        });
+        // Monitor active cell changes
+        tracker.activeCellChanged.connect(() => {
+            this.resetIdleTimer();
+        });
+        console.log('[IdleMonitor] Notebook tracker connected');
+    }
+    /**
+     * Set terminal tracker for monitoring terminal activity
+     */
+    setTerminalTracker(tracker) {
+        this.terminalTracker = tracker;
+        // Monitor terminal changes
+        tracker.currentChanged.connect(() => {
+            this.resetIdleTimer();
+        });
+        // Setup monitoring for existing terminals
+        tracker.forEach(terminal => {
+            this.setupTerminalMonitoring(terminal);
+        });
+        // Monitor new terminals
+        tracker.widgetAdded.connect((_, terminal) => {
+            this.setupTerminalMonitoring(terminal);
+        });
+        console.log('[IdleMonitor] Terminal tracker connected');
+    }
+    /**
+     * Setup monitoring for a single terminal
+     * Simply reset idle timer on any terminal output
+     */
+    setupTerminalMonitoring(terminal) {
+        const terminalId = terminal.id || terminal.session?.name || 'unknown';
+        const session = terminal.session;
+        if (!session)
+            return;
+        // Listen for terminal output - any output resets idle timer
+        session.messageReceived.connect(() => {
+            this.resetIdleTimer();
+        });
+        console.log('[IdleMonitor] Terminal monitoring setup:', terminalId);
+    }
+    /**
+     * Setup global activity listeners
+     */
+    setupActivityListeners() {
+        // Keyboard events
+        document.addEventListener('keydown', this.handleActivity.bind(this), true);
+        document.addEventListener('keyup', this.handleActivity.bind(this), true);
+        document.addEventListener('keypress', this.handleActivity.bind(this), true);
+        // Mouse events
+        document.addEventListener('mousedown', this.handleActivity.bind(this), true);
+        document.addEventListener('mouseup', this.handleActivity.bind(this), true);
+        document.addEventListener('mousemove', this.throttledMouseMove.bind(this), true);
+        document.addEventListener('wheel', this.handleActivity.bind(this), true);
+        document.addEventListener('click', this.handleActivity.bind(this), true);
+        // Touch events (for tablet support)
+        document.addEventListener('touchstart', this.handleActivity.bind(this), true);
+        document.addEventListener('touchend', this.handleActivity.bind(this), true);
+        console.log('[IdleMonitor] Activity listeners attached');
+    }
+    throttledMouseMove() {
+        const now = Date.now();
+        if (now - this.mouseMoveThrottleTime > 5000) { // Only update every 5 seconds for mouse move
+            this.mouseMoveThrottleTime = now;
+            this.handleActivity();
+        }
+    }
+    /**
+     * Handle any user activity
+     */
+    handleActivity() {
+        this.resetIdleTimer();
+    }
+    /**
+     * Reset the idle timer
+     */
+    resetIdleTimer() {
+        this.lastActivityTime = Date.now();
+        this.isShuttingDown = false;
+        this.hideCountdown();
+        // Switch back to normal mode if in warning mode
+        this.switchToNormalMode();
+    }
+    /**
+     * Create countdown display element (fixed position, top-right)
+     */
+    createCountdownElement() {
+        // Create countdown container with fixed positioning
+        this.countdownElement = document.createElement('div');
+        this.countdownElement.id = 'hdsp-idle-countdown';
+        this.countdownElement.className = 'hdsp-idle-countdown';
+        this.countdownElement.style.cssText = `
+      display: none;
+      position: fixed;
+      right: 20px;
+      top: 10px;
+      background: linear-gradient(135deg, #ff6b6b 0%, #ee5a5a 100%);
+      color: white;
+      padding: 8px 16px;
+      border-radius: 20px;
+      font-size: 14px;
+      font-weight: 600;
+      box-shadow: 0 4px 12px rgba(238, 90, 90, 0.5);
+      z-index: 99999;
+      white-space: nowrap;
+      cursor: pointer;
+      user-select: none;
+    `;
+        // Click to dismiss and reset timer
+        this.countdownElement.addEventListener('click', () => {
+            this.resetIdleTimer();
+            console.log('[IdleMonitor] User clicked countdown - timer reset');
+        });
+        // Add pulse animation
+        const style = document.createElement('style');
+        style.id = 'hdsp-idle-countdown-style';
+        style.textContent = `
+      @keyframes hdsp-pulse {
+        0% { transform: scale(1); }
+        50% { transform: scale(1.03); }
+        100% { transform: scale(1); }
+      }
+
+      .hdsp-idle-countdown {
+        animation: hdsp-pulse 2s infinite;
+      }
+
+      .hdsp-idle-countdown.warning {
+        background: linear-gradient(135deg, #ffa726 0%, #fb8c00 100%) !important;
+        box-shadow: 0 4px 12px rgba(251, 140, 0, 0.5) !important;
+      }
+
+      .hdsp-idle-countdown.critical {
+        background: linear-gradient(135deg, #ef5350 0%, #d32f2f 100%) !important;
+        box-shadow: 0 4px 12px rgba(211, 47, 47, 0.6) !important;
+        animation: hdsp-pulse-critical 0.5s infinite !important;
+      }
+
+      @keyframes hdsp-pulse-critical {
+        0% { transform: scale(1); opacity: 1; }
+        50% { transform: scale(1.05); opacity: 0.9; }
+        100% { transform: scale(1); opacity: 1; }
+      }
+    `;
+        // Remove existing style if any
+        const existingStyle = document.getElementById('hdsp-idle-countdown-style');
+        if (existingStyle) {
+            existingStyle.remove();
+        }
+        document.head.appendChild(style);
+        // Append to body for fixed positioning
+        document.body.appendChild(this.countdownElement);
+        console.log('[IdleMonitor] Countdown element created (fixed position)');
+    }
+    /**
+     * Show countdown in toolbar
+     */
+    showCountdown(secondsRemaining) {
+        console.log(`[IdleMonitor] showCountdown called: ${secondsRemaining}s remaining`);
+        if (!this.countdownElement) {
+            this.createCountdownElement();
+            return;
+        }
+        this.countdownElement.style.display = 'block';
+        this.countdownElement.textContent = `Idle Shutdown ${secondsRemaining}초 전`;
+        // Update styling based on urgency
+        this.countdownElement.classList.remove('warning', 'critical');
+        if (secondsRemaining <= 10) {
+            this.countdownElement.classList.add('critical');
+        }
+        else if (secondsRemaining <= 30) {
+            this.countdownElement.classList.add('warning');
+        }
+    }
+    /**
+     * Hide countdown display
+     */
+    hideCountdown() {
+        if (this.countdownElement) {
+            this.countdownElement.style.display = 'none';
+        }
+    }
+    /**
+     * Check if any notebook cells are currently executing
+     * Uses kernel status for reliability
+     */
+    hasRunningCells() {
+        if (!this.notebookTracker)
+            return false;
+        // Check all open notebooks via kernel status
+        const notebooks = this.notebookTracker.filter(() => true);
+        for (const notebook of notebooks) {
+            const session = notebook.sessionContext?.session;
+            if (session) {
+                const kernelStatus = session.kernel?.status;
+                // Kernel is busy = cells are executing
+                if (kernelStatus === 'busy') {
+                    return true;
+                }
+            }
+            // Fallback: also check DOM for [*] indicator (for edge cases)
+            if (notebook.content) {
+                const cells = notebook.content.widgets;
+                for (const cell of cells) {
+                    const model = cell.model;
+                    if (model && model.type === 'code') {
+                        const promptNode = cell.node.querySelector('.jp-InputPrompt');
+                        if (promptNode && promptNode.textContent?.includes('*')) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Start idle checking interval
+     * Starts in normal mode (10 min), switches to warning mode (1 sec) when needed
+     */
+    startIdleCheck() {
+        this.checkIntervalId = window.setInterval(() => {
+            this.checkIdleStatus();
+        }, CHECK_INTERVAL_NORMAL_MS);
+        console.log('[IdleMonitor] Started in normal mode: check every 10 seconds');
+    }
+    /**
+     * Switch to warning mode (faster checks for countdown)
+     */
+    switchToWarningMode() {
+        if (this.isInWarningMode)
+            return;
+        this.isInWarningMode = true;
+        // Clear normal interval
+        if (this.checkIntervalId !== null) {
+            clearInterval(this.checkIntervalId);
+        }
+        // Start warning interval (1 second)
+        this.checkIntervalId = window.setInterval(() => {
+            this.checkIdleStatus();
+        }, CHECK_INTERVAL_WARNING_MS);
+        console.log('[IdleMonitor] Switched to warning mode: check every', CHECK_INTERVAL_WARNING_MS / 1000, 'seconds');
+    }
+    /**
+     * Switch back to normal mode
+     */
+    switchToNormalMode() {
+        if (!this.isInWarningMode)
+            return;
+        this.isInWarningMode = false;
+        // Clear warning interval
+        if (this.checkIntervalId !== null) {
+            clearInterval(this.checkIntervalId);
+        }
+        // Start normal interval (10 minutes)
+        this.checkIntervalId = window.setInterval(() => {
+            this.checkIdleStatus();
+        }, CHECK_INTERVAL_NORMAL_MS);
+        console.log('[IdleMonitor] Switched to normal mode: check every 10 seconds');
+    }
+    /**
+     * Check current idle status
+     */
+    checkIdleStatus() {
+        // Skip if disabled
+        if (this.isDisabled) {
+            return;
+        }
+        // Skip if notebook cells are running (not idle)
+        if (this.hasRunningCells()) {
+            this.resetIdleTimer();
+            return;
+        }
+        const now = Date.now();
+        const idleTime = now - this.lastActivityTime;
+        const remainingTime = this.idleTimeoutMs - idleTime;
+        const secondsRemaining = Math.ceil(remainingTime / 1000);
+        // Debug log every 10 seconds
+        if (Math.floor(idleTime / 1000) % 10 === 0) {
+            console.log(`[IdleMonitor] idle=${Math.round(idleTime / 1000)}s, warningAt=${Math.round(this.warningStartMs / 1000)}s, timeout=${Math.round(this.idleTimeoutMs / 1000)}s, remaining=${secondsRemaining}s`);
+        }
+        // Enter warning period - switch to fast checking for countdown
+        if (idleTime >= this.warningStartMs && !this.isShuttingDown) {
+            this.switchToWarningMode();
+            this.showCountdown(secondsRemaining);
+        }
+        // Trigger shutdown if idle timeout reached
+        if (idleTime >= this.idleTimeoutMs && !this.isShuttingDown) {
+            this.isShuttingDown = true;
+            this.triggerShutdown();
+        }
+    }
+    /**
+     * Trigger shutdown process
+     */
+    async triggerShutdown() {
+        console.log('[IdleMonitor] Idle timeout reached. Triggering shutdown...');
+        // Hide countdown
+        this.hideCountdown();
+        // Show alert popup
+        alert(`${this.idleTimeoutMinutes}분 동안 활동이 없어 세션이 종료됩니다.`);
+        // Call shutdown API
+        await this.callShutdownApi();
+    }
+    /**
+     * Call HDSP shutdown API via Jupyter server endpoint
+     * Server-side call to avoid CORS issues
+     */
+    async callShutdownApi() {
+        try {
+            // Get base URL from PageConfig
+            const baseUrl = _jupyterlab_coreutils__WEBPACK_IMPORTED_MODULE_2__.PageConfig.getBaseUrl();
+            const apiUrl = `${baseUrl}hdsp-agent/idle-shutdown`;
+            console.log('[IdleMonitor] Calling shutdown API via server:', apiUrl);
+            // Call server endpoint (which will call HDSP API)
+            const response = await fetch(apiUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            const result = await response.json();
+            if (response.ok && result.success) {
+                console.log('[IdleMonitor] Shutdown API call successful:', result.message);
+            }
+            else {
+                console.error('[IdleMonitor] Shutdown API call failed:', result.error || response.statusText);
+            }
+        }
+        catch (error) {
+            console.error('[IdleMonitor] Shutdown API call error:', error);
+        }
+    }
+    /**
+     * Get current idle time in milliseconds
+     */
+    getIdleTimeMs() {
+        return Date.now() - this.lastActivityTime;
+    }
+    /**
+     * Manually trigger activity (for external use)
+     */
+    triggerActivity() {
+        this.resetIdleTimer();
+    }
+    /**
+     * Cleanup service
+     */
+    dispose() {
+        if (this.checkIntervalId !== null) {
+            clearInterval(this.checkIntervalId);
+            this.checkIntervalId = null;
+        }
+        if (this.countdownElement && this.countdownElement.parentNode) {
+            this.countdownElement.parentNode.removeChild(this.countdownElement);
+        }
+        console.log('[IdleMonitor] Service disposed');
+    }
+}
+/**
+ * Global idle monitor instance
+ */
+let idleMonitor = null;
+/**
+ * Get idle monitor instance
+ */
+function getIdleMonitor() {
+    return idleMonitor;
+}
+/**
+ * Idle Monitor Plugin
+ */
+const idleMonitorPlugin = {
+    id: PLUGIN_ID,
+    autoStart: true,
+    requires: [],
+    optional: [_jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__.INotebookTracker, _jupyterlab_terminal__WEBPACK_IMPORTED_MODULE_1__.ITerminalTracker],
+    activate: (app, notebookTracker, terminalTracker) => {
+        console.log('[IdleMonitorPlugin] Activating Idle Monitor');
+        try {
+            // Create idle monitor service
+            idleMonitor = new IdleMonitorService();
+            // Connect notebook tracker if available
+            if (notebookTracker) {
+                idleMonitor.setNotebookTracker(notebookTracker);
+            }
+            // Connect terminal tracker if available
+            if (terminalTracker) {
+                idleMonitor.setTerminalTracker(terminalTracker);
+            }
+            // Store reference globally for debugging
+            window._hdspIdleMonitor = idleMonitor;
+            console.log('[IdleMonitorPlugin] Idle Monitor activated successfully');
+        }
+        catch (error) {
+            console.error('[IdleMonitorPlugin] Failed to activate:', error);
+        }
+    }
+};
+
+
+/***/ },
+
+/***/ "./lib/plugins/lsp-bridge-plugin.js"
+/*!******************************************!*\
+  !*** ./lib/plugins/lsp-bridge-plugin.js ***!
+  \******************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DiagnosticSeverity: () => (/* binding */ DiagnosticSeverity),
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   getLSPBridge: () => (/* binding */ getLSPBridge),
+/* harmony export */   lspBridgePlugin: () => (/* binding */ lspBridgePlugin)
+/* harmony export */ });
+/* harmony import */ var _jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyterlab/notebook */ "webpack/sharing/consume/default/@jupyterlab/notebook");
+/* harmony import */ var _jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__);
+/**
+ * LSP Bridge Plugin
+ *
+ * jupyterlab-lsp와 HDSP Agent를 연결하는 브릿지
+ * Crush 패턴 적용: Version-based 캐싱, 이벤트 기반 업데이트
+ *
+ * 주요 기능:
+ * - LSP 진단 결과 캐싱 및 조회
+ * - 심볼 참조 검색
+ * - Agent 도구와 연동
+ */
+
+/**
+ * Plugin namespace
+ */
+const PLUGIN_ID = '@hdsp-agent/lsp-bridge';
+/**
+ * LSP Diagnostic severity levels
+ */
+var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 1] = "Error";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Information"] = 3] = "Information";
+    DiagnosticSeverity[DiagnosticSeverity["Hint"] = 4] = "Hint";
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));
+/**
+ * LSP State Cache (Crush의 VersionedMap 패턴)
+ * 버전 기반 캐시 무효화로 불필요한 재계산 방지
+ */
+class LSPStateCache {
+    constructor() {
+        this.diagnosticsVersion = 0;
+        this.diagnosticsCache = new Map();
+        this.summaryCache = null;
+        this.summaryVersion = -1;
+    }
+    /**
+     * Update diagnostics for a file
+     */
+    updateDiagnostics(uri, diagnostics) {
+        this.diagnosticsCache.set(uri, diagnostics);
+        this.diagnosticsVersion++;
+    }
+    /**
+     * Get diagnostics for a specific file or all files
+     */
+    getDiagnostics(uri) {
+        if (uri) {
+            return {
+                version: this.diagnosticsVersion,
+                diagnostics: this.diagnosticsCache.get(uri) || []
+            };
+        }
+        return {
+            version: this.diagnosticsVersion,
+            diagnostics: this.diagnosticsCache
+        };
+    }
+    /**
+     * Get diagnostic counts with caching (Crush 패턴)
+     */
+    getDiagnosticSummary() {
+        // Return cached if version matches
+        if (this.summaryVersion === this.diagnosticsVersion && this.summaryCache) {
+            return this.summaryCache;
+        }
+        // Recalculate
+        let errors = 0;
+        let warnings = 0;
+        let hints = 0;
+        for (const diags of this.diagnosticsCache.values()) {
+            for (const d of diags) {
+                switch (d.severity) {
+                    case DiagnosticSeverity.Error:
+                        errors++;
+                        break;
+                    case DiagnosticSeverity.Warning:
+                        warnings++;
+                        break;
+                    default:
+                        hints++;
+                }
+            }
+        }
+        this.summaryCache = {
+            errors,
+            warnings,
+            hints,
+            total: errors + warnings + hints,
+            version: this.diagnosticsVersion
+        };
+        this.summaryVersion = this.diagnosticsVersion;
+        return this.summaryCache;
+    }
+    /**
+     * Clear diagnostics for a file
+     */
+    clearDiagnostics(uri) {
+        if (this.diagnosticsCache.has(uri)) {
+            this.diagnosticsCache.delete(uri);
+            this.diagnosticsVersion++;
+        }
+    }
+    /**
+     * Clear all diagnostics
+     */
+    clearAll() {
+        this.diagnosticsCache.clear();
+        this.diagnosticsVersion++;
+    }
+    /**
+     * Get current version
+     */
+    getVersion() {
+        return this.diagnosticsVersion;
+    }
+}
+/**
+ * LSP Bridge Service
+ * Agent 도구에서 LSP 기능을 사용할 수 있게 해주는 서비스
+ */
+class LSPBridgeService {
+    constructor() {
+        this.cache = new LSPStateCache();
+        this.lspAvailable = false;
+        this.notebookTracker = null;
+        this.checkLSPAvailability();
+    }
+    /**
+     * Check if jupyterlab-lsp is available
+     */
+    async checkLSPAvailability() {
+        try {
+            // jupyterlab-lsp가 설치되어 있는지 확인
+            // 실제로는 ILSPDocumentConnectionManager 토큰을 통해 확인
+            this.lspAvailable = false; // 기본값, 실제 연결 시 true로 변경
+            console.log('[LSPBridge] LSP availability check - will be updated when connection established');
+        }
+        catch (error) {
+            console.warn('[LSPBridge] LSP not available:', error);
+            this.lspAvailable = false;
         }
-        const agentPanel = window._hdspAgentPanel;
-        if (agentPanel) {
-            // Activate the sidebar panel
-            const app = window.jupyterapp;
-            if (app) {
-                app.shell.activateById(agentPanel.id);
+    }
+    /**
+     * Set notebook tracker for document access
+     */
+    setNotebookTracker(tracker) {
+        this.notebookTracker = tracker;
+    }
+    /**
+     * Mark LSP as available (called when connection is established)
+     */
+    setLSPAvailable(available) {
+        this.lspAvailable = available;
+        console.log('[LSPBridge] LSP available:', available);
+    }
+    /**
+     * Check if LSP is available
+     */
+    isLSPAvailable() {
+        return this.lspAvailable;
+    }
+    /**
+     * Update diagnostics from external source (e.g., jupyterlab-lsp)
+     */
+    updateDiagnostics(uri, diagnostics) {
+        this.cache.updateDiagnostics(uri, diagnostics);
+        this.notifyDiagnosticsChanged(uri);
+    }
+    /**
+     * Get diagnostics for Agent tool
+     * Returns formatted diagnostics for a file or entire project
+     */
+    async getDiagnostics(filePath) {
+        const result = this.cache.getDiagnostics(filePath ? this.pathToUri(filePath) : undefined);
+        const summary = this.cache.getDiagnosticSummary();
+        const formattedDiagnostics = [];
+        if (filePath) {
+            // Single file
+            const diags = result.diagnostics;
+            for (const d of diags) {
+                formattedDiagnostics.push({
+                    severity: this.severityToString(d.severity),
+                    line: d.range.start.line + 1,
+                    character: d.range.start.character,
+                    message: d.message,
+                    source: d.source,
+                    code: d.code,
+                    file: filePath
+                });
             }
-            // Send both prompts with cell ID and cell index
-            if (agentPanel.addCellActionMessage) {
-                // cellIndex is 1-based (for display), convert to 0-based for array access
-                const cellIndexZeroBased = cellIndex - 1;
-                agentPanel.addCellActionMessage(_types__WEBPACK_IMPORTED_MODULE_1__.CellAction.CUSTOM_PROMPT, cellContent, displayPrompt, llmPrompt, cellId, cellIndexZeroBased);
+        }
+        else {
+            // All files
+            const diagsMap = result.diagnostics;
+            for (const [uri, diags] of diagsMap) {
+                const file = this.uriToPath(uri);
+                for (const d of diags) {
+                    formattedDiagnostics.push({
+                        severity: this.severityToString(d.severity),
+                        line: d.range.start.line + 1,
+                        character: d.range.start.character,
+                        message: d.message,
+                        source: d.source,
+                        code: d.code,
+                        file
+                    });
+                }
             }
         }
-    };
-    submitBtn.addEventListener('click', handleSubmit);
-    submitBtn.addEventListener('mouseenter', () => {
-        submitBtn.style.background = 'rgba(25, 118, 210, 0.1)';
-    });
-    submitBtn.addEventListener('mouseleave', () => {
-        submitBtn.style.background = 'transparent';
-    });
-    // Enter 키로 제출 (Shift+Enter는 줄바꿈)
-    inputField?.addEventListener('keydown', (e) => {
-        if (e.key === 'Enter' && !e.shiftKey) {
-            e.preventDefault();
-            handleSubmit();
+        // Sort: errors first, then by file and line (Crush 패턴)
+        formattedDiagnostics.sort((a, b) => {
+            const severityOrder = { error: 0, warning: 1, information: 2, hint: 3 };
+            const severityDiff = (severityOrder[a.severity] || 3) - (severityOrder[b.severity] || 3);
+            if (severityDiff !== 0)
+                return severityDiff;
+            const fileDiff = a.file.localeCompare(b.file);
+            if (fileDiff !== 0)
+                return fileDiff;
+            return a.line - b.line;
+        });
+        return {
+            success: true,
+            diagnostics: formattedDiagnostics,
+            summary
+        };
+    }
+    /**
+     * Find references for a symbol (Crush의 Grep-then-LSP 패턴)
+     * 현재는 grep 기반으로 구현, LSP 연결 시 향상 가능
+     */
+    async getReferences(symbol, filePath, line, character) {
+        // LSP가 없으면 grep 기반으로 검색하도록 안내
+        if (!this.lspAvailable) {
+            return {
+                success: false,
+                locations: []
+            };
         }
-    });
-    // 오버레이 클릭 시 다이얼로그 닫기
-    dialogOverlay.addEventListener('click', (e) => {
-        if (e.target === dialogOverlay) {
-            dialogOverlay.remove();
+        // TODO: jupyterlab-lsp 연결 시 구현
+        // 현재는 빈 결과 반환 (Agent가 search_workspace_tool 사용하도록)
+        return {
+            success: false,
+            locations: []
+        };
+    }
+    /**
+     * Get diagnostic summary
+     */
+    getDiagnosticSummary() {
+        return this.cache.getDiagnosticSummary();
+    }
+    /**
+     * Notify diagnostics changed event
+     */
+    notifyDiagnosticsChanged(uri) {
+        const summary = this.cache.getDiagnosticSummary();
+        window.dispatchEvent(new CustomEvent('hdsp-lsp-diagnostics-changed', {
+            detail: { uri, summary }
+        }));
+    }
+    /**
+     * Convert severity number to string
+     */
+    severityToString(severity) {
+        switch (severity) {
+            case DiagnosticSeverity.Error:
+                return 'error';
+            case DiagnosticSeverity.Warning:
+                return 'warning';
+            case DiagnosticSeverity.Information:
+                return 'information';
+            case DiagnosticSeverity.Hint:
+                return 'hint';
+            default:
+                return 'hint';
         }
-    });
-    // ESC 키로 다이얼로그 닫기
-    const handleEscapeKey = (e) => {
-        if (e.key === 'Escape') {
-            dialogOverlay.remove();
-            document.removeEventListener('keydown', handleEscapeKey);
+    }
+    /**
+     * Convert file path to URI
+     */
+    pathToUri(path) {
+        if (path.startsWith('file://')) {
+            return path;
         }
-    };
-    document.addEventListener('keydown', handleEscapeKey);
+        return `file://${path.startsWith('/') ? '' : '/'}${path}`;
+    }
+    /**
+     * Convert URI to file path
+     */
+    uriToPath(uri) {
+        if (uri.startsWith('file://')) {
+            return uri.replace('file://', '');
+        }
+        return uri;
+    }
+    /**
+     * Dispose service
+     */
+    dispose() {
+        this.cache.clearAll();
+        console.log('[LSPBridge] Service disposed');
+    }
+}
+/**
+ * Global LSP Bridge instance
+ */
+let lspBridge = null;
+/**
+ * Get LSP Bridge instance
+ */
+function getLSPBridge() {
+    return lspBridge;
+}
+/**
+ * LSP Bridge Plugin
+ *
+ * jupyterlab-lsp가 설치되어 있으면 연동하고,
+ * 없으면 기본 기능만 제공
+ */
+const lspBridgePlugin = {
+    id: PLUGIN_ID,
+    autoStart: true,
+    requires: [],
+    optional: [_jupyterlab_notebook__WEBPACK_IMPORTED_MODULE_0__.INotebookTracker],
+    activate: (app, notebookTracker) => {
+        console.log('[LSPBridgePlugin] Activating LSP Bridge...');
+        // Create LSP Bridge service
+        lspBridge = new LSPBridgeService();
+        // Connect notebook tracker if available
+        if (notebookTracker) {
+            lspBridge.setNotebookTracker(notebookTracker);
+        }
+        // Store reference globally for debugging and Agent access
+        window._hdspLSPBridge = lspBridge;
+        // Try to connect to jupyterlab-lsp if available
+        // This is done dynamically to avoid hard dependency
+        tryConnectToLSP(app, lspBridge);
+        console.log('[LSPBridgePlugin] LSP Bridge activated');
+    }
+};
+/**
+ * Try to connect to jupyterlab-lsp extension
+ */
+async function tryConnectToLSP(app, bridge) {
+    try {
+        // Check if ILSPDocumentConnectionManager is available
+        // This token is provided by jupyterlab-lsp
+        const lspToken = '@jupyterlab/lsp:ILSPDocumentConnectionManager';
+        // Try to get the LSP manager from the application
+        // Note: This requires jupyterlab-lsp to be installed
+        const hasLSP = app.commands.hasCommand('lsp:show-diagnostics-panel');
+        if (hasLSP) {
+            console.log('[LSPBridgePlugin] jupyterlab-lsp detected');
+            bridge.setLSPAvailable(true);
+            // Listen for LSP diagnostic events
+            // jupyterlab-lsp publishes diagnostics through its own mechanism
+            setupLSPEventListeners(bridge);
+        }
+        else {
+            console.log('[LSPBridgePlugin] jupyterlab-lsp not detected, using fallback mode');
+            bridge.setLSPAvailable(false);
+        }
+    }
+    catch (error) {
+        console.warn('[LSPBridgePlugin] Failed to connect to jupyterlab-lsp:', error);
+        bridge.setLSPAvailable(false);
+    }
+}
+/**
+ * Setup event listeners for LSP events
+ */
+function setupLSPEventListeners(bridge) {
+    // jupyterlab-lsp uses its own event system
+    // We'll listen for changes through polling or direct integration
+    // This is a placeholder for future implementation
+    console.log('[LSPBridgePlugin] LSP event listeners setup (placeholder)');
+    // For now, we can use a simple polling mechanism or
+    // hook into JupyterLab's document change events
 }
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (lspBridgePlugin);
 
 
 /***/ },
@@ -6908,40 +9052,71 @@ __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
+# Core Behavior
+Be concise and direct. Answer in fewer than 4 lines unless the user asks for detail.
+After working on a file, just stop - don't explain what you did unless asked.
+Avoid unnecessary introductions or conclusions.
+
+## Task Management
+Use write_todos for complex multi-step tasks (3+ steps). Mark tasks in_progress before starting, completed immediately after finishing.
+For simple 1-2 step tasks, just do them directly without todos.
 
 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
-
-NEVER end your turn without calling a tool. NEVER produce an empty response.
+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
 
-## 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)
 - Stopping after any tool without calling the next tool
 - Ending without calling final_answer_tool
 - Leaving todos in "in_progress" or "pending" state without continuing
+
+## 📖 File Reading Best Practices
+**CRITICAL**: When exploring codebases or reading files, use pagination to prevent context overflow.
+
+**Pattern for codebase exploration:**
+1. First scan: read_file_tool(path, limit=100) - See file structure and key sections
+2. Targeted read: read_file_tool(path, offset=100, limit=200) - Read specific sections if needed
+3. Full read: Only read without limit when necessary for immediate editing
+
+**When to paginate (use offset/limit):**
+- Reading any file >500 lines
+- Exploring unfamiliar codebases (always start with limit=100)
+- Reading multiple files in sequence
+- Any research or investigation task
+
+**When full read is OK:**
+- Small files (<500 lines)
+- Files you need to edit immediately after reading
+- After confirming file size with first scan
+
+## 🔧 Code Development
+For code generation/refactoring, use LSP tools (diagnostics_tool, references_tool) to check errors and find symbol usages. Use multiedit_file_tool for multiple changes in one file.
 `;
 // ═══════════════════════════════════════════════════════════════════════════
 // Key Rotation State (in-memory, not persisted)
@@ -6975,6 +9150,8 @@ function saveLLMConfig(config) {
     try {
         localStorage.setItem(STORAGE_KEY, JSON.stringify(config));
         console.log('[ApiKeyManager] Config saved to localStorage');
+        // Dispatch custom event for same-tab listeners (e.g., idle monitor)
+        window.dispatchEvent(new CustomEvent('hdsp-config-updated', { detail: config }));
     }
     catch (e) {
         console.error('[ApiKeyManager] Failed to save config:', e);
@@ -7027,7 +9204,8 @@ function getDefaultLLMConfig() {
             endpoint: 'http://localhost:8000',
             model: 'default'
         },
-        systemPrompt: DEFAULT_LANGCHAIN_SYSTEM_PROMPT
+        systemPrompt: DEFAULT_LANGCHAIN_SYSTEM_PROMPT,
+        autoApprove: false
     };
 }
 /**
@@ -7254,6 +9432,8 @@ __webpack_require__.r(__webpack_exports__);
 class ApiService {
     // 생성자에서 baseUrl을 선택적으로 받도록 하되, 없으면 자동으로 계산
     constructor(baseUrl) {
+        this.resourceUsageCache = null;
+        this.resourceUsageCacheMs = 15000;
         if (baseUrl) {
             this.baseUrl = baseUrl;
         }
@@ -7293,6 +9473,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
     // ═══════════════════════════════════════════════════════════════════════════
@@ -7371,37 +9580,134 @@ class ApiService {
                     }
                     throw new Error('모든 API 키가 Rate Limit 상태입니다. 잠시 후 다시 시도해주세요.');
                 }
-                // Not a rate limit error, throw immediately
-                throw error;
+                // Not a rate limit error, throw immediately
+                throw error;
+            }
+        }
+        throw lastError || new Error('Maximum retry attempts exceeded');
+    }
+    /**
+     * Execute cell action (explain, fix, custom)
+     * Uses global rate limit handling with key rotation
+     */
+    async cellAction(request) {
+        console.log('[ApiService] cellAction request:', request);
+        return this.fetchWithKeyRotation(`${this.baseUrl}/cell/action`, request, { defaultErrorMessage: '셀 액션 실패' });
+    }
+    /**
+     * Send chat message (non-streaming)
+     * Uses global rate limit handling with key rotation
+     */
+    async sendMessage(request) {
+        console.log('[ApiService] sendMessage request');
+        return this.fetchWithKeyRotation(`${this.baseUrl}/chat/message`, request, { defaultErrorMessage: '메시지 전송 실패' });
+    }
+    /**
+     * Send chat message with streaming response
+     *
+     * NOTE (Financial Security Compliance):
+     * - API key rotation is handled by frontend (not server)
+     * - Server receives ONLY ONE key per request
+     * - On 429 rate limit, frontend rotates key and retries with next key
+     */
+    /**
+     * 단순 Chat용 스트리밍 - /chat/stream 사용
+     * 원래 main 브랜치의 구현 복원 - LangChain 에이전트 없이 단순 Q&A
+     */
+    async sendChatStream(request, onChunk, onMetadata) {
+        const MAX_RETRIES = 10;
+        let currentConfig = request.llmConfig;
+        let lastError = null;
+        for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+            const requestToSend = currentConfig
+                ? { ...request, llmConfig: (0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.buildSingleKeyConfig)(currentConfig) }
+                : request;
+            try {
+                await this.sendChatStreamInternal(requestToSend, onChunk, onMetadata);
+                (0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.resetKeyRotation)();
+                return;
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                lastError = error instanceof Error ? error : new Error(errorMsg);
+                if ((0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.isRateLimitError)(errorMsg) && request.llmConfig) {
+                    console.log(`[ApiService] Chat rate limit on attempt ${attempt + 1}, trying next key...`);
+                    const rotatedConfig = (0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.handleRateLimitError)(request.llmConfig);
+                    if (rotatedConfig) {
+                        currentConfig = request.llmConfig;
+                        continue;
+                    }
+                    else {
+                        throw new Error('모든 API 키가 Rate Limit 상태입니다. 잠시 후 다시 시도해주세요.');
+                    }
+                }
+                throw error;
+            }
+        }
+        throw lastError || new Error('Maximum retry attempts exceeded');
+    }
+    /**
+     * 단순 Chat 스트리밍 내부 구현 - /chat/stream 엔드포인트 사용
+     */
+    async sendChatStreamInternal(request, onChunk, onMetadata) {
+        const response = await fetch(`${this.baseUrl}/chat/stream`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify(request)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to send chat message: ${error}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body is not readable');
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        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() || '';
+                for (const line of lines) {
+                    if (line.startsWith('data: ')) {
+                        try {
+                            const data = JSON.parse(line.slice(6));
+                            if (data.error) {
+                                throw new Error(data.error);
+                            }
+                            if (data.content) {
+                                onChunk(data.content);
+                            }
+                            if (data.done && data.conversationId && onMetadata) {
+                                onMetadata({ conversationId: data.conversationId });
+                            }
+                        }
+                        catch (e) {
+                            if (!(e instanceof SyntaxError)) {
+                                throw e;
+                            }
+                        }
+                    }
+                }
             }
         }
-        throw lastError || new Error('Maximum retry attempts exceeded');
-    }
-    /**
-     * Execute cell action (explain, fix, custom)
-     * Uses global rate limit handling with key rotation
-     */
-    async cellAction(request) {
-        console.log('[ApiService] cellAction request:', request);
-        return this.fetchWithKeyRotation(`${this.baseUrl}/cell/action`, request, { defaultErrorMessage: '셀 액션 실패' });
-    }
-    /**
-     * Send chat message (non-streaming)
-     * Uses global rate limit handling with key rotation
-     */
-    async sendMessage(request) {
-        console.log('[ApiService] sendMessage request');
-        return this.fetchWithKeyRotation(`${this.baseUrl}/chat/message`, request, { defaultErrorMessage: '메시지 전송 실패' });
+        finally {
+            reader.releaseLock();
+        }
     }
     /**
-     * Send chat message with streaming response
-     *
-     * NOTE (Financial Security Compliance):
-     * - API key rotation is handled by frontend (not server)
-     * - Server receives ONLY ONE key per request
-     * - On 429 rate limit, frontend rotates key and retries with next key
+     * Agent V2용 스트리밍 - /agent/langchain/stream 사용
+     * LangChain Deep Agent (HITL, Todo, 도구 실행 등)
      */
-    async sendMessageStream(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall) {
+    async sendAgentV2Stream(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 +9718,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.sendAgentV2StreamInternal(requestToSend, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall, onComplete, threadId);
                 // Success - reset key rotation state
                 (0,_ApiKeyManager__WEBPACK_IMPORTED_MODULE_0__.resetKeyRotation)();
                 return;
@@ -7459,14 +9765,27 @@ class ApiService {
         };
     }
     /**
-     * Internal streaming implementation (without retry logic)
-     * Uses LangChain agent endpoint for improved middleware support
+     * 기존 sendMessageStream 유지 (하위 호환성)
+     * 내부적으로 sendAgentV2Stream 호출
+     * @deprecated sendChatStream 또는 sendAgentV2Stream을 직접 사용하세요
+     */
+    async sendMessageStream(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall, onComplete, threadId) {
+        return this.sendAgentV2Stream(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall, onComplete, threadId);
+    }
+    /**
+     * Agent V2 스트리밍 내부 구현 - /agent/langchain/stream 사용
+     * (기존 sendMessageStreamInternal에서 이름 변경)
      */
-    async sendMessageStreamInternal(request, onChunk, onMetadata, onDebug, onInterrupt, onTodos, onDebugClear, onToolCall) {
+    async sendAgentV2StreamInternal(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 +9793,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 +9855,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 +9896,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 +9949,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 +9960,7 @@ class ApiService {
                     args,
                     feedback
                 }],
-            llmConfig,
+            llmConfig: requestConfig,
             workspaceRoot: '.'
         };
         const response = await fetch(`${this.baseUrl}/agent/langchain/resume`, {
@@ -7704,7 +10045,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 +10067,220 @@ 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 readFile(path, options) {
+        const response = await fetch(`${this.baseUrl}/read-file`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            credentials: 'include',
+            body: JSON.stringify({
+                path,
+                encoding: options?.encoding || 'utf-8',
+                cwd: options?.cwd
+            })
+        });
+        const payload = await response.json().catch(() => ({}));
+        if (!response.ok) {
+            const errorMessage = payload.error || 'Failed to read file';
+            return { success: false, error: errorMessage };
+        }
+        return payload;
+    }
+    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) {
+            if (response.status === 404) {
+                return {
+                    success: false,
+                    files: [],
+                    dataframes: [],
+                    error: 'Resource check endpoint is not available on this Jupyter server.'
+                };
+            }
+            const errorMessage = payload.error || 'Failed to check resources';
+            throw new Error(errorMessage);
+        }
+        return payload;
+    }
     /**
      * Save configuration
      */
@@ -9238,9 +11795,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 +12177,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 +12599,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 +12628,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 +14439,7 @@ const BUILTIN_TOOL_DEFINITIONS = [
     // 확장 도구 (시스템)
     // ─────────────────────────────────────────────────────────────────────────
     {
-        name: 'execute_command',
+        name: 'execute_command_tool',
         description: '셸 명령 실행 (위험 명령만 승인 필요)',
         riskLevel: 'critical',
         requiresApproval: false,
@@ -11986,7 +14524,7 @@ const BUILTIN_TOOL_DEFINITIONS = [
 ];
 /**
  * 위험한 셸 명령 패턴들
- * execute_command에서 이 패턴에 매칭되는 명령은 사용자 승인 필요
+ * execute_command_tool에서 이 패턴에 매칭되는 명령은 사용자 승인 필요
  */
 const DANGEROUS_COMMAND_PATTERNS = [
     // 파일 삭제/제거
@@ -12452,9 +14990,11 @@ class SafetyChecker {
 
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   countDiffLines: () => (/* binding */ countDiffLines),
 /* harmony export */   escapeHtml: () => (/* binding */ escapeHtml),
 /* harmony export */   formatInlineMarkdown: () => (/* binding */ formatInlineMarkdown),
 /* harmony export */   formatMarkdownToHtml: () => (/* binding */ formatMarkdownToHtml),
+/* harmony export */   highlightDiff: () => (/* binding */ highlightDiff),
 /* harmony export */   highlightJavaScript: () => (/* binding */ highlightJavaScript),
 /* harmony export */   highlightPython: () => (/* binding */ highlightPython),
 /* harmony export */   normalizeIndentation: () => (/* binding */ normalizeIndentation),
@@ -12515,6 +15055,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
  */
@@ -12640,6 +15328,52 @@ function highlightPython(code) {
     });
     return highlighted;
 }
+/**
+ * Highlight diff output with colors for additions/deletions
+ */
+function highlightDiff(code) {
+    const lines = code.split('\n');
+    const highlightedLines = lines.map(line => {
+        const escapedLine = escapeHtml(line);
+        // File headers (--- and +++)
+        if (line.startsWith('---') || line.startsWith('+++')) {
+            return `<span class="diff-header">${escapedLine}</span>`;
+        }
+        // Hunk headers (@@ ... @@)
+        if (line.startsWith('@@')) {
+            return `<span class="diff-hunk">${escapedLine}</span>`;
+        }
+        // Added lines
+        if (line.startsWith('+')) {
+            return `<span class="diff-add">${escapedLine}</span>`;
+        }
+        // Removed lines
+        if (line.startsWith('-')) {
+            return `<span class="diff-del">${escapedLine}</span>`;
+        }
+        // Context lines (unchanged)
+        return `<span class="diff-context">${escapedLine}</span>`;
+    });
+    return highlightedLines.join('\n');
+}
+/**
+ * Count additions and deletions in diff code
+ */
+function countDiffLines(code) {
+    const lines = code.split('\n');
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+        // Skip file headers
+        if (line.startsWith('+++') || line.startsWith('---'))
+            continue;
+        if (line.startsWith('+'))
+            additions++;
+        else if (line.startsWith('-'))
+            deletions++;
+    }
+    return { additions, deletions };
+}
 /**
  * Highlight JavaScript code
  */
@@ -12915,9 +15649,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 = [];
@@ -12945,20 +15680,36 @@ function formatMarkdownToHtml(text) {
             language: lang
         });
         // Create HTML for code block
-        const highlightedCode = lang === 'python' || lang === 'py'
-            ? highlightPython(trimmedCode)
-            : lang === 'javascript' || lang === 'js'
-                ? highlightJavaScript(trimmedCode)
-                : escapeHtml(trimmedCode);
-        const htmlBlock = '<div class="code-block-container" data-block-id="' + blockId + '">' +
+        const isDiff = lang === 'diff';
+        const highlightedCode = isDiff
+            ? highlightDiff(trimmedCode)
+            : lang === 'python' || lang === 'py'
+                ? highlightPython(trimmedCode)
+                : lang === 'javascript' || lang === 'js'
+                    ? highlightJavaScript(trimmedCode)
+                    : escapeHtml(trimmedCode);
+        // For diff blocks, calculate and show line counts
+        let diffLineCountHtml = '';
+        if (isDiff) {
+            const { additions, deletions } = countDiffLines(trimmedCode);
+            diffLineCountHtml = '<span class="diff-line-counts">' +
+                '<span class="diff-additions">+' + additions + '</span>' +
+                '<span class="diff-deletions">-' + deletions + '</span>' +
+                '</span>';
+        }
+        const htmlBlock = '<div class="code-block-container' + (isDiff ? ' diff-block' : '') + '" data-block-id="' + blockId + '">' +
             '<div class="code-block-header">' +
             '<span class="code-block-language">' + escapeHtml(lang) + '</span>' +
+            diffLineCountHtml +
             '<div class="code-block-actions">' +
-            '<button class="code-block-apply" data-block-id="' + blockId + '" title="셀에 적용">셀에 적용</button>' +
+            (isDiff ? '' : '<button class="code-block-apply" data-block-id="' + blockId + '" title="셀에 적용">셀에 적용</button>') +
             '<button class="code-block-copy" data-block-id="' + blockId + '" title="복사">복사</button>' +
             '</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 +15771,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 +15819,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 +15984,4 @@ __webpack_require__.r(__webpack_exports__);
 /***/ }
 
 }]);
-//# sourceMappingURL=lib_index_js.a223ea20056954479ae9.js.map
+//# sourceMappingURL=lib_index_js.e4ff4b5779b5e049f84c.js.map