claude-session-continuity-mcp 1.4.3 → 1.5.0

package/README.md

@@ -1,4 +1,4 @@
-# claude-session-continuity-mcp (v1.4.3)
+# claude-session-continuity-mcp (v1.5.0)
 
 > **Zero Re-explanation Session Continuity for Claude Code** — Automatic context capture + semantic search
 
@@ -64,7 +64,7 @@ npm install claude-session-continuity-mcp
 1. Registers MCP server in `~/.claude.json`
 2. Installs Claude Hooks in `~/.claude/settings.local.json`
 
-> **v1.4.3+:** Works with both local and global installation. Hooks use `npm exec --` which finds local bin scripts first, then global.
+> **v1.5.0+:** Full lifecycle hooks! SessionStart, PostToolUse (file tracking), PreCompact (save before compression), and Stop (auto-save on exit). Works with both local and global installation.
 
 ### What Gets Installed
 
@@ -85,19 +85,25 @@ npm install claude-session-continuity-mcp
 {
   "hooks": {
     "SessionStart": [{ "hooks": [{ "type": "command", "command": "npm exec -- claude-hook-session-start" }] }],
-    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "npm exec -- claude-hook-user-prompt" }] }]
+    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "npm exec -- claude-hook-user-prompt" }] }],
+    "PostToolUse": [{ "matcher": { "tool_name": "Edit|Write" }, "hooks": [{ "type": "command", "command": "npm exec -- claude-hook-post-tool" }] }],
+    "PreCompact": [{ "hooks": [{ "type": "command", "command": "npm exec -- claude-hook-pre-compact" }] }],
+    "Stop": [{ "hooks": [{ "type": "command", "command": "npm exec -- claude-hook-session-end" }] }]
   }
 }
 ```
 
-**Note (v1.4.3+):** Hooks use `npm exec --` which finds local `node_modules/.bin` first, then falls back to global. Works with both local and global installation.
+**Note (v1.5.0+):** Full lifecycle coverage with 5 hooks. Uses `npm exec --` which finds local `node_modules/.bin` first.
 
-### Installed Hooks
+### Installed Hooks (v1.5.0+)
 
 | Hook | Command | Function |
 |------|---------|----------|
-| `SessionStart` | `npm exec -- claude-hook-session-start` | Auto-loads project context on session start |
-| `UserPromptSubmit` | `npm exec -- claude-hook-user-prompt` | Auto-injects relevant memories per prompt |
+| `SessionStart` | `claude-hook-session-start` | Auto-loads project context on session start |
+| `UserPromptSubmit` | `claude-hook-user-prompt` | Auto-injects relevant memories per prompt |
+| `PostToolUse` | `claude-hook-post-tool` | Tracks file changes (Edit, Write) automatically |
+| `PreCompact` | `claude-hook-pre-compact` | Saves important context before compression |
+| `Stop` | `claude-hook-session-end` | Auto-saves session on exit (no manual call needed) |
 
 ### Manual Hook Management
 
@@ -132,6 +138,10 @@ After installation, restart Claude Code to activate the hooks.
 | ✅ **Integrated Verification** | One-click build/test/lint execution |
 | 📋 **Task Management** | Priority-based task management |
 | 🔧 **Solution Archive** | Auto-search error solutions |
+| 📁 **File Change Tracking** | **(v1.5.0)** Auto-track Edit/Write tool usage |
+| 💾 **Auto Backup** | **(v1.5.0)** Daily SQLite backup (max 5) |
+| 🛡️ **PreCompact Save** | **(v1.5.0)** Save context before compression |
+| 🚪 **Auto Session End** | **(v1.5.0)** No manual session_end needed |
 
 ---
 

package/dist/db/database.d.ts

@@ -6,3 +6,22 @@ export declare const db: DatabaseType;
 export declare let contentFilterPatterns: ContentFilterPattern[];
 export declare function initDatabase(): void;
 export declare function loadContentFilterPatterns(): void;
+/**
+ * DB 백업 생성
+ * - 최대 5개 유지
+ * - 하루에 한 번만 백업
+ */
+export declare function createBackup(): string | null;
+/**
+ * 백업에서 복원
+ */
+export declare function restoreFromBackup(backupPath: string): boolean;
+/**
+ * 백업 목록 조회
+ */
+export declare function listBackups(): Array<{
+    name: string;
+    path: string;
+    date: string;
+    size: number;
+}>;

package/dist/db/database.js

@@ -263,6 +263,103 @@ export function loadContentFilterPatterns() {
         contentFilterPatterns = [];
     }
 }
+// ===== 백업 시스템 =====
+const BACKUP_DIR = path.join(os.homedir(), '.claude', 'backups');
+const MAX_BACKUPS = 5;
+/**
+ * DB 백업 생성
+ * - 최대 5개 유지
+ * - 하루에 한 번만 백업
+ */
+export function createBackup() {
+    try {
+        if (!fs.existsSync(BACKUP_DIR)) {
+            fs.mkdirSync(BACKUP_DIR, { recursive: true });
+        }
+        const today = new Date().toISOString().slice(0, 10);
+        const backupPath = path.join(BACKUP_DIR, `sessions-${today}.db`);
+        // 오늘 이미 백업했으면 스킵
+        if (fs.existsSync(backupPath)) {
+            return backupPath;
+        }
+        // SQLite 백업 (VACUUM INTO)
+        db.exec(`VACUUM INTO '${backupPath}'`);
+        // 오래된 백업 삭제
+        cleanupOldBackups();
+        return backupPath;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 오래된 백업 삭제 (MAX_BACKUPS 개수 유지)
+ */
+function cleanupOldBackups() {
+    try {
+        const files = fs.readdirSync(BACKUP_DIR)
+            .filter(f => f.startsWith('sessions-') && f.endsWith('.db'))
+            .map(f => ({
+            name: f,
+            path: path.join(BACKUP_DIR, f),
+            time: fs.statSync(path.join(BACKUP_DIR, f)).mtime.getTime()
+        }))
+            .sort((a, b) => b.time - a.time);
+        // MAX_BACKUPS 초과분 삭제
+        for (const file of files.slice(MAX_BACKUPS)) {
+            fs.unlinkSync(file.path);
+        }
+    }
+    catch {
+        // 무시
+    }
+}
+/**
+ * 백업에서 복원
+ */
+export function restoreFromBackup(backupPath) {
+    try {
+        if (!fs.existsSync(backupPath)) {
+            return false;
+        }
+        // 현재 DB 닫기
+        db.close();
+        // 백업으로 교체
+        fs.copyFileSync(backupPath, DB_PATH);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 백업 목록 조회
+ */
+export function listBackups() {
+    try {
+        if (!fs.existsSync(BACKUP_DIR)) {
+            return [];
+        }
+        return fs.readdirSync(BACKUP_DIR)
+            .filter(f => f.startsWith('sessions-') && f.endsWith('.db'))
+            .map(f => {
+            const filePath = path.join(BACKUP_DIR, f);
+            const stat = fs.statSync(filePath);
+            return {
+                name: f,
+                path: filePath,
+                date: f.replace('sessions-', '').replace('.db', ''),
+                size: stat.size
+            };
+        })
+            .sort((a, b) => b.date.localeCompare(a.date));
+    }
+    catch {
+        return [];
+    }
+}
 // 초기화
 initDatabase();
 loadContentFilterPatterns();
+// 시작 시 백업 생성 (하루 한 번)
+createBackup();

package/dist/hooks/install.js

@@ -110,8 +110,7 @@ function install() {
     const settings = loadSettings();
     // 기존 hooks 유지하면서 추가
     const hooks = settings.hooks || {};
-    // SessionStart Hook - npm exec로 실행 (로컬 + 글로벌 모두 지원)
-    // npm exec는 로컬 node_modules/.bin을 먼저 찾고, 없으면 글로벌에서 찾음
+    // SessionStart Hook - 세션 시작 시 컨텍스트 로드
     hooks.SessionStart = [
         {
             hooks: [
@@ -122,7 +121,7 @@ function install() {
             ]
         }
     ];
-    // UserPromptSubmit Hook - npm exec로 실행
+    // UserPromptSubmit Hook - 프롬프트 제출 시 관련 컨텍스트 주입
     hooks.UserPromptSubmit = [
         {
             hooks: [
@@ -133,11 +132,50 @@ function install() {
             ]
         }
     ];
+    // PostToolUse Hook - 파일 변경 시 자동 기록 (Edit, Write)
+    hooks.PostToolUse = [
+        {
+            matcher: {
+                tool_name: 'Edit|Write'
+            },
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'npm exec -- claude-hook-post-tool'
+                }
+            ]
+        }
+    ];
+    // PreCompact Hook - 컨텍스트 압축 전 중요 정보 저장
+    hooks.PreCompact = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'npm exec -- claude-hook-pre-compact'
+                }
+            ]
+        }
+    ];
+    // Stop Hook - 세션 종료 시 자동 저장
+    hooks.Stop = [
+        {
+            hooks: [
+                {
+                    type: 'command',
+                    command: 'npm exec -- claude-hook-session-end'
+                }
+            ]
+        }
+    ];
     settings.hooks = hooks;
     saveSettings(settings);
     console.log('✅ Hooks installed (npm exec mode - works with local or global install!)');
-    console.log('   SessionStart: npm exec -- claude-hook-session-start');
-    console.log('   UserPromptSubmit: npm exec -- claude-hook-user-prompt');
+    console.log('   SessionStart: context auto-load');
+    console.log('   UserPromptSubmit: relevant memory injection');
+    console.log('   PostToolUse: file change tracking (Edit, Write)');
+    console.log('   PreCompact: save before context compression');
+    console.log('   Stop: auto-save session on exit');
     console.log('');
     // ===== 2. MCP 서버 등록 =====
     console.log('📌 Step 2: Registering MCP Server...');
@@ -167,6 +205,9 @@ function uninstall() {
     // session-continuity 관련 Hook만 제거
     delete hooks.SessionStart;
     delete hooks.UserPromptSubmit;
+    delete hooks.PostToolUse;
+    delete hooks.PreCompact;
+    delete hooks.Stop;
     if (Object.keys(hooks).length === 0) {
         delete settings.hooks;
     }

package/dist/hooks/post-tool-use.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse Hook - 파일 변경 시 자동 기록
+ *
+ * Edit, Write 도구 사용 후 변경 사항을 메모리에 기록합니다.
+ */
+export {};

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

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * PostToolUse Hook - 파일 변경 시 자동 기록
+ *
+ * Edit, Write 도구 사용 후 변경 사항을 메모리에 기록합니다.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import Database from 'better-sqlite3';
+function getDbPath() {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+    }
+    return path.join(claudeDir, 'sessions.db');
+}
+function detectProject(cwd) {
+    const appsMatch = cwd.match(/apps[\/\\]([^\/\\]+)/);
+    if (appsMatch)
+        return appsMatch[1];
+    let current = cwd;
+    while (current !== path.parse(current).root) {
+        const pkgPath = path.join(current, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                return pkg.name || path.basename(current);
+            }
+            catch {
+                return path.basename(current);
+            }
+        }
+        current = path.dirname(current);
+    }
+    return path.basename(cwd);
+}
+function getFileExtension(filePath) {
+    return path.extname(filePath).slice(1).toLowerCase();
+}
+function categorizeChange(toolName, filePath, oldString, newString) {
+    const ext = getFileExtension(filePath);
+    const fileName = path.basename(filePath);
+    // 파일 타입별 분류
+    const isConfig = ['json', 'yaml', 'yml', 'toml', 'env'].includes(ext) || fileName.includes('config');
+    const isTest = filePath.includes('test') || filePath.includes('spec');
+    const isStyle = ['css', 'scss', 'less', 'styled'].some(s => filePath.includes(s));
+    const isComponent = ['tsx', 'jsx', 'vue', 'svelte'].includes(ext);
+    let changeType = 'code';
+    if (isConfig)
+        changeType = 'config';
+    else if (isTest)
+        changeType = 'test';
+    else if (isStyle)
+        changeType = 'style';
+    else if (isComponent)
+        changeType = 'component';
+    // 변경 요약 생성
+    let summary = '';
+    if (toolName === 'Write') {
+        summary = `Created ${fileName}`;
+    }
+    else if (toolName === 'Edit') {
+        if (oldString && newString) {
+            const added = newString.split('\n').length;
+            const removed = oldString.split('\n').length;
+            if (added > removed) {
+                summary = `Added ${added - removed} lines to ${fileName}`;
+            }
+            else if (removed > added) {
+                summary = `Removed ${removed - added} lines from ${fileName}`;
+            }
+            else {
+                summary = `Modified ${fileName}`;
+            }
+        }
+        else {
+            summary = `Modified ${fileName}`;
+        }
+    }
+    return { changeType, summary };
+}
+async function main() {
+    try {
+        let inputData = '';
+        for await (const chunk of process.stdin) {
+            inputData += chunk;
+        }
+        const input = inputData ? JSON.parse(inputData) : {};
+        // Edit, Write 도구만 처리
+        const toolName = input.tool_name;
+        if (!toolName || !['Edit', 'Write'].includes(toolName)) {
+            process.exit(0);
+        }
+        const filePath = input.tool_input?.file_path;
+        if (!filePath) {
+            process.exit(0);
+        }
+        const cwd = input.cwd || process.cwd();
+        const project = detectProject(cwd);
+        const dbPath = getDbPath();
+        if (!fs.existsSync(dbPath)) {
+            process.exit(0);
+        }
+        const db = new Database(dbPath);
+        const { changeType, summary } = categorizeChange(toolName, filePath, input.tool_input?.old_string, input.tool_input?.new_string);
+        // 최근 파일 목록 업데이트
+        const activeStmt = db.prepare(`
+      INSERT OR REPLACE INTO active_context (project, recent_files, updated_at)
+      VALUES (
+        ?,
+        COALESCE(
+          (SELECT json_insert(
+            COALESCE(recent_files, '[]'),
+            '$[#]',
+            ?
+          ) FROM active_context WHERE project = ?),
+          json_array(?)
+        ),
+        datetime('now')
+      )
+    `);
+        try {
+            // 간단한 방식으로 recent_files 업데이트
+            const existing = db.prepare('SELECT recent_files FROM active_context WHERE project = ?').get(project);
+            let recentFiles = [];
+            if (existing?.recent_files) {
+                try {
+                    recentFiles = JSON.parse(existing.recent_files);
+                }
+                catch {
+                    recentFiles = [];
+                }
+            }
+            // 중복 제거하고 최신 파일 추가 (최대 10개)
+            recentFiles = recentFiles.filter(f => f !== filePath);
+            recentFiles.unshift(filePath);
+            recentFiles = recentFiles.slice(0, 10);
+            db.prepare(`
+        INSERT OR REPLACE INTO active_context (project, recent_files, updated_at)
+        VALUES (?, ?, datetime('now'))
+      `).run(project, JSON.stringify(recentFiles));
+        }
+        catch {
+            // 오류 시 무시
+        }
+        // 중요 변경사항은 메모리에 기록 (하루에 같은 파일 중복 방지)
+        const today = new Date().toISOString().slice(0, 10);
+        const existingMemory = db.prepare(`
+      SELECT id FROM memories
+      WHERE project = ?
+        AND content LIKE ?
+        AND date(created_at) = ?
+    `).get(project, `%${path.basename(filePath)}%`, today);
+        if (!existingMemory) {
+            db.prepare(`
+        INSERT INTO memories (content, memory_type, project, importance, tags)
+        VALUES (?, 'observation', ?, 3, ?)
+      `).run(`[File Change] ${summary}`, project, `auto-tracked,${changeType},${getFileExtension(filePath)}`);
+        }
+        db.close();
+        process.exit(0);
+    }
+    catch (e) {
+        process.exit(0);
+    }
+}
+main();

package/dist/hooks/pre-compact.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * PreCompact Hook - 컨텍스트 압축 전 중요 메모리 저장
+ *
+ * 컨텍스트가 압축되기 전에 현재 세션의 중요 정보를 메모리에 저장합니다.
+ */
+export {};

package/dist/hooks/pre-compact.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * PreCompact Hook - 컨텍스트 압축 전 중요 메모리 저장
+ *
+ * 컨텍스트가 압축되기 전에 현재 세션의 중요 정보를 메모리에 저장합니다.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import Database from 'better-sqlite3';
+function getDbPath() {
+    // 글로벌 DB 경로
+    const claudeDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+    }
+    return path.join(claudeDir, 'sessions.db');
+}
+function detectProject(cwd) {
+    // apps/ 하위 프로젝트 감지
+    const appsMatch = cwd.match(/apps[\/\\]([^\/\\]+)/);
+    if (appsMatch)
+        return appsMatch[1];
+    // package.json 기반
+    let current = cwd;
+    while (current !== path.parse(current).root) {
+        const pkgPath = path.join(current, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                return pkg.name || path.basename(current);
+            }
+            catch {
+                return path.basename(current);
+            }
+        }
+        current = path.dirname(current);
+    }
+    return path.basename(cwd);
+}
+function extractKeyPoints(transcript) {
+    const keyPoints = [];
+    // 최근 메시지에서 중요 패턴 추출
+    const recentMessages = transcript.slice(-20);
+    for (const msg of recentMessages) {
+        if (msg.role !== 'assistant')
+            continue;
+        const content = msg.content;
+        // 결정 사항 패턴
+        const decisionPatterns = [
+            /(?:decided|결정|선택)[^.]*\./gi,
+            /(?:will use|사용할)[^.]*\./gi,
+            /(?:approach|방식)[^.]*\./gi,
+        ];
+        for (const pattern of decisionPatterns) {
+            const matches = content.match(pattern);
+            if (matches) {
+                keyPoints.push(...matches.slice(0, 2));
+            }
+        }
+        // 에러 해결 패턴
+        const errorPatterns = [
+            /(?:fixed|수정|해결)[^.]*(?:error|bug|issue|오류|버그)[^.]*\./gi,
+            /(?:error|bug|issue|오류|버그)[^.]*(?:fixed|수정|해결)[^.]*\./gi,
+        ];
+        for (const pattern of errorPatterns) {
+            const matches = content.match(pattern);
+            if (matches) {
+                keyPoints.push(...matches.slice(0, 2));
+            }
+        }
+    }
+    // 중복 제거 및 길이 제한
+    const unique = [...new Set(keyPoints)].slice(0, 5);
+    return unique.map(p => p.slice(0, 200));
+}
+async function main() {
+    try {
+        let inputData = '';
+        for await (const chunk of process.stdin) {
+            inputData += chunk;
+        }
+        const input = inputData ? JSON.parse(inputData) : {};
+        const cwd = input.cwd || process.cwd();
+        const project = detectProject(cwd);
+        const dbPath = getDbPath();
+        if (!fs.existsSync(dbPath)) {
+            console.log('[PreCompact] No DB found, skipping');
+            process.exit(0);
+        }
+        const db = new Database(dbPath);
+        // 현재 활성 컨텍스트 저장
+        const activeStmt = db.prepare(`
+      INSERT OR REPLACE INTO active_context (project, current_state, updated_at)
+      VALUES (?, ?, datetime('now'))
+    `);
+        // transcript에서 핵심 포인트 추출
+        const keyPoints = input.transcript ? extractKeyPoints(input.transcript) : [];
+        if (keyPoints.length > 0) {
+            // 중요 메모리로 저장
+            const memoryStmt = db.prepare(`
+        INSERT INTO memories (content, memory_type, project, importance, tags)
+        VALUES (?, 'pattern', ?, 8, 'auto-compact,session-summary')
+      `);
+            const summary = `[Pre-Compact Summary] ${keyPoints.join(' | ')}`;
+            memoryStmt.run(summary, project);
+            // 활성 컨텍스트 업데이트
+            activeStmt.run(project, `Compacted: ${keyPoints[0]?.slice(0, 50) || 'Session context saved'}`);
+            console.log(`[PreCompact] Saved ${keyPoints.length} key points for ${project}`);
+        }
+        else {
+            console.log(`[PreCompact] No key points extracted for ${project}`);
+        }
+        db.close();
+        process.exit(0);
+    }
+    catch (e) {
+        // 에러 시 조용히 종료
+        process.exit(0);
+    }
+}
+main();

package/dist/hooks/session-end.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * SessionEnd Hook (Stop 이벤트) - 세션 종료 시 자동 저장
+ *
+ * Claude Code 세션 종료 시 자동으로 컨텍스트를 저장합니다.
+ */
+export {};

package/dist/hooks/session-end.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * SessionEnd Hook (Stop 이벤트) - 세션 종료 시 자동 저장
+ *
+ * Claude Code 세션 종료 시 자동으로 컨텍스트를 저장합니다.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import Database from 'better-sqlite3';
+function getDbPath() {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+    }
+    return path.join(claudeDir, 'sessions.db');
+}
+function detectProject(cwd) {
+    const appsMatch = cwd.match(/apps[\/\\]([^\/\\]+)/);
+    if (appsMatch)
+        return appsMatch[1];
+    let current = cwd;
+    while (current !== path.parse(current).root) {
+        const pkgPath = path.join(current, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                return pkg.name || path.basename(current);
+            }
+            catch {
+                return path.basename(current);
+            }
+        }
+        current = path.dirname(current);
+    }
+    return path.basename(cwd);
+}
+function extractSessionSummary(transcript) {
+    const lastWork = [];
+    const nextTasks = [];
+    const modifiedFiles = new Set();
+    // 최근 메시지 분석
+    const recentMessages = transcript.slice(-30);
+    for (const msg of recentMessages) {
+        const content = msg.content;
+        // 파일 수정 추출 (Edit, Write 도구 결과에서)
+        const filePatterns = [
+            /(?:edited|modified|updated|created|wrote)\s+[`"]?([^\s`"]+\.[a-z]+)/gi,
+            /file[:\s]+[`"]?([^\s`"]+\.[a-z]+)/gi,
+        ];
+        for (const pattern of filePatterns) {
+            let match;
+            while ((match = pattern.exec(content)) !== null) {
+                if (match[1] && !match[1].includes('...')) {
+                    modifiedFiles.add(match[1]);
+                }
+            }
+        }
+        if (msg.role === 'assistant') {
+            // 완료된 작업 추출
+            const donePatterns = [
+                /(?:completed|finished|done|완료|수정)[:\s]*([^.!?\n]+)/gi,
+                /(?:implemented|added|fixed|created)[:\s]*([^.!?\n]+)/gi,
+            ];
+            for (const pattern of donePatterns) {
+                const match = pattern.exec(content);
+                if (match && match[1]) {
+                    const work = match[1].trim().slice(0, 100);
+                    if (work.length > 10)
+                        lastWork.push(work);
+                }
+            }
+            // 다음 할 일 추출
+            const nextPatterns = [
+                /(?:next|todo|remaining|다음)[:\s]*([^.!?\n]+)/gi,
+                /(?:should|need to|필요)[:\s]*([^.!?\n]+)/gi,
+            ];
+            for (const pattern of nextPatterns) {
+                const match = pattern.exec(content);
+                if (match && match[1]) {
+                    const task = match[1].trim().slice(0, 100);
+                    if (task.length > 10)
+                        nextTasks.push(task);
+                }
+            }
+        }
+    }
+    return {
+        lastWork: lastWork.slice(0, 3).join('; ') || 'Session work completed',
+        nextTasks: [...new Set(nextTasks)].slice(0, 5),
+        modifiedFiles: [...modifiedFiles].slice(0, 10)
+    };
+}
+async function main() {
+    try {
+        let inputData = '';
+        for await (const chunk of process.stdin) {
+            inputData += chunk;
+        }
+        const input = inputData ? JSON.parse(inputData) : {};
+        const cwd = input.cwd || process.cwd();
+        const project = detectProject(cwd);
+        const dbPath = getDbPath();
+        if (!fs.existsSync(dbPath)) {
+            console.log('[SessionEnd] No DB found, skipping');
+            process.exit(0);
+        }
+        const db = new Database(dbPath);
+        // transcript에서 세션 요약 추출
+        const summary = input.transcript
+            ? extractSessionSummary(input.transcript)
+            : { lastWork: 'Session ended', nextTasks: [], modifiedFiles: [] };
+        // 세션 기록 저장
+        db.prepare(`
+      INSERT INTO sessions (project, last_work, next_tasks, modified_files)
+      VALUES (?, ?, ?, ?)
+    `).run(project, summary.lastWork, JSON.stringify(summary.nextTasks), JSON.stringify(summary.modifiedFiles));
+        // 활성 컨텍스트 업데이트
+        db.prepare(`
+      INSERT OR REPLACE INTO active_context (project, current_state, recent_files, updated_at)
+      VALUES (?, ?, ?, datetime('now'))
+    `).run(project, summary.lastWork, JSON.stringify(summary.modifiedFiles));
+        db.close();
+        console.log(`[SessionEnd] Saved session for ${project}`);
+        console.log(`  Last work: ${summary.lastWork.slice(0, 50)}...`);
+        console.log(`  Modified files: ${summary.modifiedFiles.length}`);
+        console.log(`  Next tasks: ${summary.nextTasks.length}`);
+        process.exit(0);
+    }
+    catch (e) {
+        process.exit(0);
+    }
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-session-continuity-mcp",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "Session Continuity for Claude Code - Never re-explain your project again",
   "type": "module",
   "main": "dist/index.js",
@@ -8,7 +8,10 @@
     "claude-session-continuity-mcp": "dist/index.js",
     "claude-session-hooks": "dist/hooks/install.js",
     "claude-hook-session-start": "dist/hooks/session-start.js",
-    "claude-hook-user-prompt": "dist/hooks/user-prompt-submit.js"
+    "claude-hook-user-prompt": "dist/hooks/user-prompt-submit.js",
+    "claude-hook-post-tool": "dist/hooks/post-tool-use.js",
+    "claude-hook-pre-compact": "dist/hooks/pre-compact.js",
+    "claude-hook-session-end": "dist/hooks/session-end.js"
   },
   "scripts": {
     "build": "tsc",