claude-session-continuity-mcp 1.9.7 → 1.10.1

package/README.md

@@ -1,4 +1,4 @@
-# claude-session-continuity-mcp (v1.9.0)
+# claude-session-continuity-mcp (v1.10.0)
 
 > **Zero Re-explanation Session Continuity for Claude Code** — Automatic context capture + semantic search
 
@@ -25,27 +25,36 @@ Every new Claude Code session:
 **Fully automatic.** Claude Hooks handle everything without manual calls:
 
 ```bash
-# Session start → Auto-loads relevant context (Git-based semantic search)
-# When asking → Auto-injects memories/solutions related to your query
-# During conversation → Auto-captures important decisions/errors/learnings
-# On commit → Commit messages automatically become memories
+# Session start → Auto-loads relevant context + recent session history
+# When asking → Auto-injects relevant memories/solutions
+# During conversation → Tracks active files (no noise memories)
+# On compact → Structured handover context for continuity
+# On exit → Extracts commits, decisions, error-fix pairs from transcript
 ```
 
 ```
 ← Auto-output on session start:
-# 🚀 my-app - Session Resumed
+# my-app - Session Resumed
 
-## Tech Stack
-**framework**: Next.js, **language**: TypeScript
+📍 **State**: Implementing signup form
 
-## Current State
-📍 Implementing signup form
-🚧 **Blocker**: OAuth callback URL issue
+## Recent Sessions
+### 2026-02-28
+**Work**: Completed OAuth integration with Google provider
+**Commits**: feat: add OAuth callback handler; fix: redirect URI config
+**Decisions**: Use Server Actions instead of API routes
+
+### 2026-02-27
+**Work**: Set up authentication foundation
+**Next**: Implement signup form validation
+
+## Directives
+- 🔴 Always use Zod for form validation
+- 📎 Prefer Server Components by default
 
-## 🧠 Relevant Memories (semantic: 0.89)
-- 🎯 [decision] Decided on App Router, using Server Actions
-- ⚠️ [error] OAuth redirect_uri mismatch → check env file
-- 📚 [learning] Zod form validation gives automatic type inference
+## Key Memories
+- 🎯 Decided on App Router, using Server Actions
+- ⚠️ OAuth redirect_uri mismatch → check env file
 ```
 
 **Zero manual work. Context follows you.**
@@ -64,8 +73,6 @@ npm install claude-session-continuity-mcp
 1. Registers MCP server in `~/.claude.json`
 2. Installs Claude Hooks in `~/.claude/settings.json`
 
-> **v1.6.1:** Fixed critical bug where hooks were installed to wrong settings file. Now correctly installs to `~/.claude/settings.json`. Auto-migrates existing users from `settings.local.json`.
-
 ### What Gets Installed
 
 **MCP Server** (in `~/.claude.json`):
@@ -101,9 +108,9 @@ npm install claude-session-continuity-mcp
 |------|---------|----------|
 | `SessionStart` | `claude-hook-session-start` | Auto-loads project context on session start |
 | `UserPromptSubmit` | `claude-hook-user-prompt` | Auto-injects relevant memories + past reference search |
-| `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) |
+| `PostToolUse` | `claude-hook-post-tool` | Tracks active files (Edit, Write) — no noise memories |
+| `PreCompact` | `claude-hook-pre-compact` | Structured handover context before compression |
+| `Stop` | `claude-hook-session-end` | Extracts commits, decisions, error-fix pairs from transcript |
 
 ### Manual Hook Management
 
@@ -129,19 +136,18 @@ After installation, restart Claude Code to activate the hooks.
 | Feature | Description |
 |---------|-------------|
 | 🤖 **Zero Manual Work** | Claude Hooks automate all context capture/load |
-| 🎯 **Query-Based Injection** | Selectively inject only relevant memories/solutions |
+| 🎯 **Quality Memory Only** | **(v1.10.0)** Only decisions, learnings, errors — no file-change noise |
 | 🧠 **Semantic Search** | multilingual-e5-small embedding (94+ languages, 384d) |
 | 🌍 **Multilingual** | Korean/English/Japanese + cross-language search (EN→KR, KR→EN) |
-| 🔗 **Git Integration** | Commit messages auto-memorized |
+| 🔗 **Git Integration** | Commit messages auto-extracted from transcripts |
 | 🕸️ **Knowledge Graph** | Memory relations (solves, causes, extends...) |
-| 📊 **Memory Classification** | 6 types: observation, decision, learning, error, pattern, code |
+| 📊 **Memory Classification** | 5 types: observation, decision, learning, error, pattern |
 | ✅ **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 |
+| 📝 **Structured Handover** | **(v1.10.0)** PreCompact saves work summary, active files, pending actions |
+| 🚪 **Smart Session End** | **(v1.10.0)** Extracts commits, decisions, error-fix pairs from transcript |
+| 🗑️ **Auto Noise Cleanup** | **(v1.10.0)** Auto-deletes stale observation memories (3d+) |
 | 🔍 **Past Reference Detection** | **(v1.8.0)** "저번에 X 어떻게 했어?" auto-searches DB |
 | 📝 **User Directive Extraction** | **(v1.8.0)** Auto-extracts "always/never" rules from prompts |
 
@@ -153,32 +159,53 @@ After installation, restart Claude Code to activate the hooks.
 
 **SessionStart Hook** (`npx claude-hook-session-start`):
 - Auto-detects project: monorepo (`apps/project-name/`) or single project (`package.json` root folder name)
-- Loads context from `~/.claude/sessions.db`
-- Injects: Tech stack, current state, pending tasks, recent memories
+- Loads context from `.claude/sessions.db`
+- Injects: Current state, **3 recent sessions** with commits/decisions, directives, pending tasks, filtered key memories
+- Auto-cleans stale noise memories (3d+ auto-tracked, 14d+ auto-compact)
 
 **UserPromptSubmit Hook** (`npx claude-hook-user-prompt`):
 - Runs on every prompt submission
-- Injects relevant context based on current project
+- Injects relevant context (filtered: decisions, learnings, errors only)
+
+**PostToolUse Hook** (`npx claude-hook-post-tool`):
+- Tracks hot file paths and updates `active_context.recent_files`
+- **No longer creates observation memories** (v1.10.0 — eliminates `[File Change]` noise)
+
+**PreCompact Hook** (`npx claude-hook-pre-compact`):
+- Builds structured handover context: work summary, active file, pending action, key facts, recent errors
+- **No longer stores auto-compact memories** (v1.10.0)
+
+**Stop Hook** (`npx claude-hook-session-end`):
+- Extracts commit messages from JSONL transcript (`git commit -m` patterns)
+- Extracts error-fix pairs (error → resolution within 3 messages)
+- Extracts decisions ("because", "instead of", "chose" patterns)
+- Stores structured metadata in `sessions.issues` column as JSON
 
 ### Example Output (Session Start)
 
 ```markdown
-# 🚀 my-app - Session Resumed
-
-## Tech Stack
-**framework**: Next.js, **language**: TypeScript
+# my-app - Session Resumed
 
-## Current State
-📍 Implementing signup form
+📍 **State**: Implementing signup form
 🚧 **Blocker**: OAuth callback URL issue
 
-## 📋 Pending Tasks
+## Recent Sessions
+### 2026-02-28
+**Work**: Completed OAuth integration
+**Commits**: feat: add OAuth handler; fix: redirect config
+**Decisions**: Use Server Actions over API routes
+**Next**: Implement form validation
+
+## Directives
+- 🔴 Always use Zod for validation
+
+## Pending Tasks
 - 🔄 [P8] Implement form validation
 - ⏳ [P5] Add error handling
 
-## 🧠 Key Memories
-- 🎯 [decision] Decided on App Router, using Server Actions
-- ⚠️ [error] OAuth redirect_uri mismatch → check env file
+## Key Memories
+- 🎯 Decided on App Router, using Server Actions
+- ⚠️ OAuth redirect_uri mismatch → check env file
 ```
 
 ### Hook Management
@@ -496,6 +523,11 @@ npm run test:coverage
 - [x] Empty session skip and techStack save improvements (v1.7.1)
 - [x] Past reference auto-detection in UserPromptSubmit hook (v1.8.0)
 - [x] User directive extraction ("always/never" rules) (v1.8.0)
+- [x] Memory quality overhaul — no more `[File Change]` noise (v1.10.0)
+- [x] Structured handover context in PreCompact (v1.10.0)
+- [x] Smart session-end: commit/decision/error-fix extraction from transcript (v1.10.0)
+- [x] Auto noise cleanup (3d+ observations, 14d+ auto-compact) (v1.10.0)
+- [x] 3 recent sessions display with structured metadata (v1.10.0)
 - [ ] sqlite-vec native vector search (v2 - when data > 1000 records)
 - [ ] Web dashboard
 - [ ] Cloud sync option

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

@@ -183,20 +183,8 @@ async function main() {
             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, JSON.stringify(['auto-tracked', changeType, getFileExtension(filePath)]));
-            }
+            // auto-tracked 메모리 기록 제거 (v1.10.0)
+            // git이 파일 변경을 더 잘 추적함. hot_paths + recent_files만 유지.
         }
         db.close();
         process.exit(0);

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

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 /**
- * PreCompact Hook - 컨텍스트 압축 전 중요 메모리 저장
+ * PreCompact Hook v2 - 컨텍스트 압축 전 구조화된 HANDOVER 생성
  *
- * 컨텍스트가 압축되기 전에 현재 세션의 중요 정보를 메모리에 저장합니다.
+ * 컴팩션 전에 대화 내용을 분석해 구조화된 컨텍스트를 systemMessage로 반환합니다.
+ * v1과 달리 memories 테이블에 저장하지 않습니다 (노이즈 방지).
  */
 export {};

package/dist/hooks/pre-compact.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 /**
- * PreCompact Hook - 컨텍스트 압축 전 중요 메모리 저장
+ * PreCompact Hook v2 - 컨텍스트 압축 전 구조화된 HANDOVER 생성
  *
- * 컨텍스트가 압축되기 전에 현재 세션의 중요 정보를 메모리에 저장합니다.
+ * 컴팩션 전에 대화 내용을 분석해 구조화된 컨텍스트를 systemMessage로 반환합니다.
+ * v1과 달리 memories 테이블에 저장하지 않습니다 (노이즈 방지).
  */
 import * as fs from 'fs';
 import * as path from 'path';
@@ -30,12 +31,10 @@ function getDbPath(cwd) {
 function detectProject(cwd) {
     const workspaceRoot = detectWorkspaceRoot(cwd);
     const appsDir = path.join(workspaceRoot, 'apps');
-    // apps/ 하위인지 확인
     if (cwd.startsWith(appsDir + path.sep)) {
         const relative = path.relative(appsDir, cwd);
         return relative.split(path.sep)[0];
     }
-    // apps/ 외부 하위 프로젝트 (hackathons/ 등)
     if (cwd !== workspaceRoot) {
         let current = cwd;
         while (current !== workspaceRoot && current !== path.parse(current).root) {
@@ -52,44 +51,97 @@ function detectProject(cwd) {
             current = path.dirname(current);
         }
     }
-    // 워크스페이스 루트 → 폴더명 반환
     return path.basename(workspaceRoot);
 }
-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,
+function stripMarkdown(text) {
+    return text
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/#{1,6}\s*/g, '')
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+        .trim();
+}
+/**
+ * 대화 transcript에서 구조화된 핸드오버 컨텍스트를 빌드합니다.
+ */
+function buildHandoverContext(transcript) {
+    const context = {
+        workSummary: '',
+        activeFile: null,
+        pendingAction: null,
+        keyFacts: [],
+        recentErrors: []
+    };
+    const userMessages = transcript.filter(m => m.role === 'user');
+    const assistantMessages = transcript.filter(m => m.role === 'assistant');
+    // 1. workSummary: 첫 user 메시지 = 작업 요청
+    if (userMessages.length > 0) {
+        const first = userMessages[0].content;
+        // 코드블록, 테이블 제거 후 첫 의미있는 라인
+        const cleaned = first
+            .replace(/```[\s\S]*?```/g, '')
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l.length > 10 && !l.startsWith('|') && !l.startsWith('---'));
+        if (cleaned.length > 0) {
+            context.workSummary = stripMarkdown(cleaned[0]).slice(0, 200);
+        }
+    }
+    // 2. activeFile: 최근 메시지에서 파일 경로 추출
+    const recentAll = transcript.slice(-10);
+    for (const msg of recentAll.reverse()) {
+        const filePatterns = [
+            /(?:file_path|파일)[:\s]*["']?([^\s"',]+\.\w{1,6})/,
+            /(?:Edit|Write|Read|수정|생성|읽기)\s+.*?(\S+\.\w{1,6})/,
+            /`([^`]+\.\w{1,6})`/,
         ];
-        for (const pattern of decisionPatterns) {
-            const matches = content.match(pattern);
-            if (matches) {
-                keyPoints.push(...matches.slice(0, 2));
+        for (const pattern of filePatterns) {
+            const match = msg.content.match(pattern);
+            if (match?.[1] && !match[1].includes('http')) {
+                context.activeFile = match[1];
+                break;
             }
         }
-        // 에러 해결 패턴
-        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));
+        if (context.activeFile)
+            break;
+    }
+    // 3. pendingAction: 마지막 메시지가 user면 미완료 요청
+    if (transcript.length > 0 && transcript[transcript.length - 1].role === 'user') {
+        const lastUser = transcript[transcript.length - 1].content;
+        const cleaned = stripMarkdown(lastUser.split('\n')[0] || lastUser);
+        if (cleaned.length > 5) {
+            context.pendingAction = cleaned.slice(0, 150);
+        }
+    }
+    // 4. keyFacts: assistant 메시지에서 설정값, 포트, 버전 등 추출
+    const factPatterns = [
+        /(?:port|포트)\s*(?:is|=|:|→)\s*(\d{2,5})/gi,
+        /(?:version|버전)\s*(?:is|=|:|→)\s*([\d.]+)/gi,
+        /(?:IP|ip)\s*(?:is|=|:|→)\s*([\d.]+)/gi,
+        /(?:using|사용)\s+([\w\s.-]+?\s+v[\d.]+)/gi,
+    ];
+    for (const msg of assistantMessages.slice(-10)) {
+        for (const pattern of factPatterns) {
+            pattern.lastIndex = 0;
+            const match = msg.content.match(pattern);
+            if (match) {
+                context.keyFacts.push(stripMarkdown(match[0]).slice(0, 100));
             }
         }
     }
-    // 중복 제거 및 길이 제한
-    const unique = [...new Set(keyPoints)].slice(0, 5);
-    return unique.map(p => p.slice(0, 200));
+    context.keyFacts = [...new Set(context.keyFacts)].slice(0, 5);
+    // 5. recentErrors: 에러 패턴 추출
+    for (const msg of transcript.slice(-15)) {
+        const errorMatch = msg.content.match(/(?:Error|error|ERROR|오류|실패|FAILED|Exception)[:\s](.{10,100})/);
+        if (errorMatch) {
+            const err = stripMarkdown(errorMatch[0]).slice(0, 100);
+            if (!context.recentErrors.includes(err)) {
+                context.recentErrors.push(err);
+            }
+        }
+    }
+    context.recentErrors = context.recentErrors.slice(0, 3);
+    return context;
 }
 async function main() {
     try {
@@ -106,23 +158,23 @@ async function main() {
             process.exit(0);
         }
         const db = new Database(dbPath);
-        // transcript에서 핵심 포인트 추출
-        const keyPoints = input.transcript ? extractKeyPoints(input.transcript) : [];
-        if (keyPoints.length > 0) {
-            // 중요 메모리로 저장
-            db.prepare(`
-        INSERT INTO memories (content, memory_type, project, importance, tags)
-        VALUES (?, 'pattern', ?, 8, '["auto-compact","session-summary"]')
-      `).run(`[Pre-Compact Summary] ${keyPoints.join(' | ')}`, project);
-            // 활성 컨텍스트 업데이트
+        // 핸드오버 컨텍스트 빌드
+        const handover = input.transcript ? buildHandoverContext(input.transcript) : null;
+        // active_context 업데이트 (memories에는 저장하지 않음)
+        if (handover?.workSummary) {
+            const stateStr = [
+                handover.workSummary,
+                handover.activeFile ? `file: ${handover.activeFile}` : '',
+                handover.pendingAction ? `pending: ${handover.pendingAction.slice(0, 50)}` : ''
+            ].filter(Boolean).join(' | ');
             db.prepare(`
         INSERT OR REPLACE INTO active_context (project, current_state, updated_at)
         VALUES (?, ?, datetime('now'))
-      `).run(project, `Compacted: ${keyPoints[0]?.slice(0, 50) || 'Session context saved'}`);
+      `).run(project, stateStr.slice(0, 300));
         }
         // === 컨텍스트 재주입: systemMessage로 반환 ===
-        const recoveryLines = [`# ${project} - Recovered Context\n`];
-        // 사용자 지시사항 (HIGH 우선)
+        const recoveryLines = [`# ${project} - Compact Recovery\n`];
+        // 사용자 지시사항
         try {
             const directives = db.prepare(`
         SELECT directive, priority FROM user_directives
@@ -154,27 +206,25 @@ async function main() {
             if (active.blockers)
                 recoveryLines.push(`**Blocker**: ${active.blockers}`);
         }
-        // Hot paths (상위 5개)
-        try {
-            const hotPaths = db.prepare(`
-        SELECT file_path, access_count FROM hot_paths
-        WHERE project = ? AND last_accessed > datetime('now', '-7 days')
-        ORDER BY access_count DESC LIMIT 5
-      `).all(project);
-            if (hotPaths.length > 0) {
-                recoveryLines.push(`**Hot Files**: ${hotPaths.map(h => h.file_path.split('/').pop()).join(', ')}`);
+        // 핸드오버 컨텍스트
+        if (handover) {
+            recoveryLines.push(`\n## Handover`);
+            if (handover.workSummary)
+                recoveryLines.push(`**Working on**: ${handover.workSummary}`);
+            if (handover.activeFile)
+                recoveryLines.push(`**Active file**: ${handover.activeFile}`);
+            if (handover.pendingAction)
+                recoveryLines.push(`**Pending**: ${handover.pendingAction}`);
+            if (handover.keyFacts.length > 0) {
+                recoveryLines.push('**Key facts**:');
+                handover.keyFacts.forEach(f => recoveryLines.push(`- ${f}`));
             }
-        }
-        catch { /* table may not exist */ }
-        // Key points from this session
-        if (keyPoints.length > 0) {
-            recoveryLines.push(`\n## Session Key Points`);
-            for (const kp of keyPoints) {
-                recoveryLines.push(`- ${kp}`);
+            if (handover.recentErrors.length > 0) {
+                recoveryLines.push('**Recent errors**:');
+                handover.recentErrors.forEach(e => recoveryLines.push(`- ${e}`));
             }
         }
         db.close();
-        // systemMessage로 반환 → 컴팩션 후에도 유지
         const output = {
             continue: true,
             systemMessage: recoveryLines.join('\n')

package/dist/hooks/session-end.js

@@ -134,11 +134,13 @@ function extractSummaryFromText(content) {
         if (cleaned.length > 10)
             return cleaned.slice(0, 200);
     }
-    // 전략 4: 첫 헤딩 제목 (## 제목) — 짧아도 허용 (성과 요약인 경우 많음)
+    // 전략 4: 첫 헤딩 제목 — 단, 일반적인 섹션 헤딩은 제외
     const headingMatch = cleanedContent.match(/^#{1,3}\s+(.+)$/m);
     if (headingMatch?.[1]) {
         const title = stripMarkdown(headingMatch[1]).trim();
-        if (title.length > 5)
+        // "결과 요약", "평가", "분석" 같은 일반 헤딩은 의미없는 요약이므로 건너뜀
+        const genericHeadings = /^(결과|요약|분석|평가|결론|테스트|현재|문제|핵심|다음|참고|MCP|Overview|Summary|Result|Analysis|Test)/i;
+        if (title.length > 5 && !genericHeadings.test(title))
             return title.slice(0, 200);
     }
     // 전략 5: 첫 의미있는 단락 (노이즈 라인 건너뜀)
@@ -192,15 +194,13 @@ async function readRecentAssistantMessages(transcriptPath, maxMessages = 5) {
 }
 /**
  * 다음 할 일 추출 (텍스트에서)
- * 테이블 행, 코드블록 내부는 제외
  */
 function extractNextTasks(content) {
     const nextTasks = [];
-    // 코드블록과 테이블 행 제거
     const cleaned = content
-        .replace(/```[\s\S]*?```/g, '') // 코드블록 제거
+        .replace(/```[\s\S]*?```/g, '')
         .split('\n')
-        .filter(line => !line.trim().startsWith('|')) // 테이블 행 제거
+        .filter(line => !line.trim().startsWith('|'))
         .join('\n');
     const nextPatterns = [
         /(?:next steps?|todo|remaining|다음 (?:단계|작업|할 일)|남은 작업|해야 할)[:\s]*([^.!?\n]{10,})/gi,
@@ -217,6 +217,211 @@ function extractNextTasks(content) {
     }
     return nextTasks;
 }
+/**
+ * JSONL transcript에서 git commit 메시지 추출
+ */
+async function extractCommitMessages(transcriptPath) {
+    if (!transcriptPath || !fs.existsSync(transcriptPath))
+        return [];
+    const commits = [];
+    // git commit -m "message" 또는 heredoc 패턴 (JSON 파싱 후 적용)
+    const commitPatterns = [
+        /git commit.*?-m\s*"\$\(cat <<'?EOF'?\n(.+?)(?:\n\n|\nCo-Authored|\nEOF)/s,
+        /git commit.*?-m\s*["']([^"'\n]{10,150})["']/,
+    ];
+    try {
+        const fileStream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
+        const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.includes('git commit'))
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                // tool_use 블록에서 command 추출
+                const content = entry.message?.content;
+                if (!Array.isArray(content))
+                    continue;
+                for (const block of content) {
+                    if (block.type !== 'tool_use')
+                        continue;
+                    const cmd = block.input?.command;
+                    if (!cmd || !cmd.includes('-m'))
+                        continue;
+                    // git commit이 명령어의 시작이거나 && 이후에 나와야 함
+                    if (!/(?:^|&&\s*)git\s+commit/.test(cmd))
+                        continue;
+                    for (const pattern of commitPatterns) {
+                        const match = cmd.match(pattern);
+                        if (match?.[1]) {
+                            const msg = match[1].trim().split('\n')[0]; // 첫 줄만
+                            if (msg.length > 10 && !msg.startsWith('Co-Authored')) {
+                                commits.push(msg.slice(0, 150));
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+    }
+    catch { /* file read error */ }
+    return [...new Set(commits)].slice(0, 5);
+}
+/**
+ * JSONL transcript에서 에러→해결 쌍 추출
+ */
+async function extractErrorFixPairs(transcriptPath) {
+    if (!transcriptPath || !fs.existsSync(transcriptPath))
+        return [];
+    const pairs = [];
+    const entries = [];
+    try {
+        const fileStream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
+        const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                const role = entry.type || entry.role || '';
+                let text = '';
+                if (typeof entry.message?.content === 'string') {
+                    text = entry.message.content;
+                }
+                else if (Array.isArray(entry.message?.content)) {
+                    text = entry.message.content
+                        .filter((b) => b.type === 'text')
+                        .map((b) => b.text)
+                        .join('\n');
+                }
+                if (text.length > 5)
+                    entries.push({ role, text: text.slice(0, 500) });
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* file error */ }
+    const recent = entries.slice(-30);
+    const errorRe = /(?:error|Error|ERROR|오류|실패|FAILED|Exception)[:\s](.{5,80})/;
+    const fixRe = /(?:fixed|resolved|수정|해결|Added|수정 완료)/i;
+    for (let i = 0; i < recent.length - 1; i++) {
+        const errorMatch = recent[i].text.match(errorRe);
+        if (errorMatch) {
+            for (let j = i + 1; j < Math.min(i + 4, recent.length); j++) {
+                if (recent[j].role === 'assistant' && fixRe.test(recent[j].text)) {
+                    const errorStr = stripMarkdown(errorMatch[0]).slice(0, 80);
+                    const fixLine = recent[j].text.split('\n')
+                        .find(l => fixRe.test(l));
+                    const fixStr = fixLine ? stripMarkdown(fixLine).slice(0, 80) : 'resolved';
+                    pairs.push(`${errorStr} → ${fixStr}`);
+                    break;
+                }
+            }
+        }
+    }
+    return [...new Set(pairs)].slice(0, 3);
+}
+/**
+ * JSONL transcript에서 결정 사항 추출
+ */
+async function extractDecisions(transcriptPath) {
+    const messages = await readRecentAssistantMessages(transcriptPath, 10);
+    const decisions = [];
+    const decisionPatterns = [
+        /(?:chose|using|switched to|went with)\s+(.{10,80})\s+(?:because|since|instead of|over)/gi,
+        /(?:instead of|rather than)\s+(.{10,60})/gi,
+        /(.{10,60})(?:으로|로)\s+(?:결정|변경|전환)(?:했|함|합니다)/g,
+        /(.{10,60})(?:대신|말고)\s+(.{10,60})(?:사용|적용)/g,
+    ];
+    for (const msg of messages) {
+        for (const pattern of decisionPatterns) {
+            pattern.lastIndex = 0;
+            const matches = msg.match(pattern);
+            if (matches) {
+                decisions.push(...matches.slice(0, 1).map(m => stripMarkdown(m).slice(0, 150)));
+            }
+        }
+    }
+    return [...new Set(decisions)].slice(0, 3);
+}
+/**
+ * transcript에서 첫 사용자 요청 추출 (세션의 핵심 목적)
+ */
+async function extractUserRequest(transcriptPath) {
+    if (!transcriptPath || !fs.existsSync(transcriptPath))
+        return '';
+    try {
+        const fileStream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
+        const rl = readline.createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const entry = JSON.parse(line);
+                if (entry.type !== 'human' && entry.type !== 'user')
+                    continue;
+                const content = entry.message?.content;
+                let text = '';
+                if (typeof content === 'string') {
+                    text = content;
+                }
+                else if (Array.isArray(content)) {
+                    text = content
+                        .filter((b) => b.type === 'text')
+                        .map((b) => b.text)
+                        .join('\n');
+                }
+                // system-reminder 태그 제거
+                text = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+                if (text.length < 5)
+                    continue;
+                // 시스템/메타 메시지 스킵
+                if (text.startsWith('[Request interrupted'))
+                    continue;
+                if (text.startsWith('This session is being continued'))
+                    continue;
+                // "Implement the following plan:" → 실제 플랜 제목만 추출
+                const planMatch = text.match(/^Implement the following plan:\s*\n+#\s*(.+)/);
+                if (planMatch)
+                    return planMatch[1].trim().slice(0, 200);
+                // 긴 텍스트는 첫 줄만 (플랜, 컨텍스트 덤프 등)
+                const firstLine = text.split('\n')[0].trim();
+                if (firstLine.length > 200)
+                    return firstLine.slice(0, 200);
+                return stripMarkdown(firstLine).slice(0, 200);
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* file read error */ }
+    return '';
+}
+/**
+ * 최근 assistant 메시지에서 액션 동사 포함 라인 추출 (lastWork 폴백)
+ */
+async function extractWorkFromRecentMessages(transcriptPath) {
+    const messages = await readRecentAssistantMessages(transcriptPath, 5);
+    const actionVerbs = /(?:created|modified|added|removed|fixed|updated|implemented|deployed|configured|refactored|만들|수정|추가|삭제|구현|배포|설정|완료)/i;
+    const filePath = /(?:\/[\w.-]+){2,}|[\w.-]+\.\w{1,4}/;
+    for (const msg of messages.reverse()) {
+        const lines = msg.split('\n').filter(l => !isNoiseLine(l));
+        for (const line of lines) {
+            if (actionVerbs.test(line) && line.length > 20) {
+                const cleaned = stripMarkdown(line).trim();
+                if (cleaned.length > 15)
+                    return cleaned.slice(0, 200);
+            }
+        }
+        // 파일 경로 포함 라인도 시도
+        for (const line of lines) {
+            if (filePath.test(line) && actionVerbs.test(line)) {
+                return stripMarkdown(line).trim().slice(0, 200);
+            }
+        }
+    }
+    return '';
+}
 async function main() {
     try {
         let inputData = '';
@@ -238,15 +443,43 @@ async function main() {
             process.exit(0);
         }
         const db = new Database(dbPath);
-        // === last_work 추출 ===
+        // === 추출 시작 ===
         let lastWork = '';
         let nextTasks = [];
-        // 소스 1: last_assistant_message (Stop 이벤트에서 직접 제공)
-        if (input.last_assistant_message) {
+        let commitMessages = [];
+        let errorsSolved = [];
+        let decisions = [];
+        // Phase 1: transcript_path에서 고품질 데이터 추출
+        let userRequest = '';
+        if (input.transcript_path) {
+            [commitMessages, errorsSolved, decisions, userRequest] = await Promise.all([
+                extractCommitMessages(input.transcript_path),
+                extractErrorFixPairs(input.transcript_path),
+                extractDecisions(input.transcript_path),
+                extractUserRequest(input.transcript_path),
+            ]);
+        }
+        // Phase 2: lastWork 결정 (우선순위 폴백)
+        // 2a: 사용자 요청 + 커밋 메시지 조합 (가장 이상적)
+        if (userRequest && commitMessages.length > 0) {
+            lastWork = `${userRequest} → ${commitMessages.slice(0, 2).join('; ')}`;
+            if (lastWork.length > 250)
+                lastWork = lastWork.slice(0, 250);
+        }
+        // 2b: 커밋 메시지만 (사용자 요청 없을 때)
+        else if (commitMessages.length > 0) {
+            lastWork = commitMessages.slice(0, 3).join('; ');
+        }
+        // 2c: 사용자 요청만 (커밋 없을 때)
+        else if (userRequest) {
+            lastWork = userRequest;
+        }
+        // 2d: last_assistant_message에서 추출
+        if (!lastWork && input.last_assistant_message) {
             lastWork = extractSummaryFromText(input.last_assistant_message);
             nextTasks = extractNextTasks(input.last_assistant_message);
         }
-        // 소스 2: transcript_path에서 마지막 assistant 메시지들 읽기 (소스 1 실패 시)
+        // 2c: transcript에서 최근 assistant 메시지 스캔
         if (!lastWork && input.transcript_path) {
             const recentMessages = await readRecentAssistantMessages(input.transcript_path);
             for (let i = recentMessages.length - 1; i >= 0; i--) {
@@ -254,12 +487,15 @@ async function main() {
                 if (lastWork)
                     break;
             }
-            // next tasks도 마지막 메시지에서 추출
-            if (recentMessages.length > 0) {
+            if (recentMessages.length > 0 && nextTasks.length === 0) {
                 nextTasks = extractNextTasks(recentMessages[recentMessages.length - 1]);
             }
         }
-        // 소스 3: 레거시 transcript 배열 (이전 버전 호환)
+        // 2d: 액션 동사 기반 폴백
+        if (!lastWork && input.transcript_path) {
+            lastWork = await extractWorkFromRecentMessages(input.transcript_path);
+        }
+        // 2e: 레거시 transcript 배열
         if (!lastWork && input.transcript) {
             const assistantMsgs = input.transcript.filter(m => m.role === 'assistant');
             if (assistantMsgs.length < 2) {
@@ -273,7 +509,7 @@ async function main() {
                     break;
             }
         }
-        // === modified_files: active_context에서 PostToolUse가 실시간 저장한 파일 목록 ===
+        // === modified_files ===
         let modifiedFiles = [];
         try {
             const activeCtx = db.prepare('SELECT recent_files FROM active_context WHERE project = ?').get(project);
@@ -282,7 +518,7 @@ async function main() {
             }
         }
         catch { /* active_context may not exist */ }
-        // last_work 폴백: 파일 목록 기반
+        // last_work 최종 폴백: 파일 목록 기반
         if (!lastWork && modifiedFiles.length > 0) {
             const fileNames = modifiedFiles.slice(0, 5).map(f => path.basename(f)).join(', ');
             lastWork = `Modified files: ${fileNames}`;
@@ -293,7 +529,7 @@ async function main() {
             db.close();
             process.exit(0);
         }
-        // 중복 저장 방지: 최근 60초 이내 동일 last_work
+        // 중복 저장 방지
         const recentDup = db.prepare(`
       SELECT id FROM sessions
       WHERE project = ? AND last_work = ? AND timestamp > datetime('now', '-60 seconds')
@@ -304,11 +540,18 @@ async function main() {
             db.close();
             process.exit(0);
         }
+        // 구조화 메타데이터 (issues 컬럼 활용)
+        const metadata = {
+            commits: commitMessages,
+            decisions,
+            errorsSolved
+        };
+        const hasMetadata = commitMessages.length > 0 || decisions.length > 0 || errorsSolved.length > 0;
         // 세션 기록 저장
         db.prepare(`
-      INSERT INTO sessions (project, last_work, next_tasks, modified_files)
-      VALUES (?, ?, ?, ?)
-    `).run(project, lastWork, JSON.stringify([...new Set(nextTasks)].slice(0, 5)), JSON.stringify(modifiedFiles.slice(0, 15)));
+      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);
         // 활성 컨텍스트 업데이트
         db.prepare(`
       INSERT OR REPLACE INTO active_context (project, current_state, recent_files, updated_at)
@@ -317,6 +560,7 @@ async function main() {
         db.close();
         console.log(`[SessionEnd] Saved session for ${project}`);
         console.log(`  Last work: ${lastWork.slice(0, 80)}`);
+        console.log(`  Commits: ${commitMessages.length}, Decisions: ${decisions.length}, Errors: ${errorsSolved.length}`);
         console.log(`  Modified files: ${modifiedFiles.length}`);
         console.log(`  Next tasks: ${nextTasks.length}`);
         process.exit(0);

package/dist/hooks/session-start.js

@@ -44,44 +44,77 @@ function getProject(cwd, workspaceRoot) {
     // 워크스페이스 루트 (모노레포 포함) → 폴더명 반환
     return path.basename(workspaceRoot);
 }
+function cleanupNoiseMemories(db) {
+    try {
+        // 3일+ auto-tracked 관찰 메모리 삭제
+        db.prepare(`
+      DELETE FROM memories
+      WHERE memory_type = 'observation'
+        AND tags LIKE '%auto-tracked%'
+        AND created_at < datetime('now', '-3 days')
+    `).run();
+        // 14일+ auto-compact 패턴 메모리 삭제
+        db.prepare(`
+      DELETE FROM memories
+      WHERE tags LIKE '%auto-compact%'
+        AND created_at < datetime('now', '-14 days')
+    `).run();
+    }
+    catch { /* ignore */ }
+}
 function loadContext(dbPath, project) {
     if (!fs.existsSync(dbPath))
         return null;
     try {
-        const db = new Database(dbPath, { readonly: true });
+        const db = new Database(dbPath);
+        // 노이즈 메모리 자동 정리
+        cleanupNoiseMemories(db);
         const lines = [`# ${project} - Session Resumed\n`];
-        // 기술 스택
-        const fixed = db.prepare('SELECT tech_stack FROM project_context WHERE project = ?').get(project);
-        if (fixed?.tech_stack) {
-            const stack = JSON.parse(fixed.tech_stack);
-            const stackStr = Object.entries(stack).map(([k, v]) => `**${k}**: ${v}`).join(', ');
-            lines.push(`## Tech Stack\n${stackStr}\n`);
-        }
         // 현재 상태
         const active = db.prepare('SELECT current_state, blockers FROM active_context WHERE project = ?').get(project);
         if (active?.current_state) {
-            lines.push(`## Current State\n📍 ${active.current_state}`);
+            lines.push(`📍 **State**: ${active.current_state}`);
             if (active.blockers)
                 lines.push(`🚧 **Blocker**: ${active.blockers}`);
             lines.push('');
         }
-        // 마지막 세션 (빈 세션 skip)
-        const last = db.prepare(`
-      SELECT last_work, next_tasks, timestamp FROM sessions
+        // 최근 3개 세션 (빈 세션 skip)
+        const recentSessions = db.prepare(`
+      SELECT last_work, next_tasks, issues, timestamp FROM sessions
       WHERE project = ?
         AND last_work != 'Session ended'
         AND last_work != 'Session work completed'
         AND last_work != 'Session started'
         AND last_work != ''
-      ORDER BY timestamp DESC LIMIT 1
-    `).get(project);
-        if (last?.last_work) {
-            lines.push(`## Last Session (${last.timestamp?.slice(0, 10) || 'unknown'})`);
-            lines.push(`**Work**: ${last.last_work}`);
-            if (last.next_tasks) {
-                const next = JSON.parse(last.next_tasks);
-                if (next.length > 0)
-                    lines.push(`**Next**: ${next.slice(0, 3).join(' → ')}`);
+        AND length(last_work) > 15
+      ORDER BY timestamp DESC LIMIT 3
+    `).all(project);
+        if (recentSessions.length > 0) {
+            lines.push('## Recent Sessions');
+            for (const session of recentSessions) {
+                lines.push(`### ${session.timestamp?.slice(0, 10) || 'unknown'}`);
+                lines.push(`**Work**: ${session.last_work}`);
+                // 구조화 메타데이터 파싱 (session-end v2에서 저장)
+                if (session.issues) {
+                    try {
+                        const meta = JSON.parse(session.issues);
+                        if (meta.commits?.length > 0) {
+                            lines.push(`**Commits**: ${meta.commits.slice(0, 3).join('; ')}`);
+                        }
+                        if (meta.decisions?.length > 0) {
+                            lines.push(`**Decisions**: ${meta.decisions.join('; ')}`);
+                        }
+                    }
+                    catch { /* plain text issues or empty, skip */ }
+                }
+                if (session.next_tasks) {
+                    try {
+                        const next = JSON.parse(session.next_tasks);
+                        if (next.length > 0)
+                            lines.push(`**Next**: ${next.slice(0, 2).join(', ')}`);
+                    }
+                    catch { /* skip */ }
+                }
             }
             lines.push('');
         }
@@ -92,7 +125,7 @@ function loadContext(dbPath, project) {
         WHERE project = ? ORDER BY priority DESC, created_at DESC LIMIT 10
       `).all(project);
             if (directives.length > 0) {
-                lines.push('## 📌 Directives');
+                lines.push('## Directives');
                 for (const d of directives) {
                     const icon = d.priority === 'high' ? '🔴' : '📎';
                     lines.push(`- ${icon} ${d.directive}`);
@@ -101,58 +134,51 @@ function loadContext(dbPath, project) {
             }
         }
         catch { /* table may not exist yet */ }
-        // Hot Files (최근 7일, 상위 10개)
+        // 미완료 태스크
         try {
-            const hotPaths = db.prepare(`
-        SELECT file_path, access_count FROM hot_paths
-        WHERE project = ? AND last_accessed > datetime('now', '-7 days')
-        ORDER BY access_count DESC LIMIT 10
+            const tasks = db.prepare(`
+        SELECT title, priority, status FROM tasks
+        WHERE project = ? AND status IN ('pending', 'in_progress')
+        ORDER BY priority DESC LIMIT 5
       `).all(project);
-            if (hotPaths.length > 0) {
-                lines.push('## 🔥 Hot Files');
-                for (const h of hotPaths) {
-                    const fileName = h.file_path.split('/').pop() || h.file_path;
-                    lines.push(`- ${fileName} (${h.access_count}x)`);
+            if (tasks.length > 0) {
+                lines.push('## Pending Tasks');
+                for (const t of tasks) {
+                    const icon = t.status === 'in_progress' ? '🔄' : '⏳';
+                    lines.push(`- ${icon} [P${t.priority}] ${t.title}`);
                 }
                 lines.push('');
             }
         }
-        catch { /* table may not exist yet */ }
-        // 미완료 태스크
-        const tasks = db.prepare(`
-      SELECT title, priority, status FROM tasks
-      WHERE project = ? AND status IN ('pending', 'in_progress')
-      ORDER BY priority DESC LIMIT 5
-    `).all(project);
-        if (tasks.length > 0) {
-            lines.push('## 📋 Pending Tasks');
-            for (const t of tasks) {
-                const icon = t.status === 'in_progress' ? '🔄' : '⏳';
-                lines.push(`- ${icon} [P${t.priority}] ${t.title}`);
-            }
-            lines.push('');
-        }
-        // 중요 메모리
-        const memories = db.prepare(`
-      SELECT content, memory_type FROM memories
-      WHERE project = ?
-      ORDER BY importance DESC, created_at DESC LIMIT 5
-    `).all(project);
-        if (memories.length > 0) {
-            const typeIcons = {
-                observation: '👀', decision: '🎯', learning: '📚', error: '⚠️', pattern: '🔄'
-            };
-            lines.push('## 🧠 Key Memories');
-            for (const m of memories) {
-                const icon = typeIcons[m.memory_type] || '💭';
-                const content = m.content.length > 100 ? m.content.slice(0, 100) + '...' : m.content;
-                lines.push(`- ${icon} [${m.memory_type}] ${content}`);
+        catch { /* table may not exist */ }
+        // 중요 메모리 (노이즈 필터링)
+        try {
+            const memories = db.prepare(`
+        SELECT content, memory_type FROM memories
+        WHERE project = ?
+          AND memory_type IN ('decision', 'learning', 'error', 'preference')
+          AND importance >= 5
+          AND (tags NOT LIKE '%auto-tracked%' OR tags IS NULL)
+          AND (tags NOT LIKE '%auto-compact%' OR tags IS NULL)
+        ORDER BY importance DESC, accessed_at DESC LIMIT 5
+      `).all(project);
+            if (memories.length > 0) {
+                const typeIcons = {
+                    decision: '🎯', learning: '📚', error: '⚠️', preference: '💡'
+                };
+                lines.push('## Key Memories');
+                for (const m of memories) {
+                    const icon = typeIcons[m.memory_type] || '💭';
+                    const content = m.content.length > 100 ? m.content.slice(0, 100) + '...' : m.content;
+                    lines.push(`- ${icon} ${content}`);
+                }
+                lines.push('');
             }
-            lines.push('');
         }
+        catch { /* ignore */ }
         db.close();
         lines.push('---');
-        lines.push('_Auto-injected by session-continuity. Use `session_end` when done._');
+        lines.push('_Auto-injected by session-continuity v2. Use `session_end` when done._');
         return lines.join('\n');
     }
     catch (e) {

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

@@ -286,21 +286,25 @@ function loadContext(dbPath, project, prompt) {
             }
             lines.push('');
         }
-        // 중요 메모리
+        // 중요 메모리 (노이즈 필터링 - v1.10.0)
         const memories = db.prepare(`
       SELECT content, memory_type, importance FROM memories
       WHERE project = ?
-      ORDER BY importance DESC, created_at DESC LIMIT 5
+        AND memory_type IN ('decision', 'learning', 'error', 'preference')
+        AND importance >= 5
+        AND (tags NOT LIKE '%auto-tracked%' OR tags IS NULL)
+        AND (tags NOT LIKE '%auto-compact%' OR tags IS NULL)
+      ORDER BY importance DESC, accessed_at DESC LIMIT 5
     `).all(project);
         if (memories.length > 0) {
             const typeIcons = {
-                observation: '👀', decision: '🎯', learning: '📚', error: '⚠️', pattern: '🔄'
+                decision: '🎯', learning: '📚', error: '⚠️', preference: '💡'
             };
-            lines.push('## 🧠 Key Memories');
+            lines.push('## Key Memories');
             for (const m of memories) {
                 const icon = typeIcons[m.memory_type] || '💭';
                 const content = m.content.length > 100 ? m.content.slice(0, 100) + '...' : m.content;
-                lines.push(`- ${icon} [${m.memory_type}] ${content}`);
+                lines.push(`- ${icon} ${content}`);
             }
             lines.push('');
         }

package/dist/index.js

@@ -256,6 +256,17 @@ async function generateEmbedding(text, type = 'query') {
         return null;
     }
 }
+function parseTags(tags) {
+    if (!tags)
+        return [];
+    try {
+        const parsed = JSON.parse(tags);
+        return Array.isArray(parsed) ? parsed : [String(parsed)];
+    }
+    catch {
+        return tags.split(',').map(t => t.trim()).filter(Boolean);
+    }
+}
 function cosineSimilarity(a, b) {
     if (a.length !== b.length)
         return 0;
@@ -1482,7 +1493,7 @@ async function handleTool(name, args) {
                     content: m.content.substring(0, 300) + (m.content.length > 300 ? '...' : ''),
                     type: m.memory_type,
                     project: m.project || 'global',
-                    tags: m.tags ? JSON.parse(m.tags) : [],
+                    tags: parseTags(m.tags),
                     importance: m.importance,
                     similarity: m.similarity ? Math.round(m.similarity * 100) + '%' : undefined,
                     created: m.created_at
@@ -1866,23 +1877,27 @@ async function generateProjectContext(project) {
         }
         lines.push('');
     }
-    // 5. 최근 관련 메모리 (중요도 높은 것 5개)
+    // 5. 중요 메모리 (노이즈 필터링 - v1.10.0)
     const recentMemories = db.prepare(`
     SELECT id, content, memory_type, importance FROM memories
     WHERE project = ?
-    ORDER BY importance DESC, created_at DESC LIMIT 5
+      AND memory_type IN ('decision', 'learning', 'error', 'preference')
+      AND importance >= 5
+      AND (tags NOT LIKE '%auto-tracked%' OR tags IS NULL)
+      AND (tags NOT LIKE '%auto-compact%' OR tags IS NULL)
+    ORDER BY importance DESC, accessed_at DESC LIMIT 5
   `).all(project);
     if (recentMemories.length > 0) {
-        lines.push(`## 🧠 중요 메모리`);
+        lines.push(`## 🧠 Key Memories`);
         for (const mem of recentMemories) {
             const typeIcon = {
-                observation: '👀',
                 decision: '🎯',
                 learning: '📚',
                 error: '⚠️',
-                pattern: '🔄'
-            }[mem.memory_type] || '💭';
-            lines.push(`- ${typeIcon} [${mem.memory_type}] ${mem.content.substring(0, 100)}${mem.content.length > 100 ? '...' : ''}`);
+                preference: '💡'
+            };
+            const icon = typeIcon[mem.memory_type] || '💭';
+            lines.push(`- ${icon} ${mem.content.substring(0, 100)}${mem.content.length > 100 ? '...' : ''}`);
         }
         lines.push('');
     }
@@ -1904,9 +1919,10 @@ async function generateProjectContext(project) {
 }
 async function generateRecentMemories(project, limit = 10) {
     const lines = ['# 🧠 최근 메모리\n'];
+    const noiseFilter = `AND memory_type IN ('decision','learning','error','preference') AND importance >= 5 AND (tags NOT LIKE '%auto-tracked%' OR tags IS NULL) AND (tags NOT LIKE '%auto-compact%' OR tags IS NULL)`;
     const sql = project
-        ? `SELECT id, content, memory_type, project, importance, created_at FROM memories WHERE project = ? ORDER BY importance DESC, created_at DESC LIMIT ?`
-        : `SELECT id, content, memory_type, project, importance, created_at FROM memories ORDER BY importance DESC, created_at DESC LIMIT ?`;
+        ? `SELECT id, content, memory_type, project, importance, created_at FROM memories WHERE project = ? ${noiseFilter} ORDER BY importance DESC, created_at DESC LIMIT ?`
+        : `SELECT id, content, memory_type, project, importance, created_at FROM memories WHERE 1=1 ${noiseFilter} ORDER BY importance DESC, created_at DESC LIMIT ?`;
     const memories = project
         ? db.prepare(sql).all(project, limit)
         : db.prepare(sql).all(limit);

package/package.json

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