@haenah/u1z 0.1.0

package/src/discord/handlers/messageCreate.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import { splitMessage } from "./messageCreate";
+
+describe("splitMessage", () => {
+  test("2000자 이하면 그대로 반환", () => {
+    const text = "a".repeat(2000);
+    expect(splitMessage(text)).toEqual([text]);
+  });
+
+  test("2001자면 2개로 분할", () => {
+    const text = "a".repeat(2001);
+    const chunks = splitMessage(text);
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0]).toHaveLength(2000);
+    expect(chunks[1]).toHaveLength(1);
+  });
+
+  test("newline 경계에서 분할", () => {
+    const line = "a".repeat(1999);
+    const text = `${line}\n${"b".repeat(10)}`;
+    const chunks = splitMessage(text);
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0]).toBe(line);
+    expect(chunks[1]).toBe("b".repeat(10));
+  });
+
+  test("newline이 없으면 2000자에서 강제 컷", () => {
+    const text = "a".repeat(3000);
+    const chunks = splitMessage(text);
+    expect(chunks).toHaveLength(2);
+    expect(chunks[0]).toHaveLength(2000);
+    expect(chunks[1]).toHaveLength(1000);
+  });
+
+  test("여러 청크로 분할", () => {
+    const text = "a".repeat(5000);
+    const chunks = splitMessage(text);
+    for (const chunk of chunks) expect(chunk.length).toBeLessThanOrEqual(2000);
+    expect(chunks.join("")).toBe(text);
+  });
+
+  test("newline이 포함된 여러 청크", () => {
+    const line = "a".repeat(500);
+    const text = Array.from({ length: 10 }, () => line).join("\n");
+    const chunks = splitMessage(text);
+    for (const chunk of chunks) expect(chunk.length).toBeLessThanOrEqual(2000);
+    expect(chunks.join("\n")).toBe(text);
+  });
+});

package/src/discord/handlers/messageCreate.ts

@@ -0,0 +1,180 @@
+import { APICallError, generateText, type ModelMessage, stepCountIs } from "ai";
+import type { Message } from "discord.js";
+import { MODELS } from "@/ai/llm/model";
+import { analyzeYoutube } from "@/ai/llm/tools/analyzeYoutube";
+import { bash } from "@/ai/llm/tools/bash";
+import { textEditor } from "@/ai/llm/tools/textEditor";
+import { webFetch } from "@/ai/llm/tools/webFetch";
+import { webSearch } from "@/ai/llm/tools/webSearch";
+import type { Usage } from "@/conversation/conversation";
+import { conversationManager } from "@/conversation/manager";
+
+import { compactMemories } from "@/memory/compress";
+import type { MemoryScope } from "@/memory/types";
+
+const DISCORD_MAX_LENGTH = 2000;
+const IS_E2E = process.env.IS_E2E === "true";
+
+/**
+ * 디스코는 메세지당 최대 2000자까지만 허용하므로, 이를 초과하는 경우 여러 메세지로 나누어 전송한다.
+ */
+export function splitMessage(text: string): string[] {
+  if (text.length <= DISCORD_MAX_LENGTH) return [text];
+  const chunks: string[] = [];
+  let remaining = text;
+  while (remaining.length > DISCORD_MAX_LENGTH) {
+    const slice = remaining.slice(0, DISCORD_MAX_LENGTH);
+    const lastNewline = slice.lastIndexOf("\n");
+    const cut = lastNewline > 0 ? lastNewline : DISCORD_MAX_LENGTH;
+    chunks.push(remaining.slice(0, cut));
+    remaining = remaining.slice(lastNewline > 0 ? lastNewline + 1 : DISCORD_MAX_LENGTH);
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}
+
+const ALLOWED_BOT_IDS = (process.env.DISCORD_ALLOWED_BOT_IDS ?? "")
+  .split(",")
+  .map((id) => id.trim())
+  .filter(Boolean);
+
+function toModelMessage(message: Message, botId: string, isDM: boolean): ModelMessage | null {
+  const content = isDM
+    ? message.content
+    : message.content.replace(new RegExp(`^<@!?${botId}>\\s*`), "").trim();
+
+  if (!content) return null;
+
+  if (message.author.id === botId) return { role: "assistant", content };
+
+  if (message.author.bot && !ALLOWED_BOT_IDS.includes(message.author.id)) return null;
+
+  if (isDM) return { role: "user", content };
+
+  const displayName =
+    message.member?.displayName ?? message.author.displayName ?? message.author.username;
+  return { role: "user", content: `[${displayName}]: ${content}` };
+}
+
+export async function handleMessageCreate(message: Message): Promise<void> {
+  if (message.system) return;
+
+  const botId = message.client.user?.id;
+  if (!botId) {
+    console.error("[Discord] Client user is not ready");
+    return;
+  }
+
+  if (message.author.id === botId) return;
+
+  if (message.author.bot && !ALLOWED_BOT_IDS.includes(message.author.id)) return;
+
+  const isDM = message.channel.isDMBased();
+  if (!isDM && !message.mentions.has(botId)) return;
+
+  if (!message.content.trim()) return;
+
+  try {
+    if ("sendTyping" in message.channel) await message.channel.sendTyping();
+
+    const scope: MemoryScope = isDM
+      ? { kind: "user", userId: message.author.id }
+      : { kind: "channel", channelId: message.channelId };
+
+    // 만료된 Conversation이 있으면 먼저 요약 저장 후 새 대화 시작
+    const expiredConversation = conversationManager.getIfExpired(message.channelId);
+    if (expiredConversation) {
+      const [memorizeResult, compactResult] = await Promise.allSettled([
+        expiredConversation.memorize(),
+        compactMemories(expiredConversation.scope),
+      ]);
+      if (memorizeResult.status === "rejected")
+        console.error(
+          "[Memorize] 요약 실패:",
+          memorizeResult.reason instanceof Error
+            ? memorizeResult.reason.message
+            : String(memorizeResult.reason),
+        );
+      if (compactResult.status === "rejected")
+        console.error(
+          "[Compress] 압축 실패:",
+          compactResult.reason instanceof Error
+            ? compactResult.reason.message
+            : String(compactResult.reason),
+        );
+    }
+
+    const { conversation } = await conversationManager.getOrCreate(
+      message.channelId,
+      MODELS.md,
+      scope,
+      !isDM
+        ? "# Important Notes\n사용자 메시지는 `[표시 이름]: 내용` 형식으로 전달됩니다. 대괄호 안은 메시지를 보낸 Discord 사용자의 표시 이름입니다."
+        : undefined,
+    );
+
+    const userMessage = toModelMessage(message, botId, isDM);
+    if (!userMessage) return;
+    conversation.addMessage(userMessage);
+    conversation.touch();
+
+    const { text, usage, response } = await generateText({
+      model: conversation.model,
+      system: conversation.systemPrompt,
+      messages: conversation.getMessages(),
+      maxOutputTokens: 1024,
+      timeout: 300_000,
+      tools: {
+        bash,
+        text_editor: textEditor,
+        web_search: webSearch,
+        web_fetch: webFetch,
+        analyze_youtube: analyzeYoutube,
+      },
+      stopWhen: stepCountIs(20),
+      onStepFinish: async (step) => {
+        if (step.finishReason === "stop" || IS_E2E) return;
+        const ch = message.channel;
+        if (ch && step.text)
+          for (const chunk of splitMessage(step.text)) await message.reply(chunk);
+        if (ch && "sendTyping" in ch) await ch.sendTyping();
+      },
+    });
+
+    const normalizedUsage: Usage = {
+      inputTokens: usage.inputTokens ?? 0,
+      outputTokens: usage.outputTokens ?? 0,
+      cacheReadTokens: usage.inputTokenDetails?.cacheReadTokens ?? 0,
+      cacheWriteTokens: usage.inputTokenDetails?.cacheWriteTokens ?? 0,
+    };
+    conversation.accumulateUsage(normalizedUsage);
+    conversation.touch();
+    for (const msg of response.messages) {
+      conversation.addMessage(msg as ModelMessage);
+    }
+
+    if (text) {
+      const chunks = IS_E2E ? [text] : splitMessage(text);
+      for (const chunk of chunks) await message.reply(chunk);
+    }
+  } catch (error: unknown) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`[Discord] LLM reply failed: ${errorMessage}`);
+
+    const isTimeout =
+      error instanceof Error &&
+      (error.name === "AbortError" ||
+        error.message.includes("timed out") ||
+        error.message.includes("operation timed out"));
+    if (isTimeout) {
+      await message.reply("응답이 지연되고 있어요. 잠시 후 다시 시도해 주세요.");
+      return;
+    }
+    if (APICallError.isInstance(error) && error.statusCode === 429) {
+      await message.reply("이용 한도가 있어서 잠시 후 다시 말걸어 주세요.");
+      return;
+    }
+
+    await message.reply("일시적인 오류가 발생했어요. 잠시 후 다시 시도해 주세요.");
+  }
+}

package/src/discord/index.ts

@@ -0,0 +1,49 @@
+import { Conversation } from "@/conversation/conversation";
+import { conversationManager } from "@/conversation/manager";
+import { ConversationStore } from "@/db/conversationStore";
+import { getDb, runMigrations } from "@/db/index";
+import { client } from "./client";
+import { handleInteractionCreate, SLASH_COMMANDS } from "./handlers/interactionCreate";
+import { handleMessageCreate } from "./handlers/messageCreate";
+
+client.once("clientReady", async (c) => {
+  console.log(`[Discord] Bot ready: ${c.user.tag}`);
+  await c.application.commands.set(SLASH_COMMANDS);
+  console.log("[Discord] Slash commands registered");
+});
+client.on("messageCreate", handleMessageCreate);
+client.on("interactionCreate", handleInteractionCreate);
+
+export async function startDiscord(): Promise<void> {
+  // DB 초기화
+  runMigrations();
+  const store = new ConversationStore(getDb());
+  conversationManager.init(store);
+
+  const threshold = Date.now() - Conversation.TTL_MS;
+
+  // 1. 만료된 미완료 conversations 메모리 재시도
+  const pending = store.loadPendingMemorize(threshold);
+  if (pending.length > 0) console.log(`[Startup] Pending memorize 재시도: ${pending.length}건`);
+  for (const { conversation: row, messages } of pending) {
+    try {
+      await Conversation.fromRow(row, messages, store).memorize();
+    } catch (err) {
+      console.error("[Startup] Memorize 재시도 실패:", row.id, err);
+    }
+  }
+
+  // 2. 활성 conversations 복구
+  const activeData = store.loadActive(threshold);
+  console.log(`[Startup] Active conversations 복구: ${activeData.length}건`);
+  conversationManager.recoverFrom(activeData);
+
+  try {
+    await client.login(process.env.DISCORD_BOT_TOKEN);
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to login Discord bot: ${message}`);
+  }
+}
+
+export { client };

package/src/discord/systemPrompt.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { buildMemoryXml } from "@/conversation/systemPrompt";
+
+describe("buildMemoryXml", () => {
+  test("모두 비어있으면 빈 문자열 반환", () => {
+    expect(buildMemoryXml("", [])).toBe("");
+  });
+
+  test("globalMemory만 있을 때", () => {
+    const result = buildMemoryXml("전역 기억", []);
+    expect(result).toBe("<Memories>\n<Shared Memory>\n전역 기억\n</Shared Memory>\n</Memories>");
+  });
+
+  test("memories만 있을 때", () => {
+    const result = buildMemoryXml("", [{ date: "260226", content: "기억" }]);
+    expect(result).toBe("<Memories>\n<Memory at 260226>\n기억\n</Memory at 260226>\n</Memories>");
+  });
+
+  test("전체 조합 — 순서 확인", () => {
+    const result = buildMemoryXml("전역", [
+      { date: "260225", content: "이틀 전" },
+      { date: "260226", content: "어제" },
+    ]);
+    expect(result).toContain("<Shared Memory>");
+    expect(result).toContain("<Memory at 260225>");
+    expect(result).toContain("<Memory at 260226>");
+    expect(result.indexOf("<Shared Memory>")).toBeLessThan(result.indexOf("<Memory at 260225>"));
+    expect(result.indexOf("<Memory at 260225>")).toBeLessThan(result.indexOf("<Memory at 260226>"));
+  });
+});

package/src/env.d.ts

@@ -0,0 +1,28 @@
+export {};
+
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      /** OpenAI API key used by the default LLM model (gpt-5.2). */
+      OPENAI_API_KEY: string;
+      /** Google Generative AI API key used by the lightweight model (Gemini3 Flash). */
+      GOOGLE_GENERATIVE_AI_API_KEY: string;
+      /** Comma-separated bot user IDs that are allowed as history/context inputs. */
+      DISCORD_ALLOWED_BOT_IDS?: string;
+      /** Discord bot token used to login via discord.js. */
+      DISCORD_BOT_TOKEN: string;
+      /** Conversation TTL in milliseconds. Defaults to 3600000 (1 hour). Useful for e2e tests. */
+      CONVERSATION_TTL_MS?: `${number}`;
+      /** Memory compression threshold in KB. Defaults to 20. Useful for e2e tests. */
+      MEMORY_COMPRESS_THRESHOLD_KB?: `${number}`;
+      /** HTTP server port as a numeric string. */
+      PORT?: `${number}`;
+      /** Home directory for u1z runtime. */
+      U1Z_HOME: string;
+      /** Tavily API key for web_search and web_fetch tools. */
+      TAVILY_API_KEY: string;
+      /** Set to "true" in e2e test environments to suppress intermediate step replies. */
+      IS_E2E?: string;
+    }
+  }
+}

package/src/memory/compress.ts

@@ -0,0 +1,102 @@
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { generateText } from "ai";
+import mustache from "mustache";
+import { MODELS } from "@/ai/llm/model";
+import { listMemoryFiles, resolveScopeDir } from "@/memory/index";
+import type { MemoryScope } from "@/memory/types";
+
+/** YYMMDD → "YYYY년 MM월 DD일" */
+function yymmddToKorean(yymmdd: string): string {
+  // 첫 6자리만 사용 (range 파일 start date)
+  const yy = yymmdd.slice(0, 2);
+  const mm = yymmdd.slice(2, 4);
+  const dd = yymmdd.slice(4, 6);
+  const year = Number(yy) + 2000;
+  return `${year}년 ${mm}월 ${dd}일`;
+}
+
+/** 파일명에서 start date(YYMMDD) 추출 — range 파일이면 ~이전 부분 */
+function startDate(fileName: string): string {
+  return fileName.replace(".txt", "").split("~")[0];
+}
+
+/** 파일명에서 end date(YYMMDD) 추출 — range 파일이면 ~이후 부분, 단순 파일이면 그대로 */
+function endDate(fileName: string): string {
+  const base = fileName.replace(".txt", "");
+  const parts = base.split("~");
+  return parts[parts.length - 1];
+}
+
+/**
+ * 해당 scope의 메모리 파일 총량이 임계값을 초과하면
+ * 오래된 순으로 50% 분량을 LLM으로 압축하여 range 파일로 저장한다.
+ */
+export async function compactMemories(scope: MemoryScope): Promise<void> {
+  const thresholdKb = Number(process.env.MEMORY_COMPRESS_THRESHOLD_KB ?? 20);
+  const thresholdBytes = thresholdKb * 1024;
+
+  const files = await listMemoryFiles(scope);
+  const totalBytes = files.reduce((sum, f) => sum + f.size, 0);
+
+  if (totalBytes <= thresholdBytes) return;
+
+  // 오래된 순으로 총량의 50%를 초과하는 시점까지 압축 대상 수집
+  const half = totalBytes / 2;
+  let accumulated = 0;
+  const targets: typeof files = [];
+  for (const f of files) {
+    targets.push(f);
+    accumulated += f.size;
+    if (accumulated > half) break;
+  }
+
+  if (targets.length === 0) return;
+
+  const dreamPath = join(process.env.U1Z_HOME, ".u1z", "prompt", "DREAM.md");
+  const dreamFile = Bun.file(dreamPath);
+  if (!(await dreamFile.exists())) return;
+  const rawPrompt = (await dreamFile.text()).trim();
+  if (!rawPrompt) return;
+
+  const dir = resolveScopeDir(scope);
+
+  // 압축 대상 파일 내용 합치기
+  const contents = await Promise.all(
+    targets.map(async (f) => Bun.file(join(dir, f.fileName)).text()),
+  );
+  const combinedContent = contents.join("\n\n");
+
+  // range 파일명 계산
+  const rangeStart = startDate(targets[0].fileName);
+  const rangeEnd = endDate(targets[targets.length - 1].fileName);
+  const rangeFileName =
+    rangeStart === rangeEnd ? `${rangeStart}.txt` : `${rangeStart}~${rangeEnd}.txt`;
+
+  // mustache 치환
+  const renderedPrompt = mustache.render(rawPrompt, {
+    memory_start_kokr: yymmddToKorean(rangeStart),
+    memory_end_kokr: yymmddToKorean(rangeEnd),
+  });
+
+  const { text } = await generateText({
+    model: MODELS.sm,
+    system: renderedPrompt,
+    messages: [{ role: "user", content: combinedContent }],
+  });
+
+  if (!text.trim()) return;
+
+  // range 파일 저장
+  await Bun.write(join(dir, rangeFileName), text.trim());
+
+  // 원본 파일 삭제 (range 파일명과 다른 경우만)
+  await Promise.all(
+    targets.filter((f) => f.fileName !== rangeFileName).map((f) => unlink(join(dir, f.fileName))),
+  );
+
+  const scopeLabel = scope.kind === "user" ? `user:${scope.userId}` : `channel:${scope.channelId}`;
+  console.log(
+    `[Compress] 압축 완료 (scope: ${scopeLabel}, ${targets.length}개 → ${rangeFileName})`,
+  );
+}

package/src/memory/index.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { appendMemory, readGlobalMemory, readMemory } from "./index";
+import type { MemoryScope } from "./types";
+
+const user: MemoryScope = { kind: "user", userId: "u123" };
+const channel: MemoryScope = { kind: "channel", channelId: "c456" };
+const tr = { start: new Date("2026-02-01T00:00:00Z"), end: new Date("2026-02-28T00:00:00Z") };
+
+let tmpDir: string;
+const origU1zHome = process.env.U1Z_HOME;
+
+beforeEach(async () => {
+  tmpDir = await mkdtemp(join(tmpdir(), "u1z-mem-test-"));
+  process.env.U1Z_HOME = tmpDir;
+});
+
+afterEach(async () => {
+  process.env.U1Z_HOME = origU1zHome;
+  await rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("readGlobalMemory", () => {
+  test("MEMORY.txt 없으면 빈 문자열 반환", async () => {
+    expect(await readGlobalMemory()).toBe("");
+  });
+
+  test("MEMORY.txt 있으면 내용 반환", async () => {
+    const memDir = join(tmpDir, ".u1z", "memory");
+    await Bun.write(join(memDir, "MEMORY.txt"), "전역 기억");
+    expect(await readGlobalMemory()).toBe("전역 기억");
+  });
+});
+
+describe("readMemory", () => {
+  test("파일이 없으면 빈 배열 반환", async () => {
+    expect(await readMemory(user)).toEqual([]);
+  });
+
+  test("기억 파일 내용 반환", async () => {
+    await appendMemory(user, "단기 기억 A", tr);
+    const result = await readMemory(user);
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toContain("단기 기억 A");
+  });
+
+  test("scope 격리 — 채널 A 내용이 채널 B에 포함되지 않음", async () => {
+    const chA: MemoryScope = { kind: "channel", channelId: "ch-a" };
+    const chB: MemoryScope = { kind: "channel", channelId: "ch-b" };
+    await appendMemory(chA, "채널 A 전용 기억", tr);
+    expect(await readMemory(chB)).toEqual([]);
+  });
+
+  test("scope 격리 — user 기억이 channel에 포함되지 않음", async () => {
+    await appendMemory(user, "유저 전용 기억", tr);
+    expect(await readMemory(channel)).toEqual([]);
+  });
+
+  test("scope 격리 — user A 기억이 user B에 포함되지 않음", async () => {
+    const userA: MemoryScope = { kind: "user", userId: "u-a" };
+    const userB: MemoryScope = { kind: "user", userId: "u-b" };
+    await appendMemory(userA, "유저 A 전용 기억", tr);
+    expect(await readMemory(userB)).toEqual([]);
+  });
+});
+
+describe("appendMemory", () => {
+  test("두 번 호출하면 같은 파일에 누적", async () => {
+    await appendMemory(user, "첫 번째", tr);
+    await appendMemory(user, "두 번째", tr);
+    const result = await readMemory(user);
+    expect(result).toHaveLength(1);
+    expect(result[0].content).toContain("첫 번째");
+    expect(result[0].content).toContain("두 번째");
+  });
+
+  test("날짜 형식이 YYMMDD 6자리", async () => {
+    await appendMemory(user, "기억", tr);
+    const result = await readMemory(user);
+    expect(result[0].date).toMatch(/^\d{6}$/);
+  });
+});

package/src/memory/index.ts

@@ -0,0 +1,103 @@
+import { mkdir, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { MemoryScope } from "./types";
+
+export type { MemoryScope };
+
+function resolveMemoryRoot(): string {
+  return join(process.env.U1Z_HOME, ".u1z", "memory");
+}
+
+function scopeDir(root: string, scope: MemoryScope): string {
+  switch (scope.kind) {
+    case "user":
+      return join(root, "user", scope.userId);
+    case "channel":
+      return join(root, "channel", scope.channelId);
+  }
+}
+
+function toYYMMDD(date: Date): string {
+  const yy = String(date.getFullYear()).slice(-2);
+  const mm = String(date.getMonth() + 1).padStart(2, "0");
+  const dd = String(date.getDate()).padStart(2, "0");
+  return `${yy}${mm}${dd}`;
+}
+
+async function readFileIfExists(filePath: string): Promise<string> {
+  const file = Bun.file(filePath);
+  if (!(await file.exists())) return "";
+  return (await file.text()).trim();
+}
+
+export function resolveScopeDir(scope: MemoryScope): string {
+  return scopeDir(resolveMemoryRoot(), scope);
+}
+
+async function listScopedFiles(scope: MemoryScope): Promise<{ dir: string; files: string[] }> {
+  const dir = resolveScopeDir(scope);
+  let entries: string[] = [];
+  try {
+    entries = await readdir(dir);
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+  }
+  return { dir, files: entries.filter((f) => /^\d{6}(~\d{6})?\.txt$/.test(f)).sort() };
+}
+
+export type MemoryData = { date: string; content: string };
+
+export async function readMemory(scope: MemoryScope): Promise<MemoryData[]> {
+  const { dir, files } = await listScopedFiles(scope);
+  const memories: MemoryData[] = [];
+  for (const fileName of files) {
+    const content = await readFileIfExists(join(dir, fileName));
+    if (content) memories.push({ date: fileName.replace(".txt", ""), content });
+  }
+  return memories;
+}
+
+export type MemoryFile = { fileName: string; size: number };
+
+export async function listMemoryFiles(scope: MemoryScope): Promise<MemoryFile[]> {
+  const { dir, files } = await listScopedFiles(scope);
+  return Promise.all(
+    files.map(async (fileName) => ({ fileName, size: Bun.file(join(dir, fileName)).size })),
+  );
+}
+
+/**
+ * $U1Z_HOME/.u1z/memory/MEMORY.txt — 전역 공유 기억 파일.
+ * 사용자가 직접 관리하며, 없으면 빈 문자열 반환.
+ */
+export async function readGlobalMemory(): Promise<string> {
+  const root = resolveMemoryRoot();
+  return readFileIfExists(join(root, "MEMORY.txt"));
+}
+
+function formatTimeRange(start: Date, end: Date): string {
+  const fmt = (d: Date) =>
+    `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+  return `[${fmt(start)} ~ ${fmt(end)}]`;
+}
+
+/**
+ * 오늘 날짜의 기억 파일(YYMMDD.txt)에 텍스트를 추가한다.
+ * timeRange가 있으면 대화 시작~종료 시각을 헤더로 붙인다.
+ */
+export async function appendMemory(
+  scope: MemoryScope,
+  text: string,
+  timeRange: { start: Date; end: Date },
+): Promise<void> {
+  const root = resolveMemoryRoot();
+  const dir = scopeDir(root, scope);
+  await mkdir(dir, { recursive: true });
+
+  const entry = `${formatTimeRange(timeRange.start, timeRange.end)}\n${text.trim()}`;
+
+  const filePath = join(dir, `${toYYMMDD(timeRange.end)}.txt`);
+  const file = Bun.file(filePath);
+  const existing = ((await file.exists()) ? await file.text() : "").trimEnd();
+  await Bun.write(filePath, [existing, entry].filter(Boolean).join("\n\n"));
+}

package/src/memory/memorize.ts

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import { generateText } from "ai";
+import { MODELS } from "@/ai/llm/model";
+import { appendMemory } from "@/memory/index";
+import type { MemoryScope } from "@/memory/types";
+
+/**
+ * 텍스트를 LLM으로 요약해 단기 기억에 저장한다.
+ * MEMORIZE.md가 없거나 비어있으면 스킵.
+ */
+export async function memorizeText(
+  text: string,
+  scope: MemoryScope,
+  timeRange: { start: Date; end: Date },
+): Promise<void> {
+  const path = join(process.env.U1Z_HOME, ".u1z", "prompt", "MEMORIZE.md");
+  const file = Bun.file(path);
+  if (!(await file.exists())) return;
+  const systemPrompt = (await file.text()).trim();
+  if (!systemPrompt) {
+    console.error("[Memorize] MEMORIZE.md가 비어있습니다. 스킵합니다.");
+    return;
+  }
+
+  const { text: summary } = await generateText({
+    model: MODELS.xs,
+    system: systemPrompt,
+    messages: [{ role: "user", content: text }],
+    maxOutputTokens: 512,
+  });
+
+  if (!summary.trim()) {
+    console.log("[Memorize] 요약 내용이 비어있습니다. 스킵합니다.");
+    return;
+  }
+
+  await appendMemory(scope, summary.trim(), timeRange);
+}

package/src/memory/types.ts

@@ -0,0 +1 @@
+export type MemoryScope = { kind: "user"; userId: string } | { kind: "channel"; channelId: string };