claude-session-continuity-mcp 1.13.0 → 1.13.2

package/README.md

@@ -1,4 +1,4 @@
-# claude-session-continuity-mcp (v1.12.1)
+# claude-session-continuity-mcp (v1.13.0)
 
 > **Zero Re-explanation Session Continuity for Claude Code** — Automatic context capture + semantic search + auto error→solution pipeline
 
@@ -6,6 +6,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Tests](https://img.shields.io/badge/tests-111%20passed-brightgreen.svg)]()
 [![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)]()
+[![claude-session-continuity-mcp MCP server](https://glama.ai/mcp/servers/leesgit/claude-session-continuity-mcp/badges/card.svg)](https://glama.ai/mcp/servers/leesgit/claude-session-continuity-mcp)
 
 ## The Problem
 

package/dist/hooks/post-tool-use.js

@@ -7,6 +7,47 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
+// ===== Playwright 캐시 정리 (20MB 컨텍스트 초과 방지) =====
+function cleanPlaywrightCache(cwd) {
+    const MAX_TOTAL = 3 * 1024 * 1024; // 3MB 초과 시 정리
+    const MAX_FILES = 20; // 최대 파일 수
+    // .playwright-mcp/ 정리
+    const playwrightDir = path.join(cwd, '.playwright-mcp');
+    if (fs.existsSync(playwrightDir)) {
+        try {
+            const files = fs.readdirSync(playwrightDir)
+                .map(f => ({ name: f, path: path.join(playwrightDir, f), stat: fs.statSync(path.join(playwrightDir, f)) }))
+                .sort((a, b) => a.stat.mtimeMs - b.stat.mtimeMs);
+            let totalSize = files.reduce((sum, f) => sum + f.stat.size, 0);
+            // 오래된 파일부터 삭제 (최근 5개만 유지)
+            while (files.length > 5 || totalSize > MAX_TOTAL) {
+                const oldest = files.shift();
+                if (!oldest)
+                    break;
+                try {
+                    fs.unlinkSync(oldest.path);
+                    totalSize -= oldest.stat.size;
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // 루트의 스크린샷 파일 정리 (최근 3개만 유지)
+    try {
+        const screenshots = fs.readdirSync(cwd)
+            .filter(f => /\.(png|jpeg|jpg)$/i.test(f))
+            .map(f => ({ name: f, path: path.join(cwd, f), stat: fs.statSync(path.join(cwd, f)) }))
+            .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs); // 최신순
+        for (let i = 3; i < screenshots.length; i++) {
+            try {
+                fs.unlinkSync(screenshots[i].path);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    catch { /* ignore */ }
+}
 // ===== 에러 감지 → 솔루션 자동 주입 =====
 const ERROR_PATTERNS = [
     /(?:error|Error|ERROR)\s*[:\[]/,
@@ -190,6 +231,12 @@ async function main() {
             }
             process.exit(0);
         }
+        // Playwright 도구 사용 후 캐시 정리 (20MB 컨텍스트 초과 방지)
+        if (toolName.startsWith('mcp__playwright__')) {
+            const cwd = input.cwd || process.cwd();
+            cleanPlaywrightCache(cwd);
+            process.exit(0);
+        }
         const TRACKED_TOOLS = ['Edit', 'Write', 'Read', 'Glob', 'Grep'];
         const IGNORED_PATTERNS = ['node_modules', '.git/', 'dist/', 'build/', '.next/', 'coverage/', '.DS_Store'];
         if (!TRACKED_TOOLS.includes(toolName)) {
@@ -218,6 +265,7 @@ async function main() {
             process.exit(0);
         }
         const db = new Database(dbPath);
+        db.pragma('journal_mode = WAL'); // 다중 hook 프로세스 동시성 보장
         // hot_paths 추적 (모든 추적 도구)
         try {
             const pathType = filePath.includes('.') ? 'file' : 'directory';

package/dist/hooks/pre-compact.js

@@ -143,6 +143,55 @@ function buildHandoverContext(transcript) {
     context.recentErrors = context.recentErrors.slice(0, 3);
     return context;
 }
+/**
+ * Playwright 캐시 정리 - 오래된 스냅샷/로그 제거 (20MB 컨텍스트 초과 방지)
+ */
+function cleanPlaywrightCache(cwd) {
+    const playwrightDir = path.join(cwd, '.playwright-mcp');
+    if (!fs.existsSync(playwrightDir))
+        return;
+    const now = Date.now();
+    const MAX_AGE = 30 * 60 * 1000; // 30분 이상 된 파일 정리
+    const MAX_DIR_SIZE = 5 * 1024 * 1024; // 5MB 초과 시 정리
+    try {
+        const files = fs.readdirSync(playwrightDir);
+        let totalSize = 0;
+        const fileInfos = [];
+        for (const file of files) {
+            const filePath = path.join(playwrightDir, file);
+            const stat = fs.statSync(filePath);
+            totalSize += stat.size;
+            fileInfos.push({ name: file, mtime: stat.mtimeMs, size: stat.size });
+        }
+        if (totalSize < MAX_DIR_SIZE)
+            return; // 5MB 미만이면 정리 불필요
+        // 오래된 파일부터 삭제
+        fileInfos.sort((a, b) => a.mtime - b.mtime);
+        for (const fi of fileInfos) {
+            if (now - fi.mtime > MAX_AGE) {
+                fs.unlinkSync(path.join(playwrightDir, fi.name));
+                totalSize -= fi.size;
+            }
+            if (totalSize < MAX_DIR_SIZE)
+                break;
+        }
+    }
+    catch { /* ignore */ }
+    // 루트의 오래된 스크린샷 PNG/JPEG도 정리
+    try {
+        const rootFiles = fs.readdirSync(cwd);
+        for (const file of rootFiles) {
+            if (!/\.(png|jpeg|jpg)$/i.test(file))
+                continue;
+            const filePath = path.join(cwd, file);
+            const stat = fs.statSync(filePath);
+            if (now - stat.mtimeMs > MAX_AGE) {
+                fs.unlinkSync(filePath);
+            }
+        }
+    }
+    catch { /* ignore */ }
+}
 async function main() {
     try {
         let inputData = '';
@@ -151,6 +200,8 @@ async function main() {
         }
         const input = inputData ? JSON.parse(inputData) : {};
         const cwd = input.cwd || process.cwd();
+        // Playwright 캐시 정리 (20MB 컨텍스트 초과 방지)
+        cleanPlaywrightCache(cwd);
         const project = detectProject(cwd);
         const dbPath = getDbPath(cwd);
         if (!fs.existsSync(dbPath)) {
@@ -158,6 +209,7 @@ async function main() {
             process.exit(0);
         }
         const db = new Database(dbPath);
+        db.pragma('journal_mode = WAL'); // 다중 hook 프로세스 동시성 보장
         // 핸드오버 컨텍스트 빌드
         const handover = input.transcript ? buildHandoverContext(input.transcript) : null;
         // active_context 업데이트 (memories에는 저장하지 않음)
@@ -233,7 +285,8 @@ async function main() {
         process.exit(0);
     }
     catch (e) {
-        // 에러 시 조용히 종료
+        // fail-soft: 컴팩션이 멈추지 않도록 continue:true 반드시 반환
+        process.stdout.write(JSON.stringify({ continue: true }));
         process.exit(0);
     }
 }

package/dist/hooks/session-end.js

@@ -12,6 +12,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import * as readline from 'readline';
+import * as crypto from 'crypto';
 import Database from 'better-sqlite3';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
@@ -238,6 +239,8 @@ async function parseTranscriptSinglePass(transcriptPath) {
         userRequests: { firstRequest: '', allRequests: [] },
         recentAssistantMessages: [],
         errorFixPairs: [],
+        firstTimestamp: null,
+        lastTimestamp: null,
     };
     if (!transcriptPath || !fs.existsSync(transcriptPath))
         return result;
@@ -267,6 +270,12 @@ async function parseTranscriptSinglePass(transcriptPath) {
                 const entry = JSON.parse(line);
                 const role = entry.type || entry.role || '';
                 const content = entry.message?.content;
+                // === 0. Timestamp 추출 (세션 duration 계산용) ===
+                if (entry.timestamp) {
+                    if (!result.firstTimestamp)
+                        result.firstTimestamp = entry.timestamp;
+                    result.lastTimestamp = entry.timestamp;
+                }
                 // === 1. Commit 추출 (tool_use 블록에서) ===
                 if (line.includes('git commit') && Array.isArray(content)) {
                     for (const block of content) {
@@ -343,9 +352,9 @@ async function parseTranscriptSinglePass(transcriptPath) {
         }
     }
     result.decisions = [...decisionSet].slice(0, 3);
-    // Error-Fix pairs
-    const errorRe = /(?:error|Error|ERROR|오류|실패|FAILED|Exception)[:\s](.{5,80})/;
-    const fixRe = /(?:fixed|resolved|수정|해결|Added|수정 완료)/i;
+    // Error-Fix pairs (한국어 패턴 보강)
+    const errorRe = /(?:error|Error|ERROR|오류|에러|버그|예외|실패|FAILED|Exception|TypeError|ReferenceError|SyntaxError|crash|crashed|충돌|문제)[:\s](.{5,80})/;
+    const fixRe = /(?:fixed|resolved|patched|수정|해결|고침|처리|완료|변경|적용|반영|커밋|Added|수정 완료|문제 해결|해결됨|되돌림)/i;
     const pairSet = new Set();
     for (let i = 0; i < recentEntries.length - 1; i++) {
         const errorMatch = recentEntries[i].text.match(errorRe);
@@ -370,6 +379,45 @@ async function parseTranscriptSinglePass(transcriptPath) {
     result.recentAssistantMessages = result.recentAssistantMessages.slice(-5);
     return result;
 }
+/**
+ * 슬래시 커맨드 prefix 제거 — "/mcp-dev 측정해줘" → "측정해줘"
+ * 첫 토큰이 `/`로 시작하면 다음 의미 토큰까지 스킵
+ * 슬래시뿐이면 빈 문자열 반환 (호출자가 폴백 처리)
+ */
+function stripSlashPrefix(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/'))
+        return trimmed;
+    // 첫 줄에서 슬래시 토큰을 제거
+    const firstLine = trimmed.split('\n')[0];
+    const tokens = firstLine.split(/\s+/);
+    let i = 0;
+    while (i < tokens.length && tokens[i].startsWith('/'))
+        i++;
+    const rest = tokens.slice(i).join(' ').trim();
+    if (rest.length >= 3)
+        return rest;
+    // 다음 줄에 의미 있는 본문이 있으면 사용
+    const lines = trimmed.split('\n').slice(1).map(l => l.trim()).filter(l => l.length >= 3 && !l.startsWith('/'));
+    return lines[0] || '';
+}
+/**
+ * Jaccard 유사도 (토큰 단위) — 0~1 사이
+ * 동일하면 1, 완전 다르면 0
+ */
+function jaccardSimilarity(a, b) {
+    const tokenize = (s) => new Set(s.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, ' ').split(/\s+/).filter(t => t.length >= 2));
+    const setA = tokenize(a);
+    const setB = tokenize(b);
+    if (setA.size === 0 || setB.size === 0)
+        return 0;
+    let intersect = 0;
+    for (const t of setA)
+        if (setB.has(t))
+            intersect++;
+    const union = setA.size + setB.size - intersect;
+    return union === 0 ? 0 : intersect / union;
+}
 /**
  * 사용자 메시지들을 세션 요약으로 압축
  * 예: ["MCP 테스트해줘", "개선해줘", "npm 배포하고 커밋해줘"] → "MCP 테스트 + 개선 + npm 배포/커밋"
@@ -377,12 +425,24 @@ async function parseTranscriptSinglePass(transcriptPath) {
 function summarizeUserRequests(requests) {
     if (requests.length === 0)
         return '';
-    if (requests.length === 1)
-        return requests[0];
+    // 슬래시 커맨드 도움말 본문(/work, /clone-pro 등이 첫 줄에 박히는 케이스) 제외
+    // → 36건 동일 last_work 누적 문제 해결
+    const meaningful = requests
+        .map(r => stripSlashPrefix(r))
+        .filter(r => {
+        if (!r)
+            return false;
+        if (/^[A-Z][a-z]+\s+(skill|command):/i.test(r))
+            return false;
+        return r.length > 0;
+    });
+    const source = meaningful.length > 0 ? meaningful : requests;
+    if (source.length === 1)
+        return source[0];
     // 중복/유사 요청 제거 (앞 20글자 기준)
     const unique = [];
     const seen = new Set();
-    for (const req of requests) {
+    for (const req of source) {
         const key = req.slice(0, 20).toLowerCase();
         if (!seen.has(key)) {
             seen.add(key);
@@ -407,20 +467,59 @@ async function main() {
             inputData += chunk;
         }
         const input = inputData ? JSON.parse(inputData) : {};
+        // 중복 호출 가드 1: stop_hook_active 플래그 (Claude Code 공식 플래그)
+        if (input.stop_hook_active === true) {
+            process.exit(0);
+        }
         const cwd = input.cwd || process.cwd();
         const project = detectProject(cwd);
         const dbPath = getDbPath(cwd);
+        // 중복 호출 가드 2: transcript_path 해시 기반 5초 윈도우 파일락
+        // Phase 3: session_id 5초 락 도입 (sid 있는 호출만 차단됨)
+        // Phase 5: 실측에서 모든 stop이 [sid 있는 호출 + sid 없는 호출] 페어로 들어옴
+        //          → transcript_path 해시를 우선 키로 사용해야 같은 페어가 같은 락을 공유
+        //          → transcript_path 없을 때만 session_id 폴백
+        const lockKey = input.transcript_path
+            ? crypto.createHash('md5').update(input.transcript_path).digest('hex').slice(0, 16)
+            : (input.session_id || null);
+        if (lockKey) {
+            const lockPath = path.join(path.dirname(dbPath), `.session-end-${lockKey}.lock`);
+            const now = Date.now();
+            try {
+                // Phase 5: atomic `wx` (존재 시 EEXIST throw) → 두 hook 인스턴스가 거의 동시에 진입하는 race 차단
+                // 베이스라인: id=1606/1607이 ~500ms 차이로 동시 INSERT 됨 (debug.log 13:26:51.205 + 13:26:51.702)
+                fs.writeFileSync(lockPath, String(now), { flag: 'wx' });
+            }
+            catch (e) {
+                // 파일이 이미 존재 (다른 hook 인스턴스가 처리 중) → mtime 확인 후 5초 내면 차단
+                if (e.code === 'EEXIST') {
+                    try {
+                        const lockMtime = fs.statSync(lockPath).mtimeMs;
+                        if (now - lockMtime < 5000) {
+                            process.exit(0); // 5초 내 재발화 차단
+                        }
+                        // 5초 지난 stale 락 → 덮어쓰기 (이 호출이 새 작업)
+                        fs.writeFileSync(lockPath, String(now));
+                    }
+                    catch {
+                        // stat/write 실패는 fail-soft
+                    }
+                }
+                // 그 외 락 파일 에러는 무시 (fail-soft)
+            }
+        }
         // 디버그 로그
         const debugLogPath = path.join(path.dirname(dbPath), 'session-end-debug.log');
         const inputKeys = Object.keys(input);
         const lastMsgLen = input.last_assistant_message?.length || 0;
-        const debugLine = `[${new Date().toISOString()}] project=${project} keys=[${inputKeys.join(',')}] transcript_path=${input.transcript_path || 'none'} last_msg_len=${lastMsgLen}\n`;
+        const debugLine = `[${new Date().toISOString()}] project=${project} sid=${input.session_id?.slice(0, 8) || 'none'} keys=[${inputKeys.join(',')}] transcript_path=${input.transcript_path || 'none'} last_msg_len=${lastMsgLen}\n`;
         fs.appendFileSync(debugLogPath, debugLine);
         if (!fs.existsSync(dbPath)) {
             console.log('[SessionEnd] No DB found, skipping');
             process.exit(0);
         }
         const db = new Database(dbPath);
+        db.pragma('journal_mode = WAL'); // 다중 hook 프로세스 동시성 보장
         // === 추출 시작 ===
         let lastWork = '';
         let nextTasks = [];
@@ -433,6 +532,8 @@ async function main() {
             userRequests: { firstRequest: '', allRequests: [] },
             recentAssistantMessages: [],
             errorFixPairs: [],
+            firstTimestamp: null,
+            lastTimestamp: null,
         };
         if (input.transcript_path) {
             transcript = await parseTranscriptSinglePass(input.transcript_path);
@@ -441,7 +542,9 @@ async function main() {
             decisions = transcript.decisions;
         }
         // lastWork 결정 (우선순위 폴백)
-        const { firstRequest, allRequests } = transcript.userRequests;
+        const { firstRequest: rawFirstRequest, allRequests } = transcript.userRequests;
+        // firstRequest 슬래시 prefix 제거 (예: "/mcp-dev 측정" → "측정")
+        const firstRequest = rawFirstRequest ? (stripSlashPrefix(rawFirstRequest) || rawFirstRequest) : '';
         // 2a: 사용자 요청 + 커밋 메시지 조합 (가장 이상적)
         if (firstRequest && commitMessages.length > 0) {
             lastWork = `${firstRequest} → ${commitMessages.slice(0, 2).join('; ')}`;
@@ -519,23 +622,52 @@ async function main() {
             const fileNames = modifiedFiles.slice(0, 5).map(f => path.basename(f)).join(', ');
             lastWork = `Modified files: ${fileNames}`;
         }
+        // Phase 5: 모든 last_work 결정 경로에 stripSlashPrefix 강제 적용
+        // 베이스라인: 2a 경로(firstRequest)만 stripSlashPrefix 적용되고 2c~2e 폴백은 미적용
+        //          → 같은 transcript에서 두 hook 인스턴스가 서로 다른 경로로 들어가
+        //            한쪽은 "측정", 한쪽은 "/mcp-dev 측정"으로 분기 → Jaccard 0.85 미달로 둘 다 통과
+        //          stripSlashPrefix가 빈 문자열을 반환하면 원본 유지 (의미 토큰이 없는 경우)
+        if (lastWork) {
+            const stripped = stripSlashPrefix(lastWork);
+            if (stripped)
+                lastWork = stripped;
+        }
         // 빈 세션 skip
         if (!lastWork) {
             console.log(`[SessionEnd] Skipping empty session for ${project} (no meaningful last_work)`);
             db.close();
             process.exit(0);
         }
-        // 중복 저장 방지 (같은 내용이 1시간 이내에 저장됐으면 skip)
-        const recentDup = db.prepare(`
+        // 중복 저장 방지 — Jaccard 유사도 기반 (1시간 이내, 동일 프로젝트)
+        // 베이스라인: 동일 last_work가 4~5분 간격으로 반복 INSERT되는 케이스 5건/24h 발견
+        // 정확 일치 + Jaccard >= 0.85 둘 다 차단
+        const recentExact = db.prepare(`
       SELECT id FROM sessions
       WHERE project = ? AND last_work = ? AND timestamp > datetime('now', '-1 hour')
       LIMIT 1
     `).get(project, lastWork);
-        if (recentDup) {
-            console.log(`[SessionEnd] Skipping duplicate session for ${project}`);
+        if (recentExact) {
+            console.log(`[SessionEnd] Skipping duplicate (exact) for ${project}`);
             db.close();
             process.exit(0);
         }
+        const recentRows = db.prepare(`
+      SELECT last_work FROM sessions
+      WHERE project = ? AND timestamp > datetime('now', '-1 hour')
+      ORDER BY timestamp DESC LIMIT 10
+    `).all(project);
+        for (const row of recentRows) {
+            if (!row.last_work)
+                continue;
+            // Phase 5: 비교 전 양쪽 모두 stripSlashPrefix 정규화 → 표현 차이 흡수
+            const normalizedCurrent = stripSlashPrefix(lastWork) || lastWork;
+            const normalizedRow = stripSlashPrefix(row.last_work) || row.last_work;
+            if (jaccardSimilarity(normalizedCurrent, normalizedRow) >= 0.85) {
+                console.log(`[SessionEnd] Skipping near-duplicate (jaccard >= 0.85) for ${project}`);
+                db.close();
+                process.exit(0);
+            }
+        }
         // 구조화 메타데이터 (issues 컬럼 활용)
         const metadata = {
             commits: commitMessages,
@@ -543,11 +675,20 @@ async function main() {
             errorsSolved
         };
         const hasMetadata = commitMessages.length > 0 || decisions.length > 0 || errorsSolved.length > 0;
+        // 세션 duration 계산 (transcript first ↔ last timestamp)
+        let durationMinutes = null;
+        if (transcript.firstTimestamp && transcript.lastTimestamp) {
+            const start = new Date(transcript.firstTimestamp).getTime();
+            const end = new Date(transcript.lastTimestamp).getTime();
+            if (!isNaN(start) && !isNaN(end) && end >= start) {
+                durationMinutes = Math.round((end - start) / 60000);
+            }
+        }
         // 세션 기록 저장
         db.prepare(`
-      INSERT INTO sessions (project, last_work, next_tasks, modified_files, issues)
-      VALUES (?, ?, ?, ?, ?)
-    `).run(project, lastWork, JSON.stringify([...new Set(nextTasks)].slice(0, 5)), JSON.stringify(modifiedFiles.slice(0, 15)), hasMetadata ? JSON.stringify(metadata) : null);
+      INSERT INTO sessions (project, last_work, next_tasks, modified_files, issues, duration_minutes)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(project, lastWork, JSON.stringify([...new Set(nextTasks)].slice(0, 5)), JSON.stringify(modifiedFiles.slice(0, 15)), hasMetadata ? JSON.stringify(metadata) : null, durationMinutes);
         // 활성 컨텍스트 업데이트
         db.prepare(`
       INSERT OR REPLACE INTO active_context (project, current_state, recent_files, updated_at)
@@ -588,6 +729,35 @@ async function main() {
             }
             catch { /* project_context table may not exist */ }
         }
+        // 고품질 자동 메모리 추출 (v1.10 노이즈 제거 정책 유지하면서 가치 있는 것만)
+        // - decisions: 의미있는 의사결정 (importance=7)
+        // - commits: feat/fix만 (importance=6)
+        // - 동일 content 중복 방지 (검색해서 없을 때만 INSERT)
+        try {
+            const memoryDupCheck = db.prepare('SELECT id FROM memories WHERE project = ? AND content = ? LIMIT 1');
+            const memoryInsert = db.prepare(`
+        INSERT INTO memories (content, memory_type, tags, project, importance)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+            for (const decision of decisions) {
+                if (decision.length < 15)
+                    continue;
+                if (!memoryDupCheck.get(project, decision)) {
+                    memoryInsert.run(decision, 'decision', JSON.stringify(['auto-extracted']), project, 7);
+                }
+            }
+            // feat/fix 커밋만 (chore, docs, style은 학습 가치 낮음)
+            for (const commit of commitMessages) {
+                if (!/^(feat|fix)(\(.+\))?:/i.test(commit))
+                    continue;
+                if (commit.length < 20)
+                    continue;
+                if (!memoryDupCheck.get(project, commit)) {
+                    memoryInsert.run(commit, 'learning', JSON.stringify(['auto-extracted', 'commit']), project, 6);
+                }
+            }
+        }
+        catch { /* memories table issue, skip */ }
         // 세션 임베딩 사전 생성 (search_sessions 성능 최적화)
         try {
             const lastSession = db.prepare('SELECT id FROM sessions WHERE project = ? ORDER BY timestamp DESC LIMIT 1').get(project);

package/dist/hooks/session-start.js

@@ -72,6 +72,7 @@ function loadContext(dbPath, project) {
         return null;
     try {
         const db = new Database(dbPath);
+        db.pragma('journal_mode = WAL'); // 다중 hook 프로세스 동시성 보장
         // 노이즈 메모리 자동 정리
         cleanupNoiseMemories(db);
         const lines = [`# ${project} - Session Resumed\n`];

package/dist/hooks/user-prompt-submit.js

@@ -46,14 +46,19 @@ function getProject(cwd, workspaceRoot) {
 }
 // ===== 과거 참조 자동 감지 =====
 const PAST_REFERENCE_PATTERNS = [
-    // 한국어
+    // 한국어 - 시간 참조
     /(?:저번에|전에|이전에|그때|지난번에|예전에|아까)\s+(.+?)(?:\s*(?:어떻게|뭐|무엇|왜|어디|언제))/,
     /(?:했던|했었던|만들었던|수정했던|구현했던|해결했던)\s*(.+)/,
     /(?:지난|이전|전)\s*(?:세션|작업|시간|번).*?(?:에서|때)\s*(.+)/,
+    // 한국어 - 보유/기억 질문 ("내꺼 GCP 코인 정보 가지고 있나?")
+    /(?:내|내꺼|우리)\s+(.+?)\s+(?:가지고\s*있|있어|있나|있지|있냐|남아|남았|저장)/,
+    /(.+?)\s+(?:기억해|기억하고|기억나|알고\s*있|아는)/,
+    /(?:저장한|기록한|적어둔|메모한|남긴)\s+(.+)/,
     // 영어
     /(?:last time|before|previously|earlier)\s+(?:.*?)\s*((?:how|what|why|where|when).*)/i,
     /(?:did we|did I|have we|have I)\s+(.+)\s+(?:before|last time|earlier)/i,
-    /(?:remember when|recall when)\s+(.+)/i,
+    /(?:remember when|recall when|do you remember|do you recall)\s+(.+)/i,
+    /(?:do you have|do you know|got)\s+(.+?)\s+(?:info|information|saved|stored|record)/i,
 ];
 function extractPastKeywords(prompt) {
     for (const pattern of PAST_REFERENCE_PATTERNS) {
@@ -176,6 +181,7 @@ const MAX_DIRECTIVES = 20;
 function extractAndSaveDirectives(dbPath, project, prompt) {
     try {
         const db = new Database(dbPath);
+        db.pragma('journal_mode = WAL'); // 다중 hook 프로세스 동시성 보장
         for (const { pattern, priority } of DIRECTIVE_PATTERNS) {
             const match = prompt.match(pattern);
             if (match && match[1]) {

package/dist/index.js

@@ -22,11 +22,23 @@ import { mkdirSync, existsSync } from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import Database from 'better-sqlite3';
-// @ts-ignore - transformers.js
-import { pipeline, env } from '@xenova/transformers';
-// 모델 캐시 설정
-env.cacheDir = path.join(process.env.HOME || '/tmp', '.cache', 'transformers');
-env.allowLocalModels = true;
+// @xenova/transformers - 동적 import (sharp 의존성 문제 방지)
+let transformersModule = null;
+async function loadTransformers() {
+    if (transformersModule)
+        return transformersModule;
+    try {
+        // @ts-ignore - transformers.js
+        const mod = await import('@xenova/transformers');
+        mod.env.cacheDir = path.join(process.env.HOME || '/tmp', '.cache', 'transformers');
+        mod.env.allowLocalModels = true;
+        transformersModule = mod;
+        return mod;
+    }
+    catch {
+        return null;
+    }
+}
 // 기본 경로 설정 (자동 감지)
 function detectWorkspaceRoot() {
     // 1. 환경변수가 설정되어 있으면 사용
@@ -234,7 +246,10 @@ async function initEmbedding() {
     if (embeddingPipeline)
         return;
     try {
-        embeddingPipeline = await pipeline('feature-extraction', 'Xenova/multilingual-e5-small');
+        const mod = await loadTransformers();
+        if (!mod)
+            return;
+        embeddingPipeline = await mod.pipeline('feature-extraction', 'Xenova/multilingual-e5-small');
     }
     catch (error) {
         console.error('Failed to load embedding model:', error);
@@ -396,54 +411,54 @@ const tools = [
     // ===== 1. 세션/컨텍스트 (4개) =====
     {
         name: 'session_start',
-        description: '세션 시작 시 프로젝트 컨텍스트를 로드합니다. Hook에서 자동 호출되지만 수동 호출도 가능합니다.',
+        description: 'Load project context at the beginning of a session. Typically auto-invoked by the SessionStart hook, but can be called manually. Returns the project\'s tech stack, recent activity, pending tasks, and active blockers as a compressed context payload (~650 tokens). Read-only — does not modify any state. Use this instead of project_status when you need the full session bootstrap context.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                compact: { type: 'boolean', description: '간결한 포맷 (기본: true)' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                compact: { type: 'boolean', description: 'Return compressed format (default: true). Set false for verbose output.' }
             },
             required: ['project']
         }
     },
     {
         name: 'session_end',
-        description: '세션 종료 시 현재 상태를 저장합니다. 다음 세션에서 자동 복구됩니다.',
+        description: 'Save the current session state before ending a conversation. Persists a summary, completed work, next steps, modified files, and blockers to SQLite. The saved state is automatically restored by session_start in the next session. Side effects: writes to the sessions table and updates the active_context record for the project. Idempotent — calling multiple times overwrites the previous session record.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                summary: { type: 'string', description: '이번 세션 요약 (1-2줄)' },
-                workDone: { type: 'string', description: '완료한 작업' },
-                nextSteps: { type: 'array', items: { type: 'string' }, description: '다음 할 일' },
-                modifiedFiles: { type: 'array', items: { type: 'string' }, description: '수정한 파일' },
-                blockers: { type: 'string', description: '막힌 것/이슈' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                summary: { type: 'string', description: 'One-line summary of this session' },
+                workDone: { type: 'string', description: 'Description of completed work' },
+                nextSteps: { type: 'array', items: { type: 'string' }, description: 'Ordered list of next tasks to pick up' },
+                modifiedFiles: { type: 'array', items: { type: 'string' }, description: 'Files modified during this session' },
+                blockers: { type: 'string', description: 'Current blockers or issues (null if none)' }
             },
             required: ['project', 'summary']
         }
     },
     {
         name: 'session_history',
-        description: '프로젝트의 세션 이력을 조회합니다.',
+        description: 'Retrieve past session records for a project. Returns an array of session objects ordered by most recent first, each containing summary, work done, modified files, and verification results. Read-only. Use search_sessions instead when you need semantic/keyword matching rather than a chronological list.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                limit: { type: 'number', description: '조회 개수 (기본: 5)' },
-                days: { type: 'number', description: '최근 N일 (기본: 7)' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                limit: { type: 'number', description: 'Max records to return (default: 5)' },
+                days: { type: 'number', description: 'Only return sessions from the last N days (default: 7)' }
             },
             required: ['project']
         }
     },
     {
         name: 'search_sessions',
-        description: '세션 이력을 시맨틱 검색합니다. "저번에 인증 작업했을 때" 같은 검색에 유용합니다.',
+        description: 'Semantic search across session history using multilingual embeddings (94+ languages). Finds past sessions by meaning, not just keywords — e.g. "when I worked on authentication" matches sessions about login, OAuth, JWT. Falls back to FTS5 keyword search when embeddings are unavailable. Read-only. Use session_history instead when you just need the N most recent sessions.',
         inputSchema: {
             type: 'object',
             properties: {
-                query: { type: 'string', description: '검색어' },
-                project: { type: 'string', description: '프로젝트 (선택)' },
-                limit: { type: 'number', description: '결과 개수 (기본: 5)' }
+                query: { type: 'string', description: 'Natural language search query' },
+                project: { type: 'string', description: 'Filter by project (optional)' },
+                limit: { type: 'number', description: 'Max results to return (default: 5)' }
             },
             required: ['query']
         }
@@ -451,42 +466,42 @@ const tools = [
     // ===== 2. 프로젝트 관리 (4개) =====
     {
         name: 'project_status',
-        description: '프로젝트 진행 현황을 조회합니다. 완성도, 태스크, 최근 변경 등.',
+        description: 'Get a project\'s current status including completion percentage, task breakdown (pending/in-progress/done/blocked), recent session activity, and active blockers. Read-only. Returns a structured JSON object. Use session_start instead when bootstrapping a new conversation; use this for mid-session status checks.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' }
             },
             required: ['project']
         }
     },
     {
         name: 'project_init',
-        description: '새 프로젝트를 초기화합니다. 컨텍스트 테이블에 기본 정보를 저장합니다.',
+        description: 'Initialize a new project in the continuity system. Creates records in the project_context and active_context tables. Auto-detects tech stack from package.json/pubspec.yaml/build.gradle if present. Side effects: writes to SQLite. Idempotent — safe to call on an already-initialized project (updates existing record). Call this once when adding a new project, then use session_start for subsequent sessions.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                techStack: { type: 'object', description: '기술 스택 (자동 감지 가능)' },
-                description: { type: 'string', description: '프로젝트 설명' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                techStack: { type: 'object', description: 'Tech stack override {framework, language, database, ...}. Omit for auto-detection.' },
+                description: { type: 'string', description: 'Human-readable project description' }
             },
             required: ['project']
         }
     },
     {
         name: 'project_analyze',
-        description: '프로젝트를 분석하여 기술 스택, 구조 등을 자동 감지합니다.',
+        description: 'Auto-detect a project\'s tech stack, framework, platform (Web/Android/Flutter/Server), directory structure, and dependency count by scanning its files. Read-only — does not persist results. Returns a structured analysis object. Use project_init to persist the detected configuration.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' }
             },
             required: ['project']
         }
     },
     {
         name: 'list_projects',
-        description: 'apps/ 디렉토리의 모든 프로젝트 목록을 반환합니다.',
+        description: 'List all projects under the apps/ directory with their platform type (Web/Android/Flutter), initialization status, and whether session context exists. Read-only. Returns an array of project summary objects. No parameters required.',
         inputSchema: {
             type: 'object',
             properties: {}
@@ -495,52 +510,52 @@ const tools = [
     // ===== 3. 태스크/백로그 (4개) =====
     {
         name: 'task_add',
-        description: '새 태스크를 추가합니다.',
+        description: 'Add a new task to a project\'s backlog. Tasks are persisted in SQLite with priority ranking and optional file associations. Side effects: inserts into the tasks table. Returns the created task ID. Use task_list to view existing tasks before adding duplicates. Use task_suggest to auto-generate tasks from code comments (TODO/FIXME).',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                title: { type: 'string', description: '태스크 제목' },
-                description: { type: 'string', description: '상세 설명' },
-                priority: { type: 'number', description: '우선순위 1-10 (기본: 5)' },
-                relatedFiles: { type: 'array', items: { type: 'string' }, description: '관련 파일' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                title: { type: 'string', description: 'Task title (concise, actionable)' },
+                description: { type: 'string', description: 'Detailed description (optional)' },
+                priority: { type: 'number', description: 'Priority 1-10 where 10 is highest (default: 5)' },
+                relatedFiles: { type: 'array', items: { type: 'string' }, description: 'Associated file paths (optional)' }
             },
             required: ['project', 'title']
         }
     },
     {
         name: 'task_update',
-        description: '태스크 상태를 변경합니다.',
+        description: 'Update a task\'s status. Valid transitions: pending → in_progress → done, or any state → blocked. Setting status to "done" automatically records a completion timestamp. Side effects: updates the tasks table. Idempotent. Returns success/failure and whether the row was actually modified.',
         inputSchema: {
             type: 'object',
             properties: {
-                taskId: { type: 'number', description: '태스크 ID' },
-                status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'blocked'], description: '새 상태' },
-                note: { type: 'string', description: '메모 (완료 시 결과 등)' }
+                taskId: { type: 'number', description: 'Task ID (from task_add or task_list)' },
+                status: { type: 'string', enum: ['pending', 'in_progress', 'done', 'blocked'], description: 'New status' },
+                note: { type: 'string', description: 'Optional note (e.g. completion summary or block reason)' }
             },
             required: ['taskId', 'status']
         }
     },
     {
         name: 'task_list',
-        description: '프로젝트의 태스크 목록을 조회합니다.',
+        description: 'List tasks for a project, filtered by status. Returns an array of task objects with id, title, description, status, priority, related files, and timestamps, plus a summary count by status. Read-only. Default filter is "pending" — pass status="all" to see everything.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                status: { type: 'string', enum: ['all', 'pending', 'in_progress', 'done', 'blocked'], description: '필터 (기본: pending)' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                status: { type: 'string', enum: ['all', 'pending', 'in_progress', 'done', 'blocked'], description: 'Status filter (default: "pending")' }
             },
             required: ['project']
         }
     },
     {
         name: 'task_suggest',
-        description: '코드 분석 기반으로 TODO, FIXME 등에서 태스크를 추출하여 제안합니다.',
+        description: 'Scan project source files for TODO, FIXME, HACK, and XXX comments and return them as suggested tasks. Read-only — does not create tasks automatically. Review the suggestions and use task_add to persist the ones you want. Optionally scope the scan to a specific subdirectory.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                path: { type: 'string', description: '특정 경로만 분석 (선택)' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                path: { type: 'string', description: 'Subdirectory path to limit the scan (optional, e.g. "src/components")' }
             },
             required: ['project']
         }
@@ -548,41 +563,41 @@ const tools = [
     // ===== 4. 솔루션 아카이브 (3개) =====
     {
         name: 'solution_record',
-        description: '에러 해결 방법을 기록합니다. 나중에 같은 에러 발생 시 자동 검색됩니다.',
+        description: 'Record an error-solution pair in the solution archive. Associates an error signature (the searchable key), optional full error message, the fix, and related files. Automatically extracts keywords for FTS5 indexing. Side effects: inserts into the solutions table. Use solution_find to check for existing solutions before recording a duplicate.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                errorSignature: { type: 'string', description: '에러 패턴/시그니처 (검색 키)' },
-                errorMessage: { type: 'string', description: '전체 에러 메시지' },
-                solution: { type: 'string', description: '해결 방법' },
-                relatedFiles: { type: 'array', items: { type: 'string' }, description: '관련 파일' }
+                project: { type: 'string', description: 'Project name (optional — omit for cross-project solutions)' },
+                errorSignature: { type: 'string', description: 'Error pattern/signature used as the search key (e.g. "ENOENT: no such file", "WorkManager not initialized")' },
+                errorMessage: { type: 'string', description: 'Full error message or stack trace (optional)' },
+                solution: { type: 'string', description: 'Step-by-step fix description' },
+                relatedFiles: { type: 'array', items: { type: 'string' }, description: 'Files that were modified to fix the error' }
             },
             required: ['errorSignature', 'solution']
         }
     },
     {
         name: 'solution_find',
-        description: '유사한 에러의 해결 방법을 검색합니다. semantic=true로 시맨틱 검색 가능.',
+        description: 'Search the solution archive for previously resolved errors. Matches against error signatures, messages, and keywords using FTS5. Set semantic=true to enable embedding-based similarity search for better recall across different error phrasings. Read-only. Returns matched solutions with their fix descriptions and related files. Use solution_suggest instead if you want AI-powered fix recommendations.',
         inputSchema: {
             type: 'object',
             properties: {
-                query: { type: 'string', description: '에러 메시지 또는 키워드' },
-                project: { type: 'string', description: '프로젝트 (선택)' },
-                limit: { type: 'number', description: '결과 개수 (기본: 3)' },
-                semantic: { type: 'boolean', description: '시맨틱 검색 사용 (기본: false, 임베딩 기반)' }
+                query: { type: 'string', description: 'Error message, signature, or natural language description of the problem' },
+                project: { type: 'string', description: 'Filter by project (optional — also includes cross-project solutions)' },
+                limit: { type: 'number', description: 'Max results to return (default: 3)' },
+                semantic: { type: 'boolean', description: 'Enable semantic/embedding search for fuzzy matching (default: false)' }
             },
             required: ['query']
         }
     },
     {
         name: 'solution_suggest',
-        description: '과거 솔루션 기반으로 현재 에러에 대한 해결책을 AI가 제안합니다.',
+        description: 'Get AI-powered fix suggestions for a current error based on the solution archive. Retrieves the most relevant past solutions and generates a contextual recommendation. Read-only. Use solution_find for direct archive lookup without AI synthesis; use solution_record after fixing an error to grow the archive.',
         inputSchema: {
             type: 'object',
             properties: {
-                errorMessage: { type: 'string', description: '현재 에러 메시지' },
-                project: { type: 'string', description: '프로젝트' }
+                errorMessage: { type: 'string', description: 'The current error message or stack trace' },
+                project: { type: 'string', description: 'Project name for context (optional)' }
             },
             required: ['errorMessage']
         }
@@ -590,35 +605,35 @@ const tools = [
     // ===== 5. 검증/품질 (3개) =====
     {
         name: 'verify_build',
-        description: '프로젝트 빌드를 실행합니다.',
+        description: 'Run the project\'s build command (auto-detected per platform: "pnpm build" for Web, "flutter build" for Flutter, "./gradlew assembleDebug" for Android). Side effects: executes a shell command in the project directory with a 5-minute timeout. Returns {success, output} with the last 1000 chars of stdout/stderr. Use verify_all to run build + test + lint together.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' }
             },
             required: ['project']
         }
     },
     {
         name: 'verify_test',
-        description: '프로젝트 테스트를 실행합니다.',
+        description: 'Run the project\'s test suite (auto-detected per platform: "pnpm test:run" for Web, "flutter test" for Flutter, "./gradlew test" for Android). Optionally scope to a specific test file or directory. Side effects: executes a shell command with a 5-minute timeout. Returns {success, output}. Use verify_all to run build + test + lint together.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                testPath: { type: 'string', description: '특정 테스트 파일/폴더 (선택)' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                testPath: { type: 'string', description: 'Specific test file or directory to run (optional — runs all tests if omitted)' }
             },
             required: ['project']
         }
     },
     {
         name: 'verify_all',
-        description: '빌드 + 테스트 + 린트를 한 번에 실행합니다.',
+        description: 'Run build, test, and lint sequentially for a project. Auto-detects platform-specific commands. Side effects: executes up to 3 shell commands with 5-minute timeouts each. Returns per-gate results and an overall pass/fail status. Use this as a quality gate before committing or ending a session. Use verify_build or verify_test individually when you only need one check.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '프로젝트 이름' },
-                stopOnFail: { type: 'boolean', description: '실패 시 중단 (기본: false)' }
+                project: { type: 'string', description: 'Project name (must match a directory under apps/)' },
+                stopOnFail: { type: 'boolean', description: 'Abort remaining gates on first failure (default: false — runs all gates)' }
             },
             required: ['project']
         }
@@ -626,117 +641,117 @@ const tools = [
     // ===== 6. 메모리 시스템 (4개) - v4 신규 =====
     {
         name: 'memory_store',
-        description: '메모리를 저장합니다. 타입별로 분류되어 나중에 체계적으로 검색 가능합니다.',
+        description: 'Store a piece of knowledge in the memory system. Memories are typed (observation, decision, learning, error, pattern), tagged, and automatically embedded for semantic retrieval. Side effects: inserts into the memories table and asynchronously generates a vector embedding. If relatedTo is provided, also creates a knowledge graph edge. Returns the new memory ID. Use memory_search to verify no duplicate exists before storing.',
         inputSchema: {
             type: 'object',
             properties: {
-                content: { type: 'string', description: '저장할 내용' },
+                content: { type: 'string', description: 'The knowledge content to store' },
                 type: {
                     type: 'string',
                     enum: ['observation', 'decision', 'learning', 'error', 'pattern'],
-                    description: '메모리 타입: observation(발견), decision(결정), learning(학습), error(에러), pattern(패턴)'
+                    description: 'Memory type: observation (discovery/finding), decision (architecture/tech choice), learning (new knowledge), error (error encountered), pattern (code convention)'
                 },
-                project: { type: 'string', description: '관련 프로젝트 (선택)' },
-                tags: { type: 'array', items: { type: 'string' }, description: '태그 (검색용)' },
-                importance: { type: 'number', description: '중요도 1-10 (기본: 5)' },
-                relatedTo: { type: 'number', description: '연결할 기존 메모리 ID (선택)' }
+                project: { type: 'string', description: 'Associated project name (optional — omit for cross-project knowledge)' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags for filtering (e.g. ["auth", "performance"])' },
+                importance: { type: 'number', description: 'Importance score 1-10 where 10 is critical (default: 5)' },
+                relatedTo: { type: 'number', description: 'ID of an existing memory to link via knowledge graph (optional)' }
             },
             required: ['content', 'type']
         }
     },
     {
         name: 'memory_search',
-        description: '메모리를 검색합니다. 기본은 인덱스만 반환 (토큰 절약). detail=true로 전체 내용 확인.',
+        description: 'Search stored memories using FTS5 full-text search or semantic/embedding similarity. Default mode returns compact index entries (id, type, truncated content) to save tokens — set detail=true for full content. Supports filtering by type, project, tags, and minimum importance. Read-only. Use memory_get to fetch full content for specific IDs found in search results. Use memory_related to explore graph connections from a known memory.',
         inputSchema: {
             type: 'object',
             properties: {
-                query: { type: 'string', description: '검색어 (자연어)' },
+                query: { type: 'string', description: 'Natural language search query' },
                 type: {
                     type: 'string',
                     enum: ['observation', 'decision', 'learning', 'error', 'pattern', 'all'],
-                    description: '메모리 타입 필터 (기본: all)'
+                    description: 'Filter by memory type (default: "all")'
                 },
-                project: { type: 'string', description: '프로젝트 필터 (선택)' },
-                tags: { type: 'array', items: { type: 'string' }, description: '태그 필터 (선택)' },
-                semantic: { type: 'boolean', description: '시맨틱 검색 사용 (기본: false, 임베딩 기반)' },
-                minImportance: { type: 'number', description: '최소 중요도 (기본: 1)' },
-                limit: { type: 'number', description: '결과 개수 (기본: 10)' },
-                detail: { type: 'boolean', description: 'true면 전체 content, false면 요약 인덱스만 (기본: false)' }
+                project: { type: 'string', description: 'Filter by project (optional)' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Filter by tags — matches if any tag is present (optional)' },
+                semantic: { type: 'boolean', description: 'Use embedding-based semantic search instead of keyword FTS5 (default: false)' },
+                minImportance: { type: 'number', description: 'Minimum importance threshold 1-10 (default: 1)' },
+                limit: { type: 'number', description: 'Max results to return (default: 10)' },
+                detail: { type: 'boolean', description: 'Return full content per memory (default: false — returns compact index only)' }
             },
             required: ['query']
         }
     },
     {
         name: 'memory_get',
-        description: '메모리 ID로 전체 내용을 조회합니다. memory_search 결과에서 상세 내용 확인 시 사용.',
+        description: 'Retrieve full content for one or more memories by ID. Designed as a follow-up to memory_search: first search to find relevant IDs, then use memory_get to load full details. Read-only. Accepts up to 20 IDs per call. Returns an array of complete memory objects including content, type, tags, importance, timestamps, and access count.',
         inputSchema: {
             type: 'object',
             properties: {
-                ids: { type: 'array', items: { type: 'number' }, description: '조회할 메모리 ID 배열 (최대 20개)' }
+                ids: { type: 'array', items: { type: 'number' }, description: 'Array of memory IDs to retrieve (max 20)' }
             },
             required: ['ids']
         }
     },
     {
         name: 'memory_related',
-        description: '특정 메모리와 관련된 메모리들을 찾습니다. 지식 그래프 + 시맨틱 유사도 결합.',
+        description: 'Find memories related to a given memory using knowledge graph traversal and/or semantic similarity. Combines two strategies: (1) graph edges created via graph_connect or memory_store\'s relatedTo, and (2) cosine similarity between embeddings. Read-only. Use graph_explore for pure graph traversal with depth control; use memory_search for text-based search.',
         inputSchema: {
             type: 'object',
             properties: {
-                memoryId: { type: 'number', description: '기준 메모리 ID' },
-                includeGraph: { type: 'boolean', description: '지식 그래프 관계 포함 (기본: true)' },
-                includeSemantic: { type: 'boolean', description: '시맨틱 유사 메모리 포함 (기본: true)' },
-                limit: { type: 'number', description: '결과 개수 (기본: 10)' }
+                memoryId: { type: 'number', description: 'The anchor memory ID to find relations for' },
+                includeGraph: { type: 'boolean', description: 'Include knowledge graph connections (default: true)' },
+                includeSemantic: { type: 'boolean', description: 'Include semantically similar memories via embeddings (default: true)' },
+                limit: { type: 'number', description: 'Max results to return (default: 10)' }
             },
             required: ['memoryId']
         }
     },
     {
         name: 'memory_stats',
-        description: '메모리 시스템 통계를 조회합니다. 타입별, 프로젝트별 분포 등.',
+        description: 'Get aggregate statistics about the memory system: total count, breakdown by type (observation/decision/learning/error/pattern), breakdown by project, top 5 most accessed memories, and 5 most recent entries. Read-only. Useful for understanding memory distribution and system health. Optionally scope to a single project.',
         inputSchema: {
             type: 'object',
             properties: {
-                project: { type: 'string', description: '특정 프로젝트만 (선택)' }
+                project: { type: 'string', description: 'Scope statistics to a single project (optional — omit for global stats)' }
             }
         }
     },
     // ===== 7. 지식 그래프 (2개) - v4 신규 =====
     {
         name: 'graph_connect',
-        description: '두 메모리 사이에 관계를 생성합니다. 지식 그래프 구축용.',
+        description: 'Create a directed edge between two memories in the knowledge graph. Supports 7 relation types for structured knowledge organization. Side effects: inserts or replaces a row in memory_relations (upsert on sourceId+targetId+relation). Use memory_related to discover existing connections; use graph_explore to traverse the graph from a starting node.',
         inputSchema: {
             type: 'object',
             properties: {
-                sourceId: { type: 'number', description: '출발 메모리 ID' },
-                targetId: { type: 'number', description: '도착 메모리 ID' },
+                sourceId: { type: 'number', description: 'Source memory ID (the "from" node)' },
+                targetId: { type: 'number', description: 'Target memory ID (the "to" node)' },
                 relation: {
                     type: 'string',
                     enum: ['related_to', 'causes', 'solves', 'depends_on', 'contradicts', 'extends', 'example_of'],
-                    description: '관계 유형: related_to(관련), causes(원인), solves(해결), depends_on(의존), contradicts(상충), extends(확장), example_of(예시)'
+                    description: 'Edge type: related_to (general association), causes (A causes B), solves (A fixes B), depends_on (A requires B), contradicts (A conflicts with B), extends (A builds on B), example_of (A demonstrates B)'
                 },
-                strength: { type: 'number', description: '관계 강도 0-1 (기본: 1.0)' }
+                strength: { type: 'number', description: 'Connection strength 0.0-1.0 (default: 1.0). Lower values indicate weaker associations.' }
             },
             required: ['sourceId', 'targetId', 'relation']
         }
     },
     {
         name: 'graph_explore',
-        description: '지식 그래프를 탐색합니다. 특정 메모리부터 연결된 모든 메모리를 깊이 우선 탐색.',
+        description: 'Traverse the knowledge graph from a starting memory using depth-first search. Returns all connected memories up to the specified depth, with their relation types, strengths, and directions. Read-only. Supports filtering by relation type and traversal direction. Use memory_related instead for a combined graph+semantic approach; use graph_connect to add new edges.',
         inputSchema: {
             type: 'object',
             properties: {
-                memoryId: { type: 'number', description: '시작 메모리 ID' },
-                depth: { type: 'number', description: '탐색 깊이 (기본: 2, 최대: 4)' },
+                memoryId: { type: 'number', description: 'Starting memory ID for graph traversal' },
+                depth: { type: 'number', description: 'Maximum traversal depth 1-4 (default: 2). Higher values return more results but may be slower.' },
                 relation: {
                     type: 'string',
                     enum: ['related_to', 'causes', 'solves', 'depends_on', 'contradicts', 'extends', 'example_of', 'all'],
-                    description: '관계 유형 필터 (기본: all)'
+                    description: 'Filter by relation type (default: "all")'
                 },
                 direction: {
                     type: 'string',
                     enum: ['outgoing', 'incoming', 'both'],
-                    description: '탐색 방향 (기본: both)'
+                    description: 'Traversal direction — outgoing (A→B), incoming (B→A), or both (default: "both")'
                 }
             },
             required: ['memoryId']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-session-continuity-mcp",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "Session Continuity for Claude Code - Never re-explain your project again",
   "type": "module",
   "main": "dist/index.js",