choavis-agent 1.4.0 → 1.4.2

package/dist/slack/handlers.js

@@ -1,7 +1,9 @@
-import { runAgent } from '../agent/runner.js';
-import { getSession, setSession, clearSession, getWorkDir } from '../agent/session.js';
+import { Assistant } from '@slack/bolt';
+import { runAgent, runSession } from '../agent/runner.js';
+import { getSession, setSession, clearSession, getWorkDir, setWorkDir, isBotStarted, markBotStarted } from '../agent/session.js';
 import { enqueue, getQueueSize } from '../agent/queue.js';
 import { formatResponse, splitMessage } from './formatter.js';
+import { resolveSessionFromLink } from './link-resolver.js';
 import { config } from '../config.js';
 import { createLogger } from '../utils/logger.js';
 import { matchCommand, executeCommand, registerAllCommands } from './commands/index.js';
@@ -9,83 +11,78 @@ import { recordUsage } from '../agent/usage.js';
 import { buildMemoryContext } from '../agent/memory.js';
 import { fetchThreadContext, fetchChannelHistory } from './context.js';
 import { ApprovalServer } from '../approval/server.js';
-import { installHook } from '../approval/setup.js';
+import { installHook, addToolToSettings } from '../approval/setup.js';
+import { withRetry, bestEffort } from './slack-retry.js';
+import { formatToolInline } from './tool-formatter.js';
+import { isBootMessage, isDuplicate, isAllowedUser, trackMentionThread, mentionStartedThreads, getActiveAgentCount, getMaxConcurrent, incrementActiveCount, decrementActiveCount, setActiveKill, deleteActiveKill, getActiveKill, setTypingStatus, } from './middleware.js';
+import { downloadAndPrepareFiles } from './file-downloader.js';
 // 모듈 로드 시 1회 등록
 registerAllCommands();
 const log = createLogger('handler');
 const STREAM_UPDATE_INTERVAL_MS = 3000;
-// 이벤트 중복 처리 방지 (message + app_mention 동시 발생)
-const processedMessages = new Set();
-const DEDUP_TTL_MS = 60_000;
-// 허용된 사용자 목록 (미설정 시 모든 사용자 허용)
-const allowedUsers = process.env.ALLOWED_SLACK_USERS?.split(',').map(s => s.trim()) || [];
-// 동시 프로세스 제한
-const MAX_CONCURRENT = parseInt(process.env.MAX_CONCURRENT_AGENTS || '5', 10);
-let activeAgentCount = 0;
-export function getActiveAgentCount() { return activeAgentCount; }
-export function getMaxConcurrent() { return MAX_CONCURRENT; }
-// 실행 중인 에이전트 프로세스의 kill 함수 추적
-const activeKills = new Map();
-export function getActiveKill(threadTs) {
-    return activeKills.get(threadTs);
+// 활성 승인 서버 추적 (채널/스레드별)
+const activeApprovalServers = new Map();
+function getApprovalKey(channel, threadTs) {
+    return `${channel}:${threadTs}`;
 }
-async function setTypingStatus(client, channel, threadTs, status) {
-    try {
-        await client.assistant?.threads?.setStatus?.({
-            channel_id: channel,
-            thread_ts: threadTs,
-            status,
-        });
-    }
-    catch {
-        // Slack Assistant API 미지원 시 조용히 무시
-    }
+// inject 명령어에서 직접 호출 (중복방지/부팅체크 건너뛰기 — 사용자 인증은 이미 완료됨)
+export async function handleIncomingDirect(text, channel, threadTs, messageTs, client, userId) {
+    await handleIncoming(text, channel, threadTs, messageTs, client, userId, undefined, undefined, true);
 }
-async function handleIncoming(text, channel, threadTs, messageTs, client, userId, slackContext) {
-    // 이벤트 중복 처리 방지
-    if (processedMessages.has(messageTs)) {
-        log.info('중복 메시지 무시', { messageTs });
-        return;
-    }
-    processedMessages.add(messageTs);
-    setTimeout(() => processedMessages.delete(messageTs), DEDUP_TTL_MS);
-    // 허용된 사용자 확인
-    if (allowedUsers.length > 0 && userId && !allowedUsers.includes(userId)) {
-        log.warn('허용되지 않은 사용자', { userId });
-        return;
+async function handleIncoming(text, channel, threadTs, messageTs, client, userId, slackContext, files, bypassGuards = false) {
+    if (!bypassGuards) {
+        // 앱 시작 이전 이벤트 무시 (재시작 시 밀린 이벤트 방지)
+        if (isBootMessage(messageTs)) {
+            log.info('부팅 이전 메시지 무시', { messageTs });
+            return;
+        }
+        // 이벤트 중복 처리 방지
+        if (isDuplicate(messageTs)) {
+            log.info('중복 메시지 무시', { messageTs });
+            return;
+        }
+        // 허용된 사용자 확인 (미설정 시 전체 거부)
+        if (!isAllowedUser(userId)) {
+            log.warn('허용되지 않은 사용자', { userId });
+            return;
+        }
     }
     log.info('메시지 수신', { text: text.slice(0, 50), threadTs });
     // 커맨드 디스패처
     const cmdMatch = matchCommand(text);
     if (cmdMatch) {
+        const activeAgentCount = getActiveAgentCount();
+        const MAX_CONCURRENT = getMaxConcurrent();
         await executeCommand(cmdMatch, { text, channel, threadTs, messageTs, client, userId, activeAgentCount, maxConcurrent: MAX_CONCURRENT, getActiveKill });
         return;
     }
+    // Slack 링크에서 세션 자동 연결 (현재 스레드에 세션이 없을 때만)
+    if (!getSession(threadTs)) {
+        const linked = resolveSessionFromLink(text);
+        if (linked) {
+            setSession(threadTs, linked.sessionId);
+            if (linked.workDir) {
+                setWorkDir(threadTs, linked.workDir);
+                setSession(threadTs, linked.sessionId);
+            }
+            log.info('링크에서 세션 자동 연결', { threadTs, linkedSessionId: linked.sessionId });
+        }
+    }
     // 동시 프로세스 제한
+    const activeAgentCount = getActiveAgentCount();
+    const MAX_CONCURRENT = getMaxConcurrent();
     if (activeAgentCount >= MAX_CONCURRENT) {
         log.warn('동시 프로세스 제한 초과', { activeAgentCount, MAX_CONCURRENT });
-        await client.chat.postMessage({
-            channel,
-            thread_ts: threadTs,
-            text: ':warning: 현재 처리량이 많습니다. 잠시 후 다시 시도해주세요.',
-        }).catch(() => { });
+        await withRetry(() => client.chat.postMessage({ channel, thread_ts: threadTs, text: ':warning: 현재 처리량이 많습니다. 잠시 후 다시 시도해주세요.' }), 'chat.postMessage(limit)').catch(() => { });
         return;
     }
-    // 큐 대기 중이면 안내
     const queueSize = getQueueSize(threadTs);
     if (queueSize > 0) {
         log.info('큐 대기 중', { threadTs, queueSize });
     }
-    activeAgentCount++;
     await enqueue(threadTs, async () => {
+        incrementActiveCount();
         const startTime = Date.now();
-        // 1. 처리 중 리액션
-        await client.reactions.add({
-            channel,
-            name: 'hourglass_flowing_sand',
-            timestamp: messageTs,
-        }).catch(() => { });
-        // 2. 응답 메시지 ts (실제 응답이 올 때 lazy 생성)
         let responseTs;
         await setTypingStatus(client, channel, threadTs, '처리 중...');
         // 3. AbortController로 타임아웃 관리
@@ -101,10 +98,20 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
             const threadWorkDir = getWorkDir(threadTs) || config.agent.workDir;
             // 메모리 + Slack 컨텍스트를 프롬프트에 주입
             const memoryContext = await buildMemoryContext(config.memory.dataDir);
-            const promptParts = [memoryContext, slackContext, text].filter(Boolean);
+            // 첨부 파일 처리
+            let fileContext = '';
+            if (files && files.length > 0) {
+                const fileResult = await downloadAndPrepareFiles(files, threadTs, config.slack.botToken, client);
+                fileContext = fileResult.promptSection;
+                if (fileResult.errors.length > 0) {
+                    const errorMsg = fileResult.errors.map(e => `:warning: ${e}`).join('\n');
+                    await bestEffort(() => client.chat.postMessage({ channel, thread_ts: threadTs, text: errorMsg }), 'chat.postMessage(file-errors)');
+                }
+            }
+            const promptParts = [memoryContext, slackContext, fileContext, text].filter(Boolean);
             const fullPrompt = promptParts.join('\n\n---\n\n');
             // 승인 서버 설정 (bypassPermissions가 아닌 경우)
-            const permMode = config.agent.permissionMode || 'plan';
+            const permMode = config.agent.permissionMode;
             let approvalPort;
             if (permMode !== 'bypassPermissions') {
                 approvalServer = new ApprovalServer();
@@ -113,18 +120,17 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
                 });
                 approvalPort = await approvalServer.start();
                 cleanupHook = await installHook(threadWorkDir, approvalPort);
-                // action 핸들러에서 찾을 수 있도록 등록
                 const approvalKey = getApprovalKey(channel, threadTs);
                 activeApprovalServers.set(approvalKey, approvalServer);
             }
-            const { stream, kill } = runAgent({
+            const { stream, kill } = runSession({
                 prompt: fullPrompt,
                 sessionId: sessionId || undefined,
                 workDir: threadWorkDir,
                 abortSignal: abortController.signal,
                 approvalPort,
             });
-            activeKills.set(threadTs, kill);
+            setActiveKill(threadTs, kill);
             let responseText = '';
             let newSessionId;
             let toolUseCount = 0;
@@ -138,122 +144,70 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
                         aborted = true;
                         break;
                     }
-                    // session_id 캡처
-                    if (event.type === 'system' && event.subtype === 'init' && event.session_id) {
-                        newSessionId = event.session_id;
-                    }
-                    // 텍스트 응답 (assistant 이벤트는 전체 텍스트로 교체)
-                    if (event.type === 'assistant') {
-                        const extracted = event._fullText;
-                        if (extracted) {
-                            responseText = extracted;
-                        }
-                    }
-                    // content_block_delta에서 부분 텍스트
-                    if (event.type === 'content_block_delta' && event.delta?.text) {
-                        responseText += event.delta.text;
-                    }
-                    // result에서 최종 텍스트
-                    if (event.type === 'result') {
-                        if (event.result) {
-                            responseText = event.result;
-                        }
-                        if (event.session_id) {
-                            newSessionId = event.session_id;
-                        }
-                        // 사용량 기록 (result 이벤트의 usage 필드가 있으면)
-                        if (event.usage) {
-                            void recordUsage({
-                                userId: userId || 'unknown',
-                                threadTs,
-                                timestamp: Date.now(),
-                                model: event.model || 'unknown',
-                                inputTokens: event.usage.input_tokens || 0,
-                                outputTokens: event.usage.output_tokens || 0,
-                                durationMs: Date.now() - startTime,
-                            }, config.usage.dataDir);
-                        }
-                    }
-                    // 도구 사용 카운트
-                    if (event.type === 'tool_use') {
-                        toolUseCount++;
-                    }
-                    // 에러 이벤트 처리 (에러 유형별 자동 복구)
-                    if (event.type === 'error') {
-                        const errContent = event.message?.content;
-                        if (Array.isArray(errContent)) {
-                            const errText = errContent
-                                .filter((c) => c.type === 'text')
-                                .map((c) => c.text)
-                                .join('');
-                            if (event.errorType === 'transient' && retryCount < 1) {
-                                retryCount++;
-                                log.info('transient 에러, 재시도 안내', { threadTs, retryCount });
-                                // transient 에러 안내 (메시지가 있으면 update, 없으면 무시)
-                                if (responseTs) {
-                                    await client.chat.update({ channel, ts: responseTs, text: ':warning: 일시적 오류가 발생했습니다...' }).catch(() => { });
+                    switch (event.type) {
+                        case 'start':
+                            newSessionId = event.sessionId;
+                            break;
+                        case 'text':
+                            if (event.text) {
+                                if (event.text.replace) {
+                                    responseText = event.text.content;
+                                }
+                                else {
+                                    responseText += event.text.content;
                                 }
-                                responseText += `\n:warning: 일시적 오류 발생. 재시도하려면 같은 메시지를 다시 보내주세요.`;
                             }
-                            else if (event.errorType === 'session_corrupt') {
-                                log.info('session corrupt, 세션 초기화', { threadTs });
-                                clearSession(threadTs);
-                                responseText += `\n:warning: 세션 오류가 발생하여 세션을 초기화했습니다. 다시 메시지를 보내주세요.`;
+                            break;
+                        case 'turn-end':
+                            if (event.turn?.result) {
+                                responseText = event.turn.result;
                             }
-                            else if (event.errorType === 'context_overflow' && !didAutoCompact) {
-                                didAutoCompact = true;
-                                log.info('context overflow, 자동 압축 시도', { threadTs });
-                                // context overflow 안내
-                                if (responseTs) {
-                                    await client.chat.update({ channel, ts: responseTs, text: ':warning: 컨텍스트가 가득 차서 압축 중...' }).catch(() => { });
-                                }
-                                try {
-                                    const compactResult = runAgent({
-                                        prompt: '/compact',
-                                        sessionId: newSessionId || sessionId || undefined,
-                                        workDir: threadWorkDir,
-                                    });
-                                    for await (const ce of compactResult.stream) {
-                                        if (ce.type === 'result' && ce.session_id) {
-                                            newSessionId = ce.session_id;
-                                            setSession(threadTs, ce.session_id);
-                                        }
-                                    }
-                                    responseText += `\n:warning: 컨텍스트를 자동 압축했습니다. 다시 메시지를 보내주세요.`;
-                                }
-                                catch (compactErr) {
-                                    log.error('자동 압축 실패', { error: String(compactErr) });
-                                    responseText += `\n:x: 컨텍스트 압축 실패. \`/new\`로 세션을 초기화해주세요.`;
-                                }
+                            if (event.sessionId) {
+                                newSessionId = event.sessionId;
                             }
-                            else {
-                                responseText += `\n:x: ${errText}`;
+                            if (event.turn?.usage) {
+                                void recordUsage({
+                                    userId: userId || 'unknown',
+                                    threadTs,
+                                    timestamp: Date.now(),
+                                    model: event.turn.usage.model || 'unknown',
+                                    inputTokens: event.turn.usage.inputTokens,
+                                    outputTokens: event.turn.usage.outputTokens,
+                                    durationMs: Date.now() - startTime,
+                                }, config.usage.dataDir);
                             }
-                        }
+                            break;
+                        case 'tool-call-start':
+                            toolUseCount++;
+                            break;
+                        case 'service':
+                            await handleServiceEvent(event, {
+                                threadTs, channel, responseTs, client,
+                                sessionId, newSessionId, threadWorkDir,
+                                retryCount, didAutoCompact,
+                                onRetry: () => { retryCount++; },
+                                onCompacted: () => { didAutoCompact = true; },
+                                onSessionId: (id) => { newSessionId = id; },
+                                appendText: (t) => { responseText += t; },
+                            });
+                            break;
+                        default:
+                            break;
                     }
-                    // 스트리밍 업데이트 (일정 간격으로)
+                    // 스트리밍 업데이트 (일정 간격)
                     const now = Date.now();
                     if (responseText && now - lastUpdateAt >= STREAM_UPDATE_INTERVAL_MS) {
                         lastUpdateAt = now;
-                        const preview = responseText.length > 3800
-                            ? responseText.slice(0, 3800) + '\n_... (처리 중)_'
-                            : responseText + '\n_... (처리 중)_';
+                        // splitMessage로 코드 블록 경계를 존중하며 첫 번째 청크를 미리보기로 표시
+                        const previewChunk = splitMessage(responseText)[0];
+                        const preview = previewChunk + '\n_... (처리 중)_';
                         if (!responseTs) {
-                            // 첫 번째 스트리밍: 새 메시지 생성
-                            const msg = await client.chat.postMessage({
-                                channel,
-                                thread_ts: threadTs,
-                                text: preview,
-                            }).catch(() => null);
+                            const msg = await withRetry(() => client.chat.postMessage({ channel, thread_ts: threadTs, text: preview }), 'chat.postMessage(stream)').catch(() => null);
                             if (msg?.ts)
                                 responseTs = msg.ts;
                         }
                         else {
-                            await client.chat.update({
-                                channel,
-                                ts: responseTs,
-                                text: preview,
-                            }).catch(() => { });
+                            await bestEffort(() => client.chat.update({ channel, ts: responseTs, text: preview }), 'chat.update(stream)');
                         }
                     }
                 }
@@ -264,9 +218,14 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
                     kill();
                 }
             }
-            // 4. 세션 저장
+            // 4. 세션 저장 (메타데이터 포함)
             if (newSessionId) {
-                setSession(threadTs, newSessionId);
+                setSession(threadTs, newSessionId, {
+                    userId,
+                    channel,
+                    model: config.agent.model || undefined,
+                    lastPrompt: text,
+                });
                 log.info('세션 저장', { threadTs, sessionId: newSessionId });
             }
             // 5. 응답 전송
@@ -279,54 +238,28 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
             }
             const { text: formatted, snippets } = formatResponse(responseText);
             const chunks = splitMessage(formatted);
+            // 여러 청크일 때 n/total 번호 표시
+            const total = chunks.length;
+            const withIndex = (text, idx) => total > 1 ? `_(${idx + 1}/${total})_\n${text}` : text;
+            // 스트리밍 미리보기 메시지 삭제 (있으면)
             if (responseTs) {
-                // 기존 메시지를 최종 응답으로 업데이트
-                await client.chat.update({
-                    channel,
-                    ts: responseTs,
-                    text: chunks[0],
-                });
-            }
-            else {
-                // 스트리밍 업데이트가 없었으면 새 메시지로 전송
-                const msg = await client.chat.postMessage({
-                    channel,
-                    thread_ts: threadTs,
-                    text: chunks[0],
-                });
-                responseTs = msg.ts;
+                await bestEffort(() => client.chat.delete({ channel, ts: responseTs }), 'chat.delete(preview)');
             }
-            // 나머지 chunk는 별도 메시지
-            for (let i = 1; i < chunks.length; i++) {
-                await client.chat.postMessage({
-                    channel,
-                    thread_ts: threadTs,
-                    text: chunks[i],
-                });
+            // 모든 청크를 새 메시지로 순차 전송 (1/N, 2/N, ...)
+            for (let i = 0; i < chunks.length; i++) {
+                await withRetry(() => client.chat.postMessage({ channel, thread_ts: threadTs, text: withIndex(chunks[i], i) }), `chat.postMessage(chunk ${i})`);
             }
-            // 코드 스니펫 파일 업로드
             for (const snippet of snippets) {
-                await client.filesUploadV2({
+                await withRetry(() => client.filesUploadV2({
                     channel_id: channel,
                     thread_ts: threadTs,
                     filename: snippet.filename,
                     content: snippet.content,
                     title: snippet.filename,
-                }).catch((e) => {
+                }), `filesUploadV2(${snippet.filename})`).catch((e) => {
                     log.error('스니펫 업로드 실패', { filename: snippet.filename, error: String(e) });
                 });
             }
-            // 6. 리액션 변경
-            await client.reactions.remove({
-                channel,
-                name: 'hourglass_flowing_sand',
-                timestamp: messageTs,
-            }).catch(() => { });
-            await client.reactions.add({
-                channel,
-                name: 'white_check_mark',
-                timestamp: messageTs,
-            }).catch(() => { });
             if (toolUseCount > 0) {
                 log.info('도구 사용', { threadTs, toolUseCount });
             }
@@ -335,27 +268,16 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
             log.error('처리 오류', { error: String(error), threadTs });
             const errMsg = `:x: 오류가 발생했습니다: ${error instanceof Error ? error.message : '알 수 없는 오류'}`;
             if (responseTs) {
-                await client.chat.update({ channel, ts: responseTs, text: errMsg }).catch(() => { });
+                await bestEffort(() => client.chat.update({ channel, ts: responseTs, text: errMsg }), 'chat.update(error)');
             }
             else {
-                await client.chat.postMessage({ channel, thread_ts: threadTs, text: errMsg }).catch(() => { });
+                await bestEffort(() => client.chat.postMessage({ channel, thread_ts: threadTs, text: errMsg }), 'chat.postMessage(error)');
             }
-            await client.reactions.remove({
-                channel,
-                name: 'hourglass_flowing_sand',
-                timestamp: messageTs,
-            }).catch(() => { });
-            await client.reactions.add({
-                channel,
-                name: 'x',
-                timestamp: messageTs,
-            }).catch(() => { });
         }
         finally {
-            activeKills.delete(threadTs);
+            deleteActiveKill(threadTs);
             clearTimeout(timeoutHandle);
             await setTypingStatus(client, channel, threadTs, '');
-            // 승인 서버 정리
             const approvalKey = getApprovalKey(channel, threadTs);
             activeApprovalServers.delete(approvalKey);
             if (approvalServer) {
@@ -364,36 +286,59 @@ async function handleIncoming(text, channel, threadTs, messageTs, client, userId
             if (cleanupHook) {
                 await cleanupHook().catch(() => { });
             }
-            activeAgentCount--;
+            decrementActiveCount();
         }
     });
 }
-// 활성 승인 서버 추적 (채널/스레드별)
-const activeApprovalServers = new Map();
-function getApprovalKey(channel, threadTs) {
-    return `${channel}:${threadTs}`;
-}
-function formatToolInput(toolName, toolInput) {
-    if (toolName === 'Bash' && toolInput.command) {
-        return `\`${String(toolInput.command).slice(0, 200)}\``;
+async function handleServiceEvent(event, ctx) {
+    const svc = event.service;
+    if (!svc)
+        return;
+    if (svc.errorType === 'transient' && ctx.retryCount < 1) {
+        ctx.onRetry();
+        log.info('transient 에러, 재시도 안내', { threadTs: ctx.threadTs });
+        if (ctx.responseTs) {
+            await ctx.client.chat.update({ channel: ctx.channel, ts: ctx.responseTs, text: ':warning: 일시적 오류가 발생했습니다...' }).catch(() => { });
+        }
+        ctx.appendText('\n:warning: 일시적 오류 발생. 재시도하려면 같은 메시지를 다시 보내주세요.');
     }
-    if (toolName === 'Write' && toolInput.file_path) {
-        return `파일: \`${toolInput.file_path}\``;
+    else if (svc.errorType === 'session_corrupt') {
+        log.info('session corrupt, 세션 초기화', { threadTs: ctx.threadTs });
+        clearSession(ctx.threadTs);
+        ctx.appendText('\n:warning: 세션 오류가 발생하여 세션을 초기화했습니다. 다시 메시지를 보내주세요.');
     }
-    if (toolName === 'Edit' && toolInput.file_path) {
-        return `파일: \`${toolInput.file_path}\``;
+    else if (svc.errorType === 'context_overflow' && !ctx.didAutoCompact) {
+        ctx.onCompacted();
+        log.info('context overflow, 자동 압축 시도', { threadTs: ctx.threadTs });
+        if (ctx.responseTs) {
+            await ctx.client.chat.update({ channel: ctx.channel, ts: ctx.responseTs, text: ':warning: 컨텍스트가 가득 차서 압축 중...' }).catch(() => { });
+        }
+        try {
+            const compactResult = runAgent({
+                prompt: '/compact',
+                sessionId: ctx.newSessionId || ctx.sessionId || undefined,
+                workDir: ctx.threadWorkDir,
+            });
+            for await (const ce of compactResult.stream) {
+                if (ce.type === 'result' && ce.session_id) {
+                    ctx.onSessionId(ce.session_id);
+                    setSession(ctx.threadTs, ce.session_id);
+                }
+            }
+            ctx.appendText('\n:warning: 컨텍스트를 자동 압축했습니다. 다시 메시지를 보내주세요.');
+        }
+        catch (compactErr) {
+            log.error('자동 압축 실패', { error: String(compactErr) });
+            ctx.appendText('\n:x: 컨텍스트 압축 실패. `$new`로 세션을 초기화해주세요.');
+        }
     }
-    if (toolName === 'NotebookEdit' && toolInput.notebook_path) {
-        return `파일: \`${toolInput.notebook_path}\``;
+    else {
+        ctx.appendText(`\n:x: ${svc.message}`);
     }
-    // 기본: 주요 필드 요약
-    const keys = Object.keys(toolInput).slice(0, 3);
-    if (keys.length === 0)
-        return '(입력 없음)';
-    return keys.map((k) => `${k}: ${String(toolInput[k]).slice(0, 100)}`).join(', ');
 }
 async function sendApprovalButtons(client, channel, threadTs, request) {
-    const summary = formatToolInput(request.toolName, request.toolInput);
+    const summary = formatToolInline({ toolName: request.toolName, toolInput: request.toolInput });
+    const buttonValue = `${request.requestId}:${request.toolName}`;
     try {
         await client.chat.postMessage({
             channel,
@@ -412,17 +357,23 @@ async function sendApprovalButtons(client, channel, threadTs, request) {
                     elements: [
                         {
                             type: 'button',
-                            text: { type: 'plain_text', text: ':white_check_mark: 승인' },
+                            text: { type: 'plain_text', text: '이번만 승인' },
                             style: 'primary',
                             action_id: 'approve_tool',
-                            value: request.requestId,
+                            value: buttonValue,
+                        },
+                        {
+                            type: 'button',
+                            text: { type: 'plain_text', text: '항상 허용' },
+                            action_id: 'approve_tool_always',
+                            value: buttonValue,
                         },
                         {
                             type: 'button',
-                            text: { type: 'plain_text', text: ':x: 거부' },
+                            text: { type: 'plain_text', text: '거부' },
                             style: 'danger',
                             action_id: 'deny_tool',
-                            value: request.requestId,
+                            value: buttonValue,
                         },
                     ],
                 },
@@ -433,14 +384,115 @@ async function sendApprovalButtons(client, channel, threadTs, request) {
         log.error('승인 버튼 전송 실패', { error: String(e) });
     }
 }
+function parseButtonValue(raw) {
+    const idx = raw.indexOf(':');
+    if (idx === -1)
+        return [raw, ''];
+    return [raw.slice(0, idx), raw.slice(idx + 1)];
+}
 export function registerHandlers(app) {
-    // 도구 승인 action 핸들러
+    // Slack Assistant 핸들러 (DM Messages 탭)
+    const assistant = new Assistant({
+        threadStarted: async ({ say, setSuggestedPrompts, setTitle }) => {
+            await setTitle('Choavis Agent');
+            await say('무엇을 도와드릴까요? 코드 작성, 리뷰, 버그 수정, Git 작업 등 터미널에서 할 수 있는 모든 작업을 처리할 수 있습니다.');
+            await setSuggestedPrompts({
+                prompts: [
+                    { title: '프로젝트 구조 확인', message: '현재 프로젝트의 구조를 분석해줘' },
+                    { title: '코드 리뷰', message: '최근 변경사항을 코드 리뷰해줘' },
+                    { title: 'Git 상태 확인', message: 'git status 확인해줘' },
+                ],
+            });
+        },
+        userMessage: async ({ message, client, setStatus }) => {
+            const msg = message;
+            if ((msg.subtype && msg.subtype !== 'file_share') || msg.bot_id)
+                return;
+            const text = msg.text;
+            log.info('userMessage 수신', { text: text?.slice(0, 50), subtype: msg.subtype, filesCount: msg.files?.length ?? 0, msgKeys: Object.keys(message) });
+            if (!text && !msg.files?.length)
+                return;
+            const threadTs = msg.thread_ts || msg.ts;
+            await setStatus('처리 중...').catch(() => { });
+            let slackContext = '';
+            let threadFiles = [];
+            if (msg.thread_ts && !getSession(threadTs)) {
+                const ctx = await fetchThreadContext(client, msg.channel, msg.thread_ts, msg.ts);
+                slackContext = ctx.text;
+                threadFiles = ctx.files;
+            }
+            const allFiles = [...threadFiles, ...(msg.files || [])];
+            await handleIncoming(text || '(첨부 파일을 확인해주세요)', msg.channel, threadTs, msg.ts, client, msg.user, slackContext, allFiles.length > 0 ? allFiles : undefined);
+        },
+    });
+    app.assistant(assistant);
+    // App Home 열기 핸들러
+    app.event('app_home_opened', async ({ event, client }) => {
+        if (event.tab !== 'home')
+            return;
+        try {
+            await client.views.publish({
+                user_id: event.user,
+                view: {
+                    type: 'home',
+                    blocks: [
+                        {
+                            type: 'header',
+                            text: { type: 'plain_text', text: 'Choavis Agent' },
+                        },
+                        {
+                            type: 'section',
+                            text: {
+                                type: 'mrkdwn',
+                                text: 'Slack을 통해 Claude Code를 실행하는 AI 코딩 에이전트입니다.',
+                            },
+                        },
+                        { type: 'divider' },
+                        {
+                            type: 'section',
+                            text: {
+                                type: 'mrkdwn',
+                                text: '*사용 방법*\n\n'
+                                    + ':speech_balloon: *DM* — 이 앱의 *메시지 탭*에서 새 대화를 시작하세요\n'
+                                    + ':mega: *채널 멘션* — 채널에서 `@Choavis`를 멘션하세요\n',
+                            },
+                        },
+                        {
+                            type: 'section',
+                            text: {
+                                type: 'mrkdwn',
+                                text: '*명령어*\n\n'
+                                    + '`$stop` / `$중지` — 실행 중인 작업 중단\n'
+                                    + '`$new` — 세션 초기화 (대화 리셋)\n'
+                                    + '`$compact` — 컨텍스트 압축\n'
+                                    + '`$model <이름>` — 모델 변경 (sonnet/opus/haiku)\n'
+                                    + '`$permission <모드>` — 권한 모드 변경 (bypass/plan/accept)\n'
+                                    + '`$status` — 현재 설정 및 상태 확인\n'
+                                    + '`$sessions` / `$세션` — 활성 세션 목록\n'
+                                    + '`$resume <ID>` / `$이어서` — 기존 세션에 연결\n'
+                                    + '`$inject <ID> <명령>` — 특정 세션에 명령 주입\n'
+                                    + '`$usage` / `사용량` — 사용량 대시보드\n'
+                                    + '`기억해: 내용` — 기억 저장\n'
+                                    + '`기억 목록` — 저장된 기억 조회\n'
+                                    + '`프로젝트: 이름` — 작업 디렉토리 전환\n'
+                                    + '`$help` — 전체 도움말',
+                            },
+                        },
+                    ],
+                },
+            });
+        }
+        catch (e) {
+            log.error('App Home 업데이트 실패', { error: String(e), user: event.user });
+        }
+    });
+    // 승인 action 핸들러 — 이번만 승인
     app.action('approve_tool', async ({ action, body, client, ack }) => {
         await ack();
-        const requestId = 'value' in action ? action.value : '';
+        const raw = 'value' in action ? action.value : '';
+        const [requestId, toolName] = parseButtonValue(raw);
         const channel = body.channel?.id;
         const messageTs = body.message?.ts;
-        // 모든 활성 승인 서버에서 요청 찾기
         let resolved = false;
         for (const server of activeApprovalServers.values()) {
             if (server.resolve(requestId, 'allow')) {
@@ -449,25 +501,68 @@ export function registerHandlers(app) {
             }
         }
         if (channel && messageTs) {
+            const label = toolName ? ` — \`${toolName}\`` : '';
             await client.chat.update({
                 channel,
                 ts: messageTs,
-                text: ':white_check_mark: 승인됨',
+                text: ':white_check_mark: 승인됨 (이번만)',
                 blocks: [
                     {
                         type: 'section',
                         text: {
                             type: 'mrkdwn',
-                            text: `:white_check_mark: *승인됨* ${resolved ? '' : '(이미 처리됨)'}`,
+                            text: `:white_check_mark: *승인됨* (이번만)${label} ${resolved ? '' : '(이미 처리됨)'}`,
                         },
                     },
                 ],
             }).catch(() => { });
         }
     });
+    // 승인 action 핸들러 — 항상 허용
+    app.action('approve_tool_always', async ({ action, body, client, ack }) => {
+        await ack();
+        const raw = 'value' in action ? action.value : '';
+        const [requestId, toolName] = parseButtonValue(raw);
+        const channel = body.channel?.id;
+        const threadTs = body.message?.thread_ts;
+        const messageTs = body.message?.ts;
+        let resolved = false;
+        for (const server of activeApprovalServers.values()) {
+            if (server.resolve(requestId, 'allow', true)) {
+                resolved = true;
+                break;
+            }
+        }
+        // settings.local.json에 도구 영구 등록
+        if (toolName) {
+            const workDir = (threadTs ? getWorkDir(threadTs) : null) || config.agent.workDir;
+            await addToolToSettings(workDir, toolName).catch((e) => {
+                log.error('settings.local.json 업데이트 실패', { error: String(e), toolName });
+            });
+        }
+        if (channel && messageTs) {
+            const label = toolName ? ` — \`${toolName}\`` : '';
+            await client.chat.update({
+                channel,
+                ts: messageTs,
+                text: ':white_check_mark: 항상 허용됨',
+                blocks: [
+                    {
+                        type: 'section',
+                        text: {
+                            type: 'mrkdwn',
+                            text: `:white_check_mark: *항상 허용됨*${label} ${resolved ? '' : '(이미 처리됨)'}`,
+                        },
+                    },
+                ],
+            }).catch(() => { });
+        }
+    });
+    // 승인 action 핸들러 — 거부
     app.action('deny_tool', async ({ action, body, client, ack }) => {
         await ack();
-        const requestId = 'value' in action ? action.value : '';
+        const raw = 'value' in action ? action.value : '';
+        const [requestId, toolName] = parseButtonValue(raw);
         const channel = body.channel?.id;
         const messageTs = body.message?.ts;
         let resolved = false;
@@ -478,6 +573,7 @@ export function registerHandlers(app) {
             }
         }
         if (channel && messageTs) {
+            const label = toolName ? ` — \`${toolName}\`` : '';
             await client.chat.update({
                 channel,
                 ts: messageTs,
@@ -487,49 +583,66 @@ export function registerHandlers(app) {
                         type: 'section',
                         text: {
                             type: 'mrkdwn',
-                            text: `:x: *거부됨* ${resolved ? '' : '(이미 처리됨)'}`,
+                            text: `:x: *거부됨*${label} ${resolved ? '' : '(이미 처리됨)'}`,
                         },
                     },
                 ],
             }).catch(() => { });
         }
     });
-    // DM 메시지 핸들러 (DM에서는 멘션 없이도 반응)
+    // DM 메시지 핸들러
     app.message(async ({ message, client }) => {
         const msg = message;
-        if (msg.subtype || msg.bot_id)
+        if ((msg.subtype && msg.subtype !== 'file_share') || msg.bot_id)
             return;
         const text = msg.text;
-        if (!text)
+        if (!text && !msg.files?.length)
             return;
         const isDM = msg.channel_type === 'im';
-        if (!isDM)
-            return; // 채널 메시지는 app_mention에서만 처리
+        // @멘션으로 시작된 스레드의 후속 메시지도 처리
+        const isFollowUp = !isDM && msg.thread_ts && (mentionStartedThreads.has(msg.thread_ts) || isBotStarted(msg.thread_ts));
+        if (!isDM && !isFollowUp)
+            return;
         const threadTs = msg.thread_ts || msg.ts;
-        // DM 스레드에서 새 세션이면 이전 대화 컨텍스트 주입
         let slackContext = '';
+        let threadFiles = [];
         if (msg.thread_ts && !getSession(threadTs)) {
-            slackContext = await fetchThreadContext(client, msg.channel, msg.thread_ts, msg.ts);
+            const ctx = await fetchThreadContext(client, msg.channel, msg.thread_ts, msg.ts);
+            slackContext = ctx.text;
+            threadFiles = ctx.files;
         }
-        await handleIncoming(text, msg.channel, threadTs, msg.ts, client, msg.user, slackContext);
+        const cleanText = isFollowUp
+            ? (text?.replace(/<@[A-Z0-9]+>/g, '').trim() || text || '')
+            : (text || '');
+        const allFiles = [...threadFiles, ...(msg.files || [])];
+        await handleIncoming(cleanText || '(첨부 파일을 확인해주세요)', msg.channel, threadTs, msg.ts, client, msg.user, slackContext, allFiles.length > 0 ? allFiles : undefined);
     });
     // 채널 @멘션 핸들러
     app.event('app_mention', async ({ event, client }) => {
         const text = event.text?.replace(/<@[A-Z0-9]+>/g, '').trim();
-        if (!text)
+        const files = event.files;
+        if (!text && !files?.length)
             return;
         const threadTs = event.thread_ts || event.ts;
+        // @멘션으로 스레드를 시작한 경우만 추적
+        if (!event.thread_ts) {
+            trackMentionThread(event.ts);
+            markBotStarted(event.ts);
+        }
         // Slack 대화 컨텍스트 수집
         let slackContext = '';
-        if (event.thread_ts) {
-            // 스레드 멘션: 스레드 이전 대화 주입
-            slackContext = await fetchThreadContext(client, event.channel, event.thread_ts, event.ts);
+        let threadFiles = [];
+        if (event.thread_ts && !getSession(threadTs)) {
+            const ctx = await fetchThreadContext(client, event.channel, event.thread_ts, event.ts);
+            slackContext = ctx.text;
+            threadFiles = ctx.files;
         }
-        else {
+        else if (!event.thread_ts) {
             // 최상위 멘션: 채널 최근 대화 주입
             slackContext = await fetchChannelHistory(client, event.channel);
         }
-        await handleIncoming(text, event.channel, threadTs, event.ts, client, event.user, slackContext);
+        const allFiles = [...threadFiles, ...(files || [])];
+        await handleIncoming(text || '(첨부 파일을 확인해주세요)', event.channel, threadTs, event.ts, client, event.user, slackContext, allFiles.length > 0 ? allFiles : undefined);
     });
 }
 //# sourceMappingURL=handlers.js.map