companionbot 0.4.3 → 0.5.0

package/dist/agents/index.js

@@ -1,4 +1,4 @@
 /**
  * Sub-agent 시스템 - 복잡한 작업을 독립적인 agent에게 위임
  */
-export { setAgentBot, spawnAgent, listAgents, cancelAgent, getAgent } from "./manager.js";
+export { setAgentBot, spawnAgent, listAgents, cancelAgent, getAgent, abortAllAgents, stopCleanup } from "./manager.js";

package/dist/agents/manager.js

@@ -198,6 +198,14 @@ export function cleanupOldAgents() {
         // running 상태도 1시간 지나면 정리 (stuck agent 방지)
         if (agent.status === "running" && agent.createdAt.getTime() < oneHourAgo) {
             console.log(`[Agent ${id}] Cleaning up stuck agent (running > 1h)`);
+            // 실행 중인 API 호출 취소
+            const controller = abortControllers.get(id);
+            if (controller) {
+                controller.abort();
+                abortControllers.delete(id);
+            }
+            agent.status = "cancelled";
+            agent.completedAt = new Date();
             agents.delete(id);
         }
     }
@@ -223,5 +231,27 @@ export function stopCleanup() {
         console.log("[AgentManager] Cleanup interval stopped");
     }
 }
+/**
+ * 모든 진행 중인 agent abort 및 정리 (shutdown 시 사용)
+ */
+export function abortAllAgents() {
+    console.log("[AgentManager] Aborting all running agents...");
+    // 모든 AbortController abort
+    for (const [id, controller] of abortControllers) {
+        console.log(`[Agent ${id}] Aborting`);
+        controller.abort();
+    }
+    abortControllers.clear();
+    // 모든 running agent 상태 업데이트
+    for (const [id, agent] of agents) {
+        if (agent.status === "running") {
+            agent.status = "cancelled";
+            agent.completedAt = new Date();
+        }
+    }
+    // cleanup interval 중지
+    stopCleanup();
+    console.log("[AgentManager] All agents aborted");
+}
 // 자동 시작
 startCleanup();

package/dist/ai/claude.js

@@ -12,9 +12,10 @@ export const MODELS = {
     opus: { id: "claude-opus-4-20250514", name: "Claude Opus 4" },
     haiku: { id: "claude-haiku-3-5-20241022", name: "Claude Haiku 3.5" },
 };
-export async function chat(messages, systemPrompt, modelId = "sonnet") {
+export async function chat(messages, systemPrompt, modelId = "sonnet", options) {
     const client = getClient();
     const model = MODELS[modelId].id;
+    const signal = options?.signal;
     // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
@@ -28,7 +29,7 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
             system: systemPrompt,
             messages: apiMessages,
             tools: tools,
-        });
+        }, { signal });
     }
     catch (error) {
         if (error instanceof Anthropic.APIError) {
@@ -79,7 +80,7 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
                 system: systemPrompt,
                 messages: apiMessages,
                 tools: tools,
-            });
+            }, { signal });
         }
         catch (error) {
             if (error instanceof Anthropic.APIError) {

package/dist/cron/parser.js

@@ -130,30 +130,163 @@ export function parseCronExpression(expr) {
     };
 }
 /**
- * Calculate the next run time for a cron expression
+ * Get time components in a specific timezone using Intl API
+ */
+function getTimeInTimezone(date, timezone) {
+    try {
+        const formatter = new Intl.DateTimeFormat("en-US", {
+            timeZone: timezone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+            hour12: false,
+        });
+        const parts = formatter.formatToParts(date);
+        const getValue = (type) => parts.find((p) => p.type === type)?.value ?? "0";
+        const dayOfWeekMap = {
+            Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6,
+        };
+        return {
+            year: parseInt(getValue("year"), 10),
+            month: parseInt(getValue("month"), 10),
+            day: parseInt(getValue("day"), 10),
+            hour: parseInt(getValue("hour"), 10),
+            minute: parseInt(getValue("minute"), 10),
+            dayOfWeek: dayOfWeekMap[getValue("weekday")] ?? 0,
+        };
+    }
+    catch {
+        // Fallback to local time if timezone is invalid
+        return {
+            year: date.getFullYear(),
+            month: date.getMonth() + 1,
+            day: date.getDate(),
+            hour: date.getHours(),
+            minute: date.getMinutes(),
+            dayOfWeek: date.getDay(),
+        };
+    }
+}
+/**
+ * Create a Date object for a specific time in a timezone
+ */
+function createDateInTimezone(year, month, day, hour, minute, timezone) {
+    try {
+        const dateStr = `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}T${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}:00`;
+        const formatter = new Intl.DateTimeFormat("en-US", {
+            timeZone: timezone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+        // Binary search for the correct UTC time
+        let guess = new Date(dateStr);
+        for (let i = 0; i < 3; i++) {
+            const parts = formatter.formatToParts(guess);
+            const getValue = (type) => parseInt(parts.find((p) => p.type === type)?.value ?? "0", 10);
+            const guessHour = getValue("hour");
+            const guessMinute = getValue("minute");
+            const guessDay = getValue("day");
+            let diffMinutes = (hour - guessHour) * 60 + (minute - guessMinute);
+            if (day !== guessDay) {
+                if (day > guessDay || (day === 1 && guessDay > 20)) {
+                    diffMinutes += 24 * 60;
+                }
+                else {
+                    diffMinutes -= 24 * 60;
+                }
+            }
+            if (diffMinutes === 0)
+                break;
+            guess = new Date(guess.getTime() + diffMinutes * 60 * 1000);
+        }
+        return guess;
+    }
+    catch {
+        return new Date(year, month - 1, day, hour, minute, 0, 0);
+    }
+}
+/**
+ * Get number of days in a month
+ */
+function getDaysInMonth(year, month) {
+    return new Date(year, month, 0).getDate();
+}
+/**
+ * Calculate the next run time for a cron expression with timezone support
  */
 export function getNextCronRun(expression, fromDate = new Date(), timezone) {
     const parsed = parseCronExpression(expression);
-    const from = new Date(fromDate);
-    // Start from the next minute
-    from.setSeconds(0);
-    from.setMilliseconds(0);
-    from.setMinutes(from.getMinutes() + 1);
-    // Search for the next matching time (max 2 years ahead)
-    const maxIterations = 365 * 24 * 60 * 2; // 2 years in minutes
+    const now = fromDate;
+    const tz = timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    // Get current time in target timezone
+    const current = getTimeInTimezone(now, tz);
+    // Search for next valid time (up to 366 days ahead)
+    const searchDate = { ...current };
+    const maxIterations = 366 * 24 * 60;
     for (let i = 0; i < maxIterations; i++) {
-        const candidate = new Date(from.getTime() + i * 60000);
-        const minute = candidate.getMinutes();
-        const hour = candidate.getHours();
-        const dayOfMonth = candidate.getDate();
-        const month = candidate.getMonth() + 1;
-        const dayOfWeek = candidate.getDay();
-        if (parsed.minute.values.includes(minute) &&
-            parsed.hour.values.includes(hour) &&
-            parsed.month.values.includes(month) &&
-            (parsed.dayOfMonth.values.includes(dayOfMonth) ||
-                parsed.dayOfWeek.values.includes(dayOfWeek))) {
-            return candidate;
+        // Advance by one minute each iteration
+        if (i > 0) {
+            searchDate.minute++;
+            if (searchDate.minute > 59) {
+                searchDate.minute = 0;
+                searchDate.hour++;
+                if (searchDate.hour > 23) {
+                    searchDate.hour = 0;
+                    searchDate.day++;
+                    searchDate.dayOfWeek = (searchDate.dayOfWeek + 1) % 7;
+                    const daysInMonth = getDaysInMonth(searchDate.year, searchDate.month);
+                    if (searchDate.day > daysInMonth) {
+                        searchDate.day = 1;
+                        searchDate.month++;
+                        if (searchDate.month > 12) {
+                            searchDate.month = 1;
+                            searchDate.year++;
+                        }
+                    }
+                }
+            }
+        }
+        // Check if this time matches all constraints
+        if (!parsed.month.values.includes(searchDate.month))
+            continue;
+        // For dayOfMonth and dayOfWeek: if both are restricted, match either (OR logic)
+        // If only one is restricted, use that one
+        const domRestricted = parsed.dayOfMonth.type !== "wildcard";
+        const dowRestricted = parsed.dayOfWeek.type !== "wildcard";
+        if (domRestricted && dowRestricted) {
+            // Both restricted: match either
+            if (!parsed.dayOfMonth.values.includes(searchDate.day) &&
+                !parsed.dayOfWeek.values.includes(searchDate.dayOfWeek)) {
+                continue;
+            }
+        }
+        else if (domRestricted) {
+            if (!parsed.dayOfMonth.values.includes(searchDate.day))
+                continue;
+        }
+        else if (dowRestricted) {
+            if (!parsed.dayOfWeek.values.includes(searchDate.dayOfWeek))
+                continue;
+        }
+        if (!parsed.hour.values.includes(searchDate.hour))
+            continue;
+        if (!parsed.minute.values.includes(searchDate.minute))
+            continue;
+        // Skip if this is the current minute (must be in the future)
+        if (i === 0)
+            continue;
+        // Create the date in the target timezone
+        const nextRun = createDateInTimezone(searchDate.year, searchDate.month, searchDate.day, searchDate.hour, searchDate.minute, tz);
+        // Verify it's in the future
+        if (nextRun > now) {
+            return nextRun;
         }
     }
     throw new Error(`Could not find next run time for: ${expression}`);

package/dist/cron/scheduler.js

@@ -7,6 +7,7 @@
 import { getDueJobs, markJobExecuted, loadJobs, addJob, removeJob, updateJob, getJobsByChat } from "./store.js";
 import { chat } from "../ai/claude.js";
 import { buildSystemPrompt } from "../telegram/utils/prompt.js";
+import { runWithChatId } from "../session/state.js";
 // Scheduler state
 let schedulerInterval = null;
 let botInstance = null;
@@ -145,7 +146,8 @@ async function executeSystemEvent(job, payload, bot) {
  */
 async function executeAgentTurn(job, payload, bot) {
     const { message: inputMessage, context } = payload;
-    try {
+    // Wrap in runWithChatId so tools can access chatId via getCurrentChatId()
+    const response = await runWithChatId(job.chatId, async () => {
         // Build a fresh conversation for this job (separate from main chat)
         const messages = [
             {
@@ -165,8 +167,10 @@ async function executeAgentTurn(job, payload, bot) {
 - Run Count: ${(job.runCount || 0) + 1}
 - This is a scheduled task, not a direct user message.`;
         // Call Claude API
-        const response = await chat(messages, systemPrompt, "sonnet");
-        // Send the response to the chat
+        return await chat(messages, systemPrompt, "sonnet");
+    });
+    // Send the response to the chat
+    try {
         if (response && response.trim()) {
             // Split long messages (Telegram limit is 4096 characters)
             const maxLength = 4000;

package/dist/heartbeat/index.js

@@ -4,6 +4,7 @@ import { getWorkspacePath } from "../workspace/index.js";
 import { chat } from "../ai/claude.js";
 import { isCalendarConfigured, getTodayEvents, formatEvent } from "../calendar/index.js";
 import { getSecret } from "../config/secrets.js";
+import { runWithChatId } from "../session/state.js";
 // 활성 타이머
 const activeTimers = new Map();
 // 메모리 캐시: 타임스탬프는 메모리에만 유지하여 파일 쓰기 최소화
@@ -120,7 +121,10 @@ ${context}
     ];
     let messageSent = false;
     try {
-        const response = await chat(messages, systemPrompt, "haiku");
+        // Wrap in runWithChatId so tools can access chatId via getCurrentChatId()
+        const response = await runWithChatId(config.chatId, async () => {
+            return await chat(messages, systemPrompt, "haiku");
+        });
         if (!response.trim().includes("HEARTBEAT_OK")) {
             await botInstance.api.sendMessage(config.chatId, response);
             console.log(`[Heartbeat] Sent message to ${config.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분에 10개 메시지
+    // Rate limiting - 1분에 20개 메시지
     bot.use(limit({
         timeFrame: 60000, // 1분
-        limit: 10,
+        limit: 20,
         onLimitExceeded: async (ctx) => {
-            await ctx.reply("⚠️ 너무 빠르게 메시지를 보내고 있어요. 잠시 후 다시 시도해주세요.");
+            await ctx.reply("⚠️ 너무 빠르게 메시지를 보내고 있어요. 30초 후 다시 시도해주세요.");
         },
     }));
     // 에러 핸들링

package/dist/telegram/handlers/commands.js

@@ -1,3 +1,4 @@
+import { InlineKeyboard } from "grammy";
 import { randomBytes } from "crypto";
 import { chat, MODELS } from "../../ai/claude.js";
 // Reset 토큰 관리 (1분 만료)
@@ -74,16 +75,48 @@ export function registerCommands(bot) {
                 `/reset - 페르소나 리셋`);
         }
     });
-    // /reset 명령어 - 페르소나 리셋 (토큰 기반)
+    // /reset 명령어 - 페르소나 리셋 (인라인 버튼 + 토큰 기반)
     bot.command("reset", async (ctx) => {
         const chatId = ctx.chat.id;
         const token = generateResetToken(chatId);
-        await ctx.reply("⚠️ 정말 페르소나를 리셋할까요?\n" +
-            "모든 설정이 초기화되고 온보딩을 다시 진행합니다.\n\n" +
-            `확인하려면 /confirm_reset_${token} 을 입력하세요.\n` +
-            "(1분 후 만료)");
+        const keyboard = new InlineKeyboard()
+            .text("✅ 예, 리셋합니다", `reset_confirm_${token}`)
+            .text("❌ 취소", "reset_cancel");
+        await ctx.reply("⚠️ 정말 페르소나를 리셋할까요?\n\n" +
+            "모든 설정이 초기화되고 온보딩을 다시 진행합니다.\n" +
+            "(1분 후 버튼 만료)", { reply_markup: keyboard });
     });
-    // /confirm_reset_<token> 패턴 매칭
+    // 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("✓ 리셋이 취소되었습니다.");
+    });
+    // /confirm_reset_<token> 패턴 매칭 (레거시 - 텍스트 입력 지원)
     bot.hears(/^\/confirm_reset_([a-f0-9]+)$/, async (ctx) => {
         const chatId = ctx.chat.id;
         const token = ctx.match[1];

package/dist/telegram/handlers/messages.js

@@ -1,7 +1,70 @@
 import { chat } from "../../ai/claude.js";
 import { getHistory, getModel, runWithChatId, } from "../../session/state.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
-import { extractUrls, fetchWebContent, buildSystemPrompt, } from "../utils/index.js";
+import { extractUrls, fetchWebContent, buildSystemPrompt, detectSecrets, } from "../utils/index.js";
+// 채팅별 AbortController 관리 (race condition 방지)
+const chatAbortControllers = new Map();
+/**
+ * 이전 요청을 취소하고 새 AbortController 생성
+ */
+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;
+    }
+    // 원본 메시지 삭제 시도
+    try {
+        if (ctx.message?.message_id) {
+            await ctx.api.deleteMessage(ctx.chat.id, ctx.message.message_id);
+        }
+    }
+    catch (error) {
+        // 삭제 실패해도 계속 진행 (권한 없을 수 있음)
+        console.warn("Failed to delete message with secret:", error);
+    }
+    // 경고 메시지 전송
+    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;
+}
 /**
  * 메시지 핸들러들을 봇에 등록합니다.
  */
@@ -9,6 +72,13 @@ 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);
@@ -33,7 +103,7 @@ export function registerMessageHandlers(bot) {
                 const buffer = await response.arrayBuffer();
                 const base64 = Buffer.from(buffer).toString("base64");
                 // 캡션이 있으면 사용, 없으면 기본 질문
-                const caption = ctx.message.caption || "이 사진에 뭐가 있어?";
+                const photoCaption = caption || "이 사진에 뭐가 있어?";
                 // 이미지와 텍스트를 함께 전송
                 const imageContent = [
                     {
@@ -46,12 +116,17 @@ export function registerMessageHandlers(bot) {
                     },
                     {
                         type: "text",
-                        text: caption,
+                        text: photoCaption,
                     },
                 ];
                 history.push({ role: "user", content: imageContent });
                 const systemPrompt = await buildSystemPrompt(modelId);
-                const result = await chat(history, systemPrompt, modelId);
+                const result = await chat(history, systemPrompt, modelId, { signal: controller.signal });
+                // abort된 경우 히스토리 롤백
+                if (controller.signal.aborted) {
+                    history.pop();
+                    return;
+                }
                 history.push({ role: "assistant", content: result });
                 // 히스토리 제한
                 if (history.length > 20) {
@@ -60,9 +135,21 @@ export function registerMessageHandlers(bot) {
                 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);
+            }
         });
     });
     // 일반 메시지 처리
@@ -72,6 +159,12 @@ 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);
@@ -99,7 +192,12 @@ export function registerMessageHandlers(bot) {
             history.push({ role: "user", content: enrichedMessage });
             try {
                 const systemPrompt = await buildSystemPrompt(modelId);
-                const response = await chat(history, systemPrompt, modelId);
+                const response = await chat(history, systemPrompt, modelId, { signal: controller.signal });
+                // abort된 경우 히스토리 롤백
+                if (controller.signal.aborted) {
+                    history.pop();
+                    return;
+                }
                 history.push({ role: "assistant", content: response });
                 // 히스토리 제한 (최근 20개 메시지만 유지)
                 if (history.length > 20) {
@@ -108,9 +206,21 @@ export function registerMessageHandlers(bot) {
                 await ctx.reply(response);
             }
             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;
+                }
                 console.error("Chat error:", error);
                 await ctx.reply("뭔가 잘못됐어. 다시 시도해줄래?");
             }
+            finally {
+                cleanupAbortController(chatId, controller);
+            }
         });
     });
 }

package/dist/telegram/utils/index.js

@@ -4,3 +4,5 @@ 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";

package/dist/telegram/utils/prompt.js

@@ -53,18 +53,21 @@ export async function buildSystemPrompt(modelId) {
             parts.push("---");
             parts.push(workspace.agents);
         }
-        // 최근 기억 로드
+        // 장기 기억 (MEMORY.md) - 먼저 로드하여 중요한 맥락 제공
+        if (workspace.memory) {
+            parts.push("---");
+            parts.push("# 장기 기억 (MEMORY.md)");
+            parts.push("이것은 사용자와의 관계, 중요한 정보, 누적된 맥락입니다. 대화할 때 항상 참고하세요.");
+            parts.push(workspace.memory);
+        }
+        // 최근 일일 기억 로드 (오늘과 어제 우선)
         const recentMemories = await loadRecentMemories(3);
         if (recentMemories.trim()) {
             parts.push("---");
-            parts.push("# 최근 기억");
+            parts.push("# 최근 일일 기록");
+            parts.push("최근 대화와 활동 기록입니다. '오늘'과 '어제'의 맥락을 파악하는 데 활용하세요.");
             parts.push(recentMemories);
         }
-        if (workspace.memory) {
-            parts.push("---");
-            parts.push("# 장기 기억");
-            parts.push(workspace.memory);
-        }
     }
     // 도구 설명
     parts.push("---");