companionbot 0.9.0 → 0.10.0

package/dist/memory/ftsIndex.js

@@ -0,0 +1,148 @@
+/**
+ * FTS5 기반 키워드 검색 인덱스 모듈
+ * SQLite FTS5를 사용하여 전문 검색을 제공합니다.
+ */
+import Database from "better-sqlite3";
+import * as path from "path";
+import { getMemoryDirPath } from "../workspace/paths.js";
+// 싱글톤 DB 인스턴스
+let db = null;
+/**
+ * FTS5 데이터베이스 경로
+ */
+function getDbPath() {
+    return path.join(getMemoryDirPath(), ".fts-index.db");
+}
+/**
+ * 데이터베이스 인스턴스를 가져오거나 생성합니다.
+ */
+function getDb() {
+    if (db)
+        return db;
+    const dbPath = getDbPath();
+    db = new Database(dbPath);
+    // FTS5 테이블 생성 (없으면)
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+      id,
+      source,
+      text,
+      content='',
+      tokenize='unicode61'
+    );
+  `);
+    return db;
+}
+/**
+ * 텍스트를 FTS 인덱스에 추가합니다.
+ * 기존 id가 있으면 업데이트합니다.
+ */
+export function indexText(id, source, text) {
+    const database = getDb();
+    // 기존 엔트리 삭제 후 삽입 (upsert)
+    const deleteStmt = database.prepare("DELETE FROM memory_fts WHERE id = ?");
+    const insertStmt = database.prepare("INSERT INTO memory_fts (id, source, text) VALUES (?, ?, ?)");
+    const transaction = database.transaction(() => {
+        deleteStmt.run(id);
+        insertStmt.run(id, source, text);
+    });
+    transaction();
+}
+/**
+ * 여러 텍스트를 배치로 인덱싱합니다.
+ */
+export function indexTextBatch(entries) {
+    if (entries.length === 0)
+        return;
+    const database = getDb();
+    const deleteStmt = database.prepare("DELETE FROM memory_fts WHERE id = ?");
+    const insertStmt = database.prepare("INSERT INTO memory_fts (id, source, text) VALUES (?, ?, ?)");
+    const transaction = database.transaction(() => {
+        for (const entry of entries) {
+            deleteStmt.run(entry.id);
+            insertStmt.run(entry.id, entry.source, entry.text);
+        }
+    });
+    transaction();
+}
+/**
+ * 키워드로 검색합니다.
+ * FTS5 MATCH 쿼리와 BM25 랭킹 사용
+ */
+export function searchKeyword(query, limit = 10) {
+    const database = getDb();
+    // 쿼리 정규화 (특수문자 제거, 공백으로 분리)
+    const cleanQuery = query
+        .replace(/[^\w\s가-힣]/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(word => word.length > 0)
+        .map(word => `"${word}"`) // 정확한 단어 매칭
+        .join(" OR "); // OR 검색
+    if (!cleanQuery)
+        return [];
+    try {
+        const stmt = database.prepare(`
+      SELECT id, source, text, bm25(memory_fts) as score
+      FROM memory_fts
+      WHERE memory_fts MATCH ?
+      ORDER BY score
+      LIMIT ?
+    `);
+        const results = stmt.all(cleanQuery, limit);
+        return results.map(r => ({
+            id: r.id,
+            source: r.source,
+            text: r.text,
+            score: r.score,
+        }));
+    }
+    catch {
+        // 쿼리 파싱 실패 시 빈 결과
+        return [];
+    }
+}
+/**
+ * 특정 소스의 모든 엔트리를 삭제합니다.
+ */
+export function deleteBySource(source) {
+    const database = getDb();
+    const stmt = database.prepare("DELETE FROM memory_fts WHERE source = ?");
+    const result = stmt.run(source);
+    return result.changes;
+}
+/**
+ * 특정 ID의 엔트리를 삭제합니다.
+ */
+export function deleteById(id) {
+    const database = getDb();
+    const stmt = database.prepare("DELETE FROM memory_fts WHERE id = ?");
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+/**
+ * 전체 인덱스를 초기화합니다.
+ */
+export function clearIndex() {
+    const database = getDb();
+    database.exec("DELETE FROM memory_fts");
+}
+/**
+ * 인덱스의 총 문서 수를 반환합니다.
+ */
+export function getDocumentCount() {
+    const database = getDb();
+    const stmt = database.prepare("SELECT COUNT(*) as count FROM memory_fts");
+    const result = stmt.get();
+    return result.count;
+}
+/**
+ * 데이터베이스 연결을 닫습니다.
+ * 애플리케이션 종료 시 호출
+ */
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/memory/hybridSearch.js

@@ -0,0 +1,103 @@
+/**
+ * 하이브리드 검색 모듈
+ * 벡터 검색 + 키워드 검색을 결합하여 최적의 검색 결과를 제공합니다.
+ */
+import { embed } from "./embeddings.js";
+import { search as vectorSearch } from "./vectorStore.js";
+import { searchKeyword } from "./ftsIndex.js";
+// 가중치 설정
+const VECTOR_WEIGHT = 0.7;
+const KEYWORD_WEIGHT = 0.3;
+/**
+ * BM25 점수를 0-1 범위로 정규화합니다.
+ * BM25는 낮을수록 관련성이 높으므로 반전시킵니다.
+ */
+function normalizeBm25Score(score, minScore, maxScore) {
+    if (maxScore === minScore)
+        return 1;
+    // BM25는 음수 (낮을수록 좋음) → 정규화 후 반전
+    const normalized = (maxScore - score) / (maxScore - minScore);
+    return Math.max(0, Math.min(1, normalized));
+}
+/**
+ * 벡터 + 키워드 하이브리드 검색을 수행합니다.
+ *
+ * @param query 검색 쿼리
+ * @param topK 반환할 최대 결과 수
+ * @param vectorWeight 벡터 검색 가중치 (기본 0.7)
+ * @param keywordWeight 키워드 검색 가중치 (기본 0.3)
+ */
+export async function hybridSearch(query, topK = 5, vectorWeight = VECTOR_WEIGHT, keywordWeight = KEYWORD_WEIGHT) {
+    // 병렬로 두 검색 수행
+    const [queryEmbedding, keywordResults] = await Promise.all([
+        embed(query),
+        Promise.resolve(searchKeyword(query, topK * 2)), // 키워드 검색은 더 많이 가져옴
+    ]);
+    // 벡터 검색 수행
+    const vectorResults = await vectorSearch(queryEmbedding, topK * 2, 0.2);
+    // 결과가 모두 없으면 빈 배열 반환
+    if (vectorResults.length === 0 && keywordResults.length === 0) {
+        return [];
+    }
+    // 점수 병합을 위한 Map (key: text의 hash)
+    const scoreMap = new Map();
+    // 벡터 결과 처리 (코사인 유사도: 이미 0-1 범위)
+    for (const result of vectorResults) {
+        const key = makeKey(result.text, result.source);
+        scoreMap.set(key, {
+            text: result.text,
+            source: result.source,
+            score: result.score * vectorWeight,
+            vectorScore: result.score,
+        });
+    }
+    // 키워드 결과 정규화 및 병합
+    if (keywordResults.length > 0) {
+        const minBm25 = Math.min(...keywordResults.map(r => r.score));
+        const maxBm25 = Math.max(...keywordResults.map(r => r.score));
+        for (const result of keywordResults) {
+            const key = makeKey(result.text, result.source);
+            const normalizedScore = normalizeBm25Score(result.score, minBm25, maxBm25);
+            const existing = scoreMap.get(key);
+            if (existing) {
+                // 이미 벡터 결과에 있으면 점수 합산
+                existing.score += normalizedScore * keywordWeight;
+                existing.keywordScore = normalizedScore;
+            }
+            else {
+                // 새로운 결과
+                scoreMap.set(key, {
+                    text: result.text,
+                    source: result.source,
+                    score: normalizedScore * keywordWeight,
+                    keywordScore: normalizedScore,
+                });
+            }
+        }
+    }
+    // 점수 기준 정렬 후 상위 K개 반환
+    const results = Array.from(scoreMap.values())
+        .sort((a, b) => b.score - a.score)
+        .slice(0, topK);
+    return results;
+}
+/**
+ * 벡터 검색만 수행합니다. (기존 동작 호환)
+ */
+export async function searchVector(query, topK = 5, minScore = 0.3) {
+    const queryEmbedding = await embed(query);
+    return vectorSearch(queryEmbedding, topK, minScore);
+}
+/**
+ * 키워드 검색만 수행합니다.
+ */
+export function searchByKeyword(query, limit = 10) {
+    return searchKeyword(query, limit);
+}
+/**
+ * 텍스트와 소스로 고유 키를 생성합니다.
+ */
+function makeKey(text, source) {
+    // 간단한 해시: 처음 100자 + 소스
+    return `${source}:${text.slice(0, 100)}`;
+}

package/dist/memory/index.js

@@ -1,4 +1,11 @@
 // Memory module exports
-export { embed, embedBatch, cosineSimilarity } from './embeddings.js';
-export { search, invalidateCache } from './vectorStore.js';
-export { indexFile, indexMainMemory, indexDailyMemories, reindexAll } from './indexer.js';
+// Embeddings
+export { embed, embedBatch, cosineSimilarity } from "./embeddings.js";
+// Vector store
+export { search, invalidateCache, loadAllMemoryChunks } from "./vectorStore.js";
+// FTS index
+export { indexText, indexTextBatch, searchKeyword, deleteBySource as deleteFtsBySource, deleteById as deleteFtsById, clearIndex as clearFtsIndex, getDocumentCount, closeDb as closeFtsDb, } from "./ftsIndex.js";
+// Hybrid search
+export { hybridSearch, searchVector, searchByKeyword, } from "./hybridSearch.js";
+// Indexer
+export { indexFile, indexMainMemory, indexDailyMemories, indexConversation, reindexAll, } from "./indexer.js";

package/dist/memory/indexer.js

@@ -1,39 +1,166 @@
 /**
  * 메모리 인덱서 모듈
- * 현재 구현은 vectorStore가 on-demand로 로드하므로 캐시 무효화만 수행
+ * 벡터 저장소와 FTS 인덱스 모두 업데이트합니다.
  */
-import { invalidateCache } from './vectorStore.js';
-// 단일 파일 인덱싱 (캐시 무효화)
-export async function indexFile(_filePath, _source) {
-    // vectorStore가 on-demand로 로드하므로 캐시만 무효화
-    invalidateCache();
-    return 1;
+import * as fs from "fs/promises";
+import * as path from "path";
+import { invalidateCache, loadAllMemoryChunks } from "./vectorStore.js";
+import { indexTextBatch, clearIndex as clearFtsIndex, getDocumentCount } from "./ftsIndex.js";
+import { getMemoryDirPath, getWorkspaceFilePath } from "../workspace/paths.js";
+/**
+ * 텍스트를 청크로 분할합니다.
+ */
+function splitIntoChunks(text, source) {
+    const chunks = [];
+    let chunkIndex = 0;
+    // ## 헤더로 분할
+    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({
+                            id: `${source}:${chunkIndex++}`,
+                            text: currentChunk.trim(),
+                            source,
+                        });
+                    }
+                    currentChunk = line;
+                }
+                else {
+                    currentChunk += "\n" + line;
+                }
+            }
+            if (currentChunk.trim()) {
+                chunks.push({
+                    id: `${source}:${chunkIndex++}`,
+                    text: currentChunk.trim(),
+                    source,
+                });
+            }
+        }
+        else {
+            chunks.push({
+                id: `${source}:${chunkIndex++}`,
+                text: trimmed,
+                source,
+            });
+        }
+    }
+    return chunks;
 }
-// MEMORY.md 인덱싱
+/**
+ * 단일 파일 인덱싱 (캐시 무효화 + FTS 업데이트)
+ */
+export async function indexFile(filePath, source) {
+    try {
+        const content = await fs.readFile(filePath, "utf-8");
+        const chunks = splitIntoChunks(content, source);
+        // FTS 인덱스 업데이트
+        const ftsEntries = chunks.map(c => ({
+            id: c.id,
+            source: c.source,
+            text: c.text,
+        }));
+        indexTextBatch(ftsEntries);
+        // 벡터 캐시 무효화
+        invalidateCache();
+        return chunks.length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * MEMORY.md 인덱싱
+ */
 export async function indexMainMemory() {
-    invalidateCache();
-    return 1;
+    const memoryPath = getWorkspaceFilePath("MEMORY.md");
+    return indexFile(memoryPath, "MEMORY");
 }
-// 일일 메모리 파일들 인덱싱
-export async function indexDailyMemories(_days = 30) {
-    invalidateCache();
-    return 1;
+/**
+ * 일일 메모리 파일들 인덱싱
+ */
+export async function indexDailyMemories(days = 30) {
+    const memoryDir = getMemoryDirPath();
+    let totalChunks = 0;
+    try {
+        const files = await fs.readdir(memoryDir);
+        const mdFiles = files
+            .filter(f => f.endsWith(".md") && !f.startsWith("."))
+            .sort()
+            .reverse()
+            .slice(0, days);
+        for (const file of mdFiles) {
+            const filePath = path.join(memoryDir, file);
+            const source = file.replace(".md", "");
+            const count = await indexFile(filePath, source);
+            totalChunks += count;
+        }
+    }
+    catch {
+        // 디렉토리 없음 무시
+    }
+    return totalChunks;
+}
+/**
+ * 대화 기록 인덱싱 (JSONL 형식)
+ */
+export async function indexConversation(conversationId, messages) {
+    if (messages.length === 0)
+        return 0;
+    const ftsEntries = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (!msg.content || msg.content.length < 10)
+            continue;
+        ftsEntries.push({
+            id: `conv:${conversationId}:${i}`,
+            source: `conversation:${conversationId}`,
+            text: `[${msg.role}] ${msg.content}`,
+        });
+    }
+    if (ftsEntries.length > 0) {
+        indexTextBatch(ftsEntries);
+    }
+    return ftsEntries.length;
 }
-// 전체 리인덱싱 (캐시 무효화 후 미리 로드)
+/**
+ * 전체 리인덱싱 (벡터 + FTS 모두)
+ */
 export async function reindexAll() {
-    console.log('[Indexer] Invalidating cache for reindex...');
+    console.log("[Indexer] Starting full reindex...");
+    // 1. FTS 인덱스 초기화
+    clearFtsIndex();
+    // 2. 벡터 캐시 무효화 및 로드
     invalidateCache();
-    // 캐시 무효화 후 즉시 로드하여 청크 수 반환
-    // search를 임시로 호출하여 로드 트리거 (빈 쿼리로)
-    const { loadAllMemoryChunks } = await import('./vectorStore.js');
     const chunks = await loadAllMemoryChunks();
-    // 소스별 집계
+    // 3. 모든 청크를 FTS에 인덱싱
+    const ftsEntries = chunks.map((chunk, idx) => ({
+        id: `${chunk.source}:${idx}`,
+        source: chunk.source,
+        text: chunk.text,
+    }));
+    if (ftsEntries.length > 0) {
+        indexTextBatch(ftsEntries);
+    }
+    // 4. 소스별 집계
     const sourceCounts = new Map();
     for (const chunk of chunks) {
         sourceCounts.set(chunk.source, (sourceCounts.get(chunk.source) || 0) + 1);
     }
+    const ftsCount = getDocumentCount();
+    console.log(`[Indexer] Indexed ${chunks.length} chunks to vector store, ${ftsCount} documents to FTS`);
     return {
         total: chunks.length,
-        sources: Array.from(sourceCounts.keys())
+        sources: Array.from(sourceCounts.keys()),
+        ftsCount,
     };
 }

package/dist/session/persistence.js

@@ -0,0 +1,194 @@
+/**
+ * JSONL 기반 세션 영구 저장
+ *
+ * OpenClaw 스타일로 대화 기록을 JSONL 파일로 저장
+ * - 저장 경로: ~/.companionbot/sessions/{chatId}.jsonl
+ * - 메시지마다 한 줄씩 append
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as readline from "readline";
+// 저장 경로
+const SESSIONS_DIR = path.join(os.homedir(), ".companionbot", "sessions");
+/**
+ * 세션 디렉토리 초기화 (없으면 생성)
+ */
+function ensureSessionsDir() {
+    if (!fs.existsSync(SESSIONS_DIR)) {
+        fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+        console.log(`[Persistence] Created sessions directory: ${SESSIONS_DIR}`);
+    }
+}
+/**
+ * chatId에 해당하는 JSONL 파일 경로
+ */
+function getSessionFilePath(chatId) {
+    return path.join(SESSIONS_DIR, `${chatId}.jsonl`);
+}
+/**
+ * 메시지를 JSONL 파일에 append
+ */
+export function appendMessage(chatId, role, content) {
+    ensureSessionsDir();
+    const filePath = getSessionFilePath(chatId);
+    const message = {
+        role,
+        content,
+        timestamp: Date.now(),
+    };
+    const line = JSON.stringify(message) + "\n";
+    try {
+        fs.appendFileSync(filePath, line, "utf-8");
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to append message to ${filePath}:`, error);
+    }
+}
+/**
+ * JSONL 파일에서 히스토리 로드
+ *
+ * @param chatId 채팅 ID
+ * @param limit 최근 N개만 로드 (메모리 절약, 0 = 전부)
+ * @returns 로드된 메시지 배열
+ */
+export async function loadHistory(chatId, limit = 100) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const messages = [];
+    try {
+        const fileStream = fs.createReadStream(filePath, { encoding: "utf-8" });
+        const rl = readline.createInterface({
+            input: fileStream,
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (line.trim()) {
+                try {
+                    const msg = JSON.parse(line);
+                    messages.push(msg);
+                }
+                catch (parseError) {
+                    console.warn(`[Persistence] Skipping malformed line in ${filePath}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to load history from ${filePath}:`, error);
+        return [];
+    }
+    // limit이 0이면 전부, 아니면 최근 N개만
+    if (limit > 0 && messages.length > limit) {
+        return messages.slice(-limit);
+    }
+    return messages;
+}
+/**
+ * 동기 버전 히스토리 로드 (초기화 시 사용)
+ */
+export function loadHistorySync(chatId, limit = 100) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const messages = [];
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split("\n");
+        for (const line of lines) {
+            if (line.trim()) {
+                try {
+                    const msg = JSON.parse(line);
+                    messages.push(msg);
+                }
+                catch (parseError) {
+                    console.warn(`[Persistence] Skipping malformed line in ${filePath}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to load history from ${filePath}:`, error);
+        return [];
+    }
+    // limit이 0이면 전부, 아니면 최근 N개만
+    if (limit > 0 && messages.length > limit) {
+        return messages.slice(-limit);
+    }
+    return messages;
+}
+/**
+ * 전체 히스토리 개수 (파일에서)
+ */
+export function getHistoryCount(chatId) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return 0;
+    }
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return content.split("\n").filter(line => line.trim()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 세션 파일 삭제 (히스토리 완전 삭제)
+ */
+export function deleteSessionFile(chatId) {
+    const filePath = getSessionFilePath(chatId);
+    if (!fs.existsSync(filePath)) {
+        return false;
+    }
+    try {
+        fs.unlinkSync(filePath);
+        console.log(`[Persistence] Deleted session file: ${filePath}`);
+        return true;
+    }
+    catch (error) {
+        console.error(`[Persistence] Failed to delete session file:`, error);
+        return false;
+    }
+}
+/**
+ * 세션 파일 존재 여부
+ */
+export function sessionFileExists(chatId) {
+    return fs.existsSync(getSessionFilePath(chatId));
+}
+/**
+ * 모든 세션 파일 목록
+ */
+export function listSessionFiles() {
+    ensureSessionsDir();
+    try {
+        const files = fs.readdirSync(SESSIONS_DIR);
+        return files
+            .filter(f => f.endsWith(".jsonl"))
+            .map(f => parseInt(f.replace(".jsonl", ""), 10))
+            .filter(id => !isNaN(id));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 히스토리 검색 (파일 전체에서)
+ *
+ * @param chatId 채팅 ID
+ * @param query 검색어
+ * @param limit 최대 결과 수
+ * @returns 매칭된 메시지들
+ */
+export async function searchHistory(chatId, query, limit = 10) {
+    const all = await loadHistory(chatId, 0); // 전부 로드
+    const lowerQuery = query.toLowerCase();
+    const matches = all
+        .filter(msg => msg.content.toLowerCase().includes(lowerQuery))
+        .slice(-limit); // 최근 것부터
+    return matches;
+}

package/dist/session/state.js

@@ -1,5 +1,6 @@
 import { AsyncLocalStorage } from "async_hooks";
 import { estimateMessagesTokens, estimateTokens } from "../utils/tokens.js";
+import * as persistence from "./persistence.js";
 // 세션 설정
 const MAX_SESSIONS = 100;
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
@@ -8,6 +9,8 @@ const MAX_HISTORY_TOKENS = 40000; // 히스토리 한도
 const SUMMARY_THRESHOLD_TOKENS = 25000; // 이 이상이면 요약 시작
 const MIN_RECENT_MESSAGES = 6; // 최소 유지할 최근 메시지
 const MAX_PINNED_TOKENS = 5000; // 핀 맥락 최대 토큰
+// 영구 저장 설정
+const MAX_HISTORY_LOAD = 50; // 메모리에 로드할 최대 메시지 수
 // 세션별 상태 저장
 const sessions = new Map();
 // AsyncLocalStorage for chatId context
@@ -37,8 +40,18 @@ function getSession(chatId) {
     }
     // 새 세션 생성 전 정리
     cleanupSessions();
+    // 기존 JSONL 파일에서 히스토리 로드
+    const persistedMessages = persistence.loadHistorySync(chatId, MAX_HISTORY_LOAD);
+    const history = persistedMessages.map(pm => ({
+        role: pm.role,
+        content: pm.content,
+    }));
+    if (persistedMessages.length > 0) {
+        const totalCount = persistence.getHistoryCount(chatId);
+        console.log(`[Session] Loaded ${persistedMessages.length}/${totalCount} messages from JSONL for chatId=${chatId}`);
+    }
     const session = {
-        history: [],
+        history,
         model: "sonnet",
         lastAccessedAt: now,
         pinnedContexts: [],
@@ -73,6 +86,23 @@ export function getHistory(chatId) {
     }
     return session.history;
 }
+/**
+ * 메시지 추가 (메모리 + JSONL 파일 동기화)
+ */
+export function addMessage(chatId, role, content) {
+    const history = getHistory(chatId);
+    history.push({ role, content });
+    // JSONL 파일에도 영구 저장
+    persistence.appendMessage(chatId, role, content);
+}
+/**
+ * 여러 메시지 추가 (배치)
+ */
+export function addMessages(chatId, messages) {
+    for (const msg of messages) {
+        addMessage(chatId, msg.role, msg.content);
+    }
+}
 /**
  * 핀된 맥락 가져오기
  */
@@ -292,10 +322,11 @@ export function clearHistory(chatId) {
     }
 }
 /**
- * 완전 초기화 (핀 포함)
+ * 완전 초기화 (핀 포함 + JSONL 파일 삭제)
  */
 export function clearSession(chatId) {
     sessions.delete(chatId);
+    persistence.deleteSessionFile(chatId);
 }
 export function getModel(chatId) {
     return getSession(chatId).model;
@@ -328,5 +359,8 @@ export function getSessionStats(chatId) {
         pinnedCount: session.pinnedContexts.length,
         pinnedTokens: session.pinnedContexts.reduce((sum, p) => sum + estimateTokens(p.text), 0),
         summaryCount: session.summaryChunks.length,
+        totalPersistedCount: persistence.getHistoryCount(chatId),
     };
 }
+// Re-export persistence functions for external use
+export { searchHistory, getHistoryCount, sessionFileExists, listSessionFiles, } from "./persistence.js";

package/dist/telegram/handlers/commands.js

@@ -49,7 +49,7 @@ function validateResetToken(chatId, token) {
     resetTokens.delete(chatId); // 사용 후 삭제
     return true;
 }
-import { getHistory, clearHistory, getModel, setModel, runWithChatId, getPinnedContexts, pinContext, unpinContext, clearPins, getSessionStats, } from "../../session/state.js";
+import { getHistory, clearHistory, getModel, setModel, runWithChatId, getPinnedContexts, pinContext, unpinContext, clearPins, getSessionStats, addMessage, } from "../../session/state.js";
 import { hasBootstrap, loadRecentMemories, getWorkspacePath, } from "../../workspace/index.js";
 import { getSecret, setSecret, deleteSecret } from "../../config/secrets.js";
 import { getReminders } from "../../reminders/index.js";
@@ -75,14 +75,15 @@ export function registerCommands(bot) {
                 const history = getHistory(chatId);
                 const modelId = getModel(chatId);
                 const systemPrompt = await buildSystemPrompt(modelId);
-                // 첫 메시지 생성 요청
+                // 첫 메시지 생성 요청 (시스템 메시지는 JSONL에 저장 안 함 - 세션 내부용)
                 history.push({
                     role: "user",
                     content: "[시스템: 사용자가 /start를 눌렀습니다. 온보딩을 시작하세요.]",
                 });
                 try {
                     const result = await chat(history, systemPrompt, modelId);
-                    history.push({ role: "assistant", content: result.text });
+                    // 온보딩 응답도 JSONL에 저장
+                    addMessage(chatId, "assistant", result.text);
                     await ctx.reply(result.text);
                 }
                 catch (error) {
@@ -706,7 +707,8 @@ export function registerCommands(bot) {
         const chatId = ctx.chat.id;
         const stats = getSessionStats(chatId);
         await ctx.reply(`📊 맥락 상태\n\n` +
-            `💬 히스토리: ${stats.historyLength}개 메시지 (~${stats.historyTokens} 토큰)\n` +
+            `💬 메모리: ${stats.historyLength}개 메시지 (~${stats.historyTokens} 토큰)\n` +
+            `💾 저장됨: ${stats.totalPersistedCount}개 (JSONL 파일)\n` +
             `📌 핀: ${stats.pinnedCount}개 (~${stats.pinnedTokens} 토큰)\n` +
             `📜 요약: ${stats.summaryCount}개\n\n` +
             `명령어:\n` +

package/dist/telegram/handlers/messages.js

@@ -1,6 +1,7 @@
 import { chat, chatSmart } from "../../ai/claude.js";
 import { recordActivity, recordError } from "../../health/index.js";
-import { getHistory, getModel, runWithChatId, trimHistoryByTokens, smartTrimHistory, detectImportantContext, pinContext, } from "../../session/state.js";
+import { getHistory, getModel, runWithChatId, trimHistoryByTokens, smartTrimHistory, detectImportantContext, pinContext, addMessage, } from "../../session/state.js";
+import * as persistence from "../../session/persistence.js";
 import { updateLastMessageTime } from "../../heartbeat/index.js";
 import { extractUrls, fetchWebContent, formatUrlContent, buildSystemPrompt, } from "../utils/index.js";
 import { estimateMessagesTokens } from "../../utils/tokens.js";
@@ -145,7 +146,10 @@ export function registerMessageHandlers(bot) {
                         text: caption,
                     },
                 ];
+                // API용 메모리 히스토리에는 이미지 데이터 포함
                 history.push({ role: "user", content: imageContent });
+                // JSONL에는 캡션만 저장 (이미지 base64는 너무 큼)
+                persistence.appendMessage(chatId, "user", `[이미지] ${caption}`);
                 try {
                     const systemPrompt = await buildSystemPrompt(modelId, history);
                     const result = await chat(history, systemPrompt, modelId);
@@ -157,7 +161,9 @@ export function registerMessageHandlers(bot) {
                             .join("\n");
                         assistantContent = `[도구 사용: ${result.toolsUsed.map(t => t.name).join(", ")}]\n${toolsSummary}\n\n---\n${result.text}`;
                     }
+                    // 메모리 + JSONL 영구 저장
                     history.push({ role: "assistant", content: assistantContent });
+                    persistence.appendMessage(chatId, "assistant", assistantContent);
                     // 토큰 기반 히스토리 트리밍
                     trimHistoryByTokens(history);
                     await ctx.reply(result.text);
@@ -177,6 +183,7 @@ export function registerMessageHandlers(bot) {
                         userErrorMsg = "사진을 분석하다가 문제가 생겼어. 다시 보내줄래?";
                     }
                     history.push({ role: "assistant", content: `[응답 실패] ${userErrorMsg}` });
+                    persistence.appendMessage(chatId, "assistant", `[응답 실패] ${userErrorMsg}`);
                     recordError();
                     console.error(`[Photo] chatId=${chatId} error:`, errorMsg);
                     await ctx.reply(userErrorMsg);
@@ -242,8 +249,8 @@ export function registerMessageHandlers(bot) {
                     messageForHistory = userMessage + "\n\n" + urlRefs.join("\n");
                 }
             }
-            // 히스토리에는 간략 버전 저장
-            history.push({ role: "user", content: messageForHistory });
+            // 히스토리에는 간략 버전 저장 + JSONL에 영구 저장
+            addMessage(chatId, "user", messageForHistory);
             try {
                 const systemPrompt = await buildSystemPrompt(modelId, history);
                 // API 호출용 메시지 준비 (URL 전체 내용 포함)
@@ -262,7 +269,8 @@ export function registerMessageHandlers(bot) {
                 // 스트리밍 응답 사용 (실시간 업데이트)
                 const response = await sendStreamingResponse(ctx, messagesForApi, // URL 내용이 포함된 버전
                 systemPrompt, modelId);
-                history.push({ role: "assistant", content: response });
+                // 메모리 + JSONL에 영구 저장
+                addMessage(chatId, "assistant", response);
                 // 스마트 트리밍 (요약 포함) - autoCompactIfNeeded 대체
                 const summarizeFn = async (messages) => {
                     const summaryPrompt = "다음 대화를 핵심만 3-4문장으로 요약해. 중요한 정보(이름, 선호도, 약속 등)는 반드시 포함:\n\n" +
@@ -298,8 +306,8 @@ export function registerMessageHandlers(bot) {
                 else {
                     userErrorMsg = `문제가 생겼어: ${errorMsg.slice(0, 100)}`;
                 }
-                // 에러 메시지를 assistant 응답으로 기록 (히스토리 컨텍스트 유지)
-                history.push({ role: "assistant", content: `[응답 실패] ${userErrorMsg}` });
+                // 에러 메시지를 assistant 응답으로 기록 (히스토리 컨텍스트 유지) + JSONL 저장
+                addMessage(chatId, "assistant", `[응답 실패] ${userErrorMsg}`);
                 await ctx.reply(userErrorMsg);
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "companionbot",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "AI 친구 텔레그램 봇 - Claude API 기반 개인화된 대화 상대",
   "keywords": [
     "telegram",
@@ -48,6 +48,7 @@
     "@grammyjs/ratelimiter": "^1.2.1",
     "@inquirer/prompts": "^8.2.0",
     "@xenova/transformers": "^2.17.2",
+    "better-sqlite3": "^12.6.2",
     "cheerio": "^1.2.0",
     "google-auth-library": "^9.15.1",
     "grammy": "^1.31.0",
@@ -56,6 +57,7 @@
     "node-cron": "^4.2.1"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
     "@types/node-cron": "^3.0.11",
     "tsx": "^4.0.0",