companionbot 0.5.0 → 0.6.0

package/dist/memory/vectorStore.js

@@ -0,0 +1,194 @@
+/**
+ * 간단한 벡터 저장소 모듈
+ * 메모리 파일들을 로드하고 유사도 기반으로 검색합니다.
+ */
+import * as fs from "fs/promises";
+import * as path from "path";
+import { getMemoryDirPath, getWorkspaceFilePath } from "../workspace/paths.js";
+import { embed, cosineSimilarity } from "./embeddings.js";
+// 캐시된 청크들 (임베딩 포함)
+let cachedChunks = [];
+let cacheTimestamp = 0;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
+// 로딩 중복 방지용 Promise
+let loadingPromise = null;
+/**
+ * 텍스트를 적절한 크기의 청크로 분할합니다.
+ */
+function splitIntoChunks(text, source) {
+    const chunks = [];
+    // ## 헤더로 분할 (메모리 파일 형식)
+    const sections = text.split(/(?=^## )/m);
+    for (const section of sections) {
+        const trimmed = section.trim();
+        if (!trimmed || trimmed.length < 20)
+            continue;
+        // 청크가 너무 길면 추가로 분할
+        if (trimmed.length > 500) {
+            const lines = trimmed.split("\n");
+            let currentChunk = "";
+            for (const line of lines) {
+                if (currentChunk.length + line.length > 500) {
+                    if (currentChunk.trim()) {
+                        chunks.push({ text: currentChunk.trim(), source });
+                    }
+                    currentChunk = line;
+                }
+                else {
+                    currentChunk += "\n" + line;
+                }
+            }
+            if (currentChunk.trim()) {
+                chunks.push({ text: currentChunk.trim(), source });
+            }
+        }
+        else {
+            chunks.push({ text: trimmed, source });
+        }
+    }
+    return chunks;
+}
+/**
+ * 내부 로드 로직 - 실제 파일 로드 수행
+ */
+async function doLoadAllMemoryChunks() {
+    const chunks = [];
+    // 1. 일별 메모리 파일 (최근 30일)
+    const memoryDir = getMemoryDirPath();
+    try {
+        const files = await fs.readdir(memoryDir);
+        const mdFiles = files.filter(f => f.endsWith(".md")).sort().reverse().slice(0, 30);
+        for (const file of mdFiles) {
+            try {
+                const content = await fs.readFile(path.join(memoryDir, file), "utf-8");
+                const fileChunks = splitIntoChunks(content, file.replace(".md", ""));
+                chunks.push(...fileChunks);
+            }
+            catch {
+                // 파일 읽기 실패 무시
+            }
+        }
+    }
+    catch {
+        // 디렉토리 없음 무시
+    }
+    // 2. MEMORY.md (장기 기억)
+    try {
+        const memoryMdPath = getWorkspaceFilePath("MEMORY.md");
+        const content = await fs.readFile(memoryMdPath, "utf-8");
+        const memoryChunks = splitIntoChunks(content, "MEMORY");
+        chunks.push(...memoryChunks);
+    }
+    catch {
+        // 파일 없음 무시
+    }
+    return chunks;
+}
+/**
+ * 모든 메모리 파일을 로드하고 청크로 분할합니다.
+ * 동시 요청 시 중복 로드를 방지합니다.
+ */
+export async function loadAllMemoryChunks() {
+    const now = Date.now();
+    // 캐시가 유효하면 반환
+    if (cachedChunks.length > 0 && now - cacheTimestamp < CACHE_TTL_MS) {
+        return cachedChunks;
+    }
+    // 이미 로딩 중이면 해당 Promise 반환 (중복 로드 방지)
+    if (loadingPromise) {
+        return loadingPromise;
+    }
+    // 새로 로드
+    loadingPromise = doLoadAllMemoryChunks();
+    try {
+        const chunks = await loadingPromise;
+        // 캐시 업데이트 (임베딩은 아직 없음)
+        cachedChunks = chunks;
+        cacheTimestamp = Date.now();
+        return chunks;
+    }
+    finally {
+        loadingPromise = null;
+    }
+}
+/**
+ * 쿼리 임베딩으로 관련 메모리를 검색합니다.
+ * @param queryEmbedding 검색 쿼리의 임베딩 벡터
+ * @param topK 반환할 최대 결과 수
+ * @param minScore 최소 유사도 점수 (0-1)
+ */
+export async function search(queryEmbedding, topK = 5, minScore = 0.3) {
+    const chunks = await loadAllMemoryChunks();
+    if (chunks.length === 0) {
+        return [];
+    }
+    // 각 청크에 대해 임베딩 생성 및 유사도 계산
+    const results = [];
+    for (const chunk of chunks) {
+        try {
+            // 캐시된 임베딩이 없으면 생성
+            if (!chunk.embedding) {
+                chunk.embedding = await embed(chunk.text);
+            }
+            const score = cosineSimilarity(queryEmbedding, chunk.embedding);
+            if (score >= minScore) {
+                results.push({
+                    text: chunk.text,
+                    source: chunk.source,
+                    score,
+                });
+            }
+        }
+        catch {
+            // 임베딩 실패 무시
+        }
+    }
+    // 유사도 점수로 정렬하고 상위 K개 반환
+    return results
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+}
+/**
+ * 캐시를 무효화합니다.
+ */
+export function invalidateCache() {
+    cachedChunks = [];
+    cacheTimestamp = 0;
+    loadingPromise = null;
+}
+// 인메모리 저장소 (간단한 구현)
+let vectorStore = [];
+/**
+ * 엔트리들을 저장소에 추가/업데이트합니다.
+ */
+export async function upsertEntries(entries) {
+    for (const entry of entries) {
+        const existingIndex = vectorStore.findIndex(e => e.id === entry.id);
+        if (existingIndex >= 0) {
+            vectorStore[existingIndex] = entry;
+        }
+        else {
+            vectorStore.push(entry);
+        }
+    }
+    // 캐시 무효화
+    invalidateCache();
+}
+/**
+ * 특정 소스의 모든 엔트리를 삭제합니다.
+ */
+export async function deleteBySource(source) {
+    const before = vectorStore.length;
+    vectorStore = vectorStore.filter(e => e.source !== source);
+    const deleted = before - vectorStore.length;
+    if (deleted > 0) {
+        invalidateCache();
+    }
+    return deleted;
+}
+/**
+ * 저장소의 모든 엔트리를 반환합니다.
+ */
+export function getAllEntries() {
+    return [...vectorStore];
+}

package/dist/session/state.js

@@ -1,7 +1,9 @@
 import { AsyncLocalStorage } from "async_hooks";
+import { estimateMessagesTokens } from "../utils/tokens.js";
 // 세션 설정
 const MAX_SESSIONS = 100;
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
+const MAX_HISTORY_TOKENS = 50000; // 시스템 프롬프트 + 응답 여유 남기고
 // 세션별 상태 저장
 const sessions = new Map();
 // AsyncLocalStorage for chatId context
@@ -44,6 +46,15 @@ function cleanupSessions() {
 export function getHistory(chatId) {
     return getSession(chatId).history;
 }
+/**
+ * 히스토리를 토큰 기반으로 트리밍한다.
+ * 최대 토큰 한도를 초과하면 가장 오래된 메시지부터 제거 (최소 2개는 유지).
+ */
+export function trimHistoryByTokens(history) {
+    while (estimateMessagesTokens(history) > MAX_HISTORY_TOKENS && history.length > 2) {
+        history.shift();
+    }
+}
 export function clearHistory(chatId) {
     sessions.delete(chatId);
 }

package/dist/telegram/bot.js

@@ -27,12 +27,12 @@ export function createBot(token) {
     // Cron 시스템 초기화
     setCronBot(bot);
     restoreCronJobs().catch((err) => console.error("Failed to restore cron jobs:", err));
-    // Rate limiting - 1분에 20개 메시지
+    // Rate limiting - 1분에 10개 메시지
     bot.use(limit({
         timeFrame: 60000, // 1분
-        limit: 20,
+        limit: 10,
         onLimitExceeded: async (ctx) => {
-            await ctx.reply("⚠️ 너무 빠르게 메시지를 보내고 있어요. 30초 후 다시 시도해주세요.");
+            await ctx.reply("⚠️ 너무 빠르게 메시지를 보내고 있어요. 잠시 후 다시 시도해주세요.");
         },
     }));
     // 에러 핸들링

package/dist/telegram/handlers/commands.js

@@ -1,6 +1,32 @@
-import { InlineKeyboard } from "grammy";
 import { randomBytes } from "crypto";
 import { chat, MODELS } from "../../ai/claude.js";
+import { estimateMessagesTokens } from "../../utils/tokens.js";
+// 대화 요약 생성 함수
+async function generateSummary(messages) {
+    const conversationText = messages.map(m => {
+        const content = typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+        return `${m.role === "user" ? "사용자" : "AI"}: ${content}`;
+    }).join("\n");
+    const summaryPrompt = [
+        {
+            role: "user",
+            content: `다음 대화를 핵심만 담아 간결하게 요약해줘. 중요한 결정사항, 사용자 정보, 맥락만 포함하고 3-5문장 이내로:
+
+${conversationText}
+
+요약:`
+        }
+    ];
+    try {
+        // haiku로 빠르게 요약 생성
+        const summary = await chat(summaryPrompt, undefined, "haiku");
+        return summary;
+    }
+    catch (error) {
+        console.error("Summary generation error:", error);
+        return "이전 대화 내용 (요약 생성 실패)";
+    }
+}
 // Reset 토큰 관리 (1분 만료)
 const resetTokens = new Map();
 function generateResetToken(chatId) {
@@ -30,6 +56,7 @@ import { isCalendarConfigured, hasCredentials, setCredentials, getAuthUrl, start
 import { setBriefingConfig, getBriefingConfig, disableBriefing, } from "../../briefing/index.js";
 import { setHeartbeatConfig, getHeartbeatConfig, disableHeartbeat, } from "../../heartbeat/index.js";
 import { getWorkspace, invalidateWorkspaceCache, buildSystemPrompt, extractName, } from "../utils/index.js";
+import { ensureDefaultCronJobs } from "../../cron/scheduler.js";
 export function registerCommands(bot) {
     // /start 명령어
     bot.command("start", async (ctx) => {
@@ -68,6 +95,8 @@ export function registerCommands(bot) {
             // 일반 모드
             const workspace = await getWorkspace();
             const name = extractName(workspace.identity) || "CompanionBot";
+            // 기본 cron jobs 설정 확인
+            await ensureDefaultCronJobs(chatId);
             await ctx.reply(`안녕! ${name}이야.\n\n` +
                 `명령어:\n` +
                 `/clear - 대화 초기화\n` +
@@ -75,48 +104,16 @@ export function registerCommands(bot) {
                 `/reset - 페르소나 리셋`);
         }
     });
-    // /reset 명령어 - 페르소나 리셋 (인라인 버튼 + 토큰 기반)
+    // /reset 명령어 - 페르소나 리셋 (토큰 기반)
     bot.command("reset", async (ctx) => {
         const chatId = ctx.chat.id;
         const token = generateResetToken(chatId);
-        const keyboard = new InlineKeyboard()
-            .text("✅ 예, 리셋합니다", `reset_confirm_${token}`)
-            .text("❌ 취소", "reset_cancel");
-        await ctx.reply("⚠️ 정말 페르소나를 리셋할까요?\n\n" +
-            "모든 설정이 초기화되고 온보딩을 다시 진행합니다.\n" +
-            "(1분 후 버튼 만료)", { reply_markup: keyboard });
-    });
-    // Reset 확인 버튼 콜백
-    bot.callbackQuery(/^reset_confirm_([a-f0-9]+)$/, async (ctx) => {
-        const chatId = ctx.chat.id;
-        const token = ctx.match[1];
-        if (!validateResetToken(chatId, token)) {
-            await ctx.answerCallbackQuery({ text: "❌ 만료된 요청입니다. /reset 으로 다시 시도하세요." });
-            await ctx.editMessageText("❌ 만료된 요청입니다.\n/reset 으로 다시 시도하세요.");
-            return;
-        }
-        const { initWorkspace } = await import("../../workspace/index.js");
-        const { rm } = await import("fs/promises");
-        try {
-            await ctx.answerCallbackQuery({ text: "리셋 중..." });
-            await rm(getWorkspacePath(), { recursive: true, force: true });
-            await initWorkspace();
-            invalidateWorkspaceCache();
-            clearHistory(chatId);
-            await ctx.editMessageText("✓ 페르소나가 리셋되었습니다.\n\n" +
-                "/start 를 눌러 온보딩을 시작하세요.");
-        }
-        catch (error) {
-            console.error("Reset error:", error);
-            await ctx.editMessageText("❌ 리셋 중 오류가 발생했습니다.");
-        }
-    });
-    // Reset 취소 버튼 콜백
-    bot.callbackQuery("reset_cancel", async (ctx) => {
-        await ctx.answerCallbackQuery({ text: "취소됨" });
-        await ctx.editMessageText("✓ 리셋이 취소되었습니다.");
+        await ctx.reply("⚠️ 정말 페르소나를 리셋할까요?\n" +
+            "모든 설정이 초기화되고 온보딩을 다시 진행합니다.\n\n" +
+            `확인하려면 /confirm_reset_${token} 을 입력하세요.\n` +
+            "(1분 후 만료)");
     });
-    // /confirm_reset_<token> 패턴 매칭 (레거시 - 텍스트 입력 지원)
+    // /confirm_reset_<token> 패턴 매칭
     bot.hears(/^\/confirm_reset_([a-f0-9]+)$/, async (ctx) => {
         const chatId = ctx.chat.id;
         const token = ctx.match[1];
@@ -147,10 +144,28 @@ export function registerCommands(bot) {
             await ctx.reply("아직 정리할 대화가 별로 없어!");
             return;
         }
-        // 최근 4개만 남기고 정리
-        const removed = history.length - 4;
-        history.splice(0, removed);
-        await ctx.reply(`대화 정리 완료! ${removed}개 메시지 압축했어.`);
+        // 현재 토큰 수 계산
+        const currentTokens = estimateMessagesTokens(history);
+        await ctx.replyWithChatAction("typing");
+        await ctx.reply(`📊 현재: ${history.length}개 메시지, ~${currentTokens} 토큰\n요약 생성 중...`);
+        // 요약할 메시지와 유지할 최근 메시지 분리
+        const recentMessages = history.slice(-4);
+        const oldMessages = history.slice(0, -4);
+        // 요약 생성
+        const summary = await generateSummary(oldMessages);
+        // 히스토리 교체: 요약 + 최근 4개
+        history.splice(0, history.length);
+        history.push({
+            role: "user",
+            content: `[이전 대화 요약]\n${summary}`
+        });
+        history.push(...recentMessages);
+        // 새 토큰 수 계산
+        const newTokens = estimateMessagesTokens(history);
+        const savedPercent = Math.round((1 - newTokens / currentTokens) * 100);
+        await ctx.reply(`✨ 대화 정리 완료!\n\n` +
+            `📉 ${currentTokens} → ${newTokens} 토큰\n` +
+            `💾 약 ${savedPercent}% 절약 (${oldMessages.length}개 → 요약 1개)`);
     });
     // /memory 명령어 - 최근 기억 보기
     bot.command("memory", async (ctx) => {

package/dist/telegram/handlers/messages.js

@@ -1,69 +1,53 @@
-import { chat } from "../../ai/claude.js";
-import { getHistory, getModel, runWithChatId, } from "../../session/state.js";
+import { chat, chatSmart } from "../../ai/claude.js";
+import { getHistory, getModel, runWithChatId, trimHistoryByTokens, } from "../../session/state.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
-import { extractUrls, fetchWebContent, buildSystemPrompt, detectSecrets, } from "../utils/index.js";
-// 채팅별 AbortController 관리 (race condition 방지)
-const chatAbortControllers = new Map();
+import { extractUrls, fetchWebContent, buildSystemPrompt, } from "../utils/index.js";
 /**
- * 이전 요청을 취소하고 새 AbortController 생성
+ * 스트리밍 응답 전송 (Telegram 메시지 실시간 업데이트)
  */
-function getNewAbortController(chatId) {
-    // 이전 요청 취소
-    const previous = chatAbortControllers.get(chatId);
-    if (previous) {
-        previous.abort();
-    }
-    // 새 controller 생성
-    const controller = new AbortController();
-    chatAbortControllers.set(chatId, controller);
-    return controller;
-}
-/**
- * 완료된 요청의 controller 정리
- */
-function cleanupAbortController(chatId, controller) {
-    // 현재 저장된 controller와 같은 경우에만 삭제 (새 요청이 없을 때)
-    if (chatAbortControllers.get(chatId) === controller) {
-        chatAbortControllers.delete(chatId);
-    }
-}
-/**
- * 모든 진행 중인 요청 취소 (shutdown 시 사용)
- */
-export function abortAllChatRequests() {
-    for (const [chatId, controller] of chatAbortControllers) {
-        controller.abort();
-    }
-    chatAbortControllers.clear();
-}
-/**
- * API 키가 포함된 메시지를 처리합니다.
- * 메시지를 삭제하고 사용자에게 경고합니다.
- * @returns true if secret was detected and handled
- */
-async function handleSecretDetection(ctx, message) {
-    const result = detectSecrets(message);
-    if (!result.detected) {
-        return false;
+async function sendStreamingResponse(ctx, messages, systemPrompt, modelId) {
+    // 1. 먼저 "..." 플레이스홀더 메시지 전송
+    const placeholder = await ctx.reply("...");
+    const chatId = ctx.chat.id;
+    const messageId = placeholder.message_id;
+    let lastUpdate = Date.now();
+    const UPDATE_INTERVAL = 500; // 0.5초마다 업데이트 (Telegram rate limit 고려)
+    let lastText = "";
+    const result = await chatSmart(messages, systemPrompt, modelId, async (_chunk, accumulated) => {
+        const now = Date.now();
+        // 0.5초마다 또는 충분히 변경되었을 때 업데이트
+        if (now - lastUpdate > UPDATE_INTERVAL && accumulated !== lastText) {
+            try {
+                await ctx.api.editMessageText(chatId, messageId, accumulated + " ▌");
+                lastUpdate = now;
+                lastText = accumulated;
+            }
+            catch {
+                // rate limit 등 무시
+            }
+        }
+    });
+    // 도구를 사용한 경우 스트리밍이 안됐으므로 새 응답 전송
+    if (result.usedTools) {
+        // placeholder 메시지를 최종 결과로 교체
+        try {
+            await ctx.api.editMessageText(chatId, messageId, result.text);
+        }
+        catch {
+            // 실패시 새 메시지로 전송
+            await ctx.api.deleteMessage(chatId, messageId);
+            await ctx.reply(result.text);
+        }
+        return result.text;
     }
-    // 원본 메시지 삭제 시도
+    // 최종 메시지 업데이트 (커서 제거)
     try {
-        if (ctx.message?.message_id) {
-            await ctx.api.deleteMessage(ctx.chat.id, ctx.message.message_id);
-        }
+        await ctx.api.editMessageText(chatId, messageId, result.text);
     }
-    catch (error) {
-        // 삭제 실패해도 계속 진행 (권한 없을 수 있음)
-        console.warn("Failed to delete message with secret:", error);
+    catch {
+        // 이미 동일 텍스트면 에러 발생 가능 - 무시
     }
-    // 경고 메시지 전송
-    const typeList = result.types.join(", ");
-    await ctx.reply(`⚠️ **API 키 감지됨!**\n\n` +
-        `방금 보낸 메시지에서 ${typeList} 키가 감지되어 삭제했어.\n\n` +
-        `🔐 API 키는 채팅에 절대 입력하면 안 돼!\n` +
-        `CLI에서 \`companionbot config\` 명령어로 안전하게 설정해줘.`, { parse_mode: "Markdown" });
-    console.log(`[Security] Blocked API key exposure: ${typeList}`);
-    return true;
+    return result.text;
 }
 /**
  * 메시지 핸들러들을 봇에 등록합니다.
@@ -72,13 +56,6 @@ export function registerMessageHandlers(bot) {
     // 사진 메시지 처리
     bot.on("message:photo", async (ctx) => {
         const chatId = ctx.chat.id;
-        const caption = ctx.message.caption || "";
-        // 캡션에서 API 키 감지
-        if (caption && await handleSecretDetection(ctx, caption)) {
-            return; // 메시지 삭제됨, 처리 중단
-        }
-        // 이전 요청 취소하고 새 controller 생성 (race condition 방지)
-        const controller = getNewAbortController(chatId);
         await runWithChatId(chatId, async () => {
             const history = getHistory(chatId);
             const modelId = getModel(chatId);
@@ -103,7 +80,7 @@ export function registerMessageHandlers(bot) {
                 const buffer = await response.arrayBuffer();
                 const base64 = Buffer.from(buffer).toString("base64");
                 // 캡션이 있으면 사용, 없으면 기본 질문
-                const photoCaption = caption || "이 사진에 뭐가 있어?";
+                const caption = ctx.message.caption || "이 사진에 뭐가 있어?";
                 // 이미지와 텍스트를 함께 전송
                 const imageContent = [
                     {
@@ -116,40 +93,28 @@ export function registerMessageHandlers(bot) {
                     },
                     {
                         type: "text",
-                        text: photoCaption,
+                        text: caption,
                     },
                 ];
                 history.push({ role: "user", content: imageContent });
-                const systemPrompt = await buildSystemPrompt(modelId);
-                const result = await chat(history, systemPrompt, modelId, { signal: controller.signal });
-                // abort된 경우 히스토리 롤백
-                if (controller.signal.aborted) {
-                    history.pop();
-                    return;
+                try {
+                    const systemPrompt = await buildSystemPrompt(modelId, history);
+                    const result = await chat(history, systemPrompt, modelId);
+                    history.push({ role: "assistant", content: result });
+                    // 토큰 기반 히스토리 트리밍
+                    trimHistoryByTokens(history);
+                    await ctx.reply(result);
                 }
-                history.push({ role: "assistant", content: result });
-                // 히스토리 제한
-                if (history.length > 20) {
-                    history.splice(0, history.length - 20);
+                catch (innerError) {
+                    // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
+                    history.pop();
+                    throw innerError;
                 }
-                await ctx.reply(result);
             }
             catch (error) {
-                // abort로 인한 에러는 무시
-                if (controller.signal.aborted) {
-                    console.log(`[Photo] Request aborted for chat ${chatId}`);
-                    // 유저 메시지 롤백 (이미 추가된 경우)
-                    if (history.length > 0 && history[history.length - 1].role === "user") {
-                        history.pop();
-                    }
-                    return;
-                }
                 console.error("Photo error:", error);
                 await ctx.reply("사진 분석 중 오류가 발생했어.");
             }
-            finally {
-                cleanupAbortController(chatId, controller);
-            }
         });
     });
     // 일반 메시지 처리
@@ -159,12 +124,6 @@ export function registerMessageHandlers(bot) {
         // 빈 메시지 무시
         if (!userMessage.trim())
             return;
-        // API 키 감지 - 히스토리에 저장하지 않고 메시지 삭제
-        if (await handleSecretDetection(ctx, userMessage)) {
-            return; // 메시지 삭제됨, 처리 중단
-        }
-        // 이전 요청 취소하고 새 controller 생성 (race condition 방지)
-        const controller = getNewAbortController(chatId);
         await runWithChatId(chatId, async () => {
             // Heartbeat 마지막 대화 시간 업데이트
             updateLastMessageTime(chatId);
@@ -191,36 +150,19 @@ export function registerMessageHandlers(bot) {
             // 사용자 메시지 추가 (URL 내용 포함)
             history.push({ role: "user", content: enrichedMessage });
             try {
-                const systemPrompt = await buildSystemPrompt(modelId);
-                const response = await chat(history, systemPrompt, modelId, { signal: controller.signal });
-                // abort된 경우 히스토리 롤백
-                if (controller.signal.aborted) {
-                    history.pop();
-                    return;
-                }
+                const systemPrompt = await buildSystemPrompt(modelId, history);
+                // 스트리밍 응답 사용 (실시간 업데이트)
+                const response = await sendStreamingResponse(ctx, history, systemPrompt, modelId);
                 history.push({ role: "assistant", content: response });
-                // 히스토리 제한 (최근 20개 메시지만 유지)
-                if (history.length > 20) {
-                    history.splice(0, history.length - 20);
-                }
-                await ctx.reply(response);
+                // 토큰 기반 히스토리 트리밍
+                trimHistoryByTokens(history);
             }
             catch (error) {
-                // abort로 인한 에러는 무시
-                if (controller.signal.aborted) {
-                    console.log(`[Chat] Request aborted for chat ${chatId}`);
-                    // 유저 메시지 롤백 (이미 추가된 경우)
-                    if (history.length > 0 && history[history.length - 1].role === "user") {
-                        history.pop();
-                    }
-                    return;
-                }
+                // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
+                history.pop();
                 console.error("Chat error:", error);
                 await ctx.reply("뭔가 잘못됐어. 다시 시도해줄래?");
             }
-            finally {
-                cleanupAbortController(chatId, controller);
-            }
         });
     });
 }

package/dist/telegram/utils/index.js

@@ -4,5 +4,3 @@ export { extractUrls, fetchWebContent, isSafeUrl } from "./url.js";
 export { buildSystemPrompt, extractName } from "./prompt.js";
 // Cache utilities
 export { getWorkspace, invalidateWorkspaceCache } from "./cache.js";
-// Secret detection utilities
-export { detectSecrets, containsSecret } from "./secrets.js";