claude-session-continuity-mcp 1.13.1 → 1.15.0

package/README.md

@@ -1,4 +1,4 @@
-# claude-session-continuity-mcp (v1.13.0)
+# claude-session-continuity-mcp (v1.13.2)
 
 > **Zero Re-explanation Session Continuity for Claude Code** — Automatic context capture + semantic search + auto error→solution pipeline
 
@@ -64,16 +64,76 @@ Every new Claude Code session:
 
 ## Quick Start
 
-### One Command Installation
+### Recommended: Global Installation
 
 ```bash
-npm install claude-session-continuity-mcp
+npm install -g claude-session-continuity-mcp
 ```
 
 **That's it!** The postinstall script automatically:
 1. Registers MCP server in `~/.claude.json`
 2. Installs Claude Hooks in `~/.claude/settings.json`
 
+### Why Global (`-g`)?
+
+This tool is designed to track **all your Claude Code projects** in a single unified database.
+Global installation is strongly recommended because:
+
+| Reason | Detail |
+|---|---|
+| **Single source of truth** | One binary serves every project — no version drift between projects |
+| **Hooks are user-scoped** | `~/.claude/settings.json` lives in your home directory, not per-project |
+| **Cross-project context** | Sessions from `app-a` and `app-b` share the same DB and search index |
+| **One update = everything refreshed** | `npm install -g <latest>` updates all projects at once; no per-project reinstall |
+| **`npm exec` resolves global first** | Hooks call `npm exec -- claude-hook-*` which finds the global package reliably regardless of cwd |
+
+**Important**: Even with global install, you can still **disable the hook for specific projects** (see below).
+Global ≠ forced on every project.
+
+### Disabling Hooks for Specific Projects
+
+Global install does **not** mean "always on everywhere". You have three layers of control:
+
+| Layer | File | Scope |
+|---|---|---|
+| 1. Global ON (default) | `~/.claude/settings.json` | All projects |
+| 2. Project-wide OFF | `<project>/.claude/settings.json` | Whole team (committed) |
+| 3. Personal-only OFF | `<project>/.claude/settings.local.json` | Just you (gitignored) |
+
+**To disable hooks in a specific project**, create the override file with empty hook arrays:
+
+```json
+// <project>/.claude/settings.json  (or settings.local.json for personal-only)
+{
+  "hooks": {
+    "SessionStart": [],
+    "UserPromptSubmit": [],
+    "PostToolUse": [],
+    "PreCompact": [],
+    "Stop": []
+  }
+}
+```
+
+Empty arrays override the global setting → that project's sessions are no longer tracked.
+
+### Updating to a New Version
+
+```bash
+npm install -g claude-session-continuity-mcp@latest
+```
+
+That's the only step — all projects pick up the new binary on next Claude Code restart.
+No need to reinstall in each project.
+
+### Alternative: Local Install (Not Recommended)
+
+If you really want per-project install (e.g., locked version for one project):
+```bash
+cd <project> && npm install claude-session-continuity-mcp
+```
+Drawback: you must install separately in every project, and `npm exec` may not find the local copy reliably from hook context (cwd-dependent). Stick with `-g` unless you have a specific reason.
+
 ### What Gets Installed
 
 **MCP Server** (in `~/.claude.json`):

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

@@ -7,6 +7,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
+import { logHookError } from '../utils/logger.js';
 // ===== Playwright 캐시 정리 (20MB 컨텍스트 초과 방지) =====
 function cleanPlaywrightCache(cwd) {
     const MAX_TOTAL = 3 * 1024 * 1024; // 3MB 초과 시 정리
@@ -265,6 +266,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';
@@ -319,6 +321,7 @@ async function main() {
         process.exit(0);
     }
     catch (e) {
+        logHookError('post-tool-use', e);
         process.exit(0);
     }
 }

package/dist/hooks/pre-compact.js

@@ -193,6 +193,7 @@ function cleanPlaywrightCache(cwd) {
     catch { /* ignore */ }
 }
 async function main() {
+    let cwdForErrorLog = process.cwd();
     try {
         let inputData = '';
         for await (const chunk of process.stdin) {
@@ -200,15 +201,25 @@ async function main() {
         }
         const input = inputData ? JSON.parse(inputData) : {};
         const cwd = input.cwd || process.cwd();
+        cwdForErrorLog = cwd;
         // Playwright 캐시 정리 (20MB 컨텍스트 초과 방지)
         cleanPlaywrightCache(cwd);
         const project = detectProject(cwd);
         const dbPath = getDbPath(cwd);
+        // 디버그 로그 (DB 없어도 발화 자체는 기록)
+        const debugLogPath = path.join(path.dirname(dbPath), 'pre-compact-debug.log');
+        const transcriptLen = input.transcript?.length || 0;
+        const sid = input.sessionId?.slice(0, 8) || 'none';
         if (!fs.existsSync(dbPath)) {
+            try {
+                fs.appendFileSync(debugLogPath, `[${new Date().toISOString()}] project=${project} sid=${sid} transcript_msgs=${transcriptLen} status=no_db\n`);
+            }
+            catch { /* ignore */ }
             process.stdout.write(JSON.stringify({ continue: true }));
             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에는 저장하지 않음)
@@ -229,7 +240,10 @@ async function main() {
         try {
             const directives = db.prepare(`
         SELECT directive, priority FROM user_directives
-        WHERE project = ? ORDER BY priority DESC, created_at DESC LIMIT 10
+        WHERE project = ?
+        ORDER BY CASE priority WHEN 'high' THEN 3 WHEN 'normal' THEN 2 WHEN 'low' THEN 1 ELSE 0 END DESC,
+                 created_at DESC
+        LIMIT 10
       `).all(project);
             if (directives.length > 0) {
                 recoveryLines.push('## DIRECTIVES (MUST FOLLOW)');
@@ -276,15 +290,31 @@ async function main() {
             }
         }
         db.close();
+        const systemMessage = recoveryLines.join('\n');
+        // 디버그 로그 (성공 케이스)
+        try {
+            const factsCount = handover?.keyFacts.length || 0;
+            const errsCount = handover?.recentErrors.length || 0;
+            fs.appendFileSync(debugLogPath, `[${new Date().toISOString()}] project=${project} sid=${sid} transcript_msgs=${transcriptLen} sysmsg_len=${systemMessage.length} active_file=${handover?.activeFile || 'none'} pending=${handover?.pendingAction ? 'yes' : 'no'} facts=${factsCount} errs=${errsCount} status=ok\n`);
+        }
+        catch { /* ignore */ }
         const output = {
             continue: true,
-            systemMessage: recoveryLines.join('\n')
+            systemMessage
         };
         process.stdout.write(JSON.stringify(output));
         process.exit(0);
     }
     catch (e) {
-        // 에러 시 조용히 종료
+        // fail-soft: 컴팩션이 멈추지 않도록 continue:true 반드시 반환
+        try {
+            const dbPath = getDbPath(cwdForErrorLog);
+            const debugLogPath = path.join(path.dirname(dbPath), 'pre-compact-debug.log');
+            const errMsg = e instanceof Error ? `${e.name}: ${e.message}` : String(e);
+            fs.appendFileSync(debugLogPath, `[${new Date().toISOString()}] status=error err=${errMsg.slice(0, 200)}\n`);
+        }
+        catch { /* ignore */ }
+        process.stdout.write(JSON.stringify({ continue: true }));
         process.exit(0);
     }
 }

package/dist/hooks/session-end.js

@@ -12,7 +12,9 @@
 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';
+import { logHookError } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -183,6 +185,10 @@ function extractNextTasks(content) {
  * 사용자 메시지를 유효한 요청인지 필터링
  */
 function parseUserText(entry) {
+    // 슬래시 커맨드 확장으로 주입된 메타 턴은 사용자 요청이 아님
+    // (예: "# /work - 프로젝트 작업 메인 명령어 (v2)…" 커맨드 본문 전체가 여기 들어옴)
+    if (entry.isMeta === true)
+        return '';
     const content = entry.message?.content;
     let text = '';
     if (typeof content === 'string') {
@@ -194,6 +200,11 @@ function parseUserText(entry) {
             .map(b => b.text || '')
             .join('\n');
     }
+    // 슬래시 커맨드 실행 시 실제 사용자 요청은 <command-args> 안에 있음 → 삭제 말고 추출
+    const argsMatch = text.match(/<command-args>([\s\S]*?)<\/command-args>/);
+    if (argsMatch && argsMatch[1].trim().length >= 3) {
+        return argsMatch[1].trim();
+    }
     // system-reminder, local-command 태그 제거
     text = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
     text = text.replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, '').trim();
@@ -238,6 +249,8 @@ async function parseTranscriptSinglePass(transcriptPath) {
         userRequests: { firstRequest: '', allRequests: [] },
         recentAssistantMessages: [],
         errorFixPairs: [],
+        firstTimestamp: null,
+        lastTimestamp: null,
     };
     if (!transcriptPath || !fs.existsSync(transcriptPath))
         return result;
@@ -267,6 +280,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 +362,11 @@ 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 (한국어 패턴 보강)
+    // P3 (2026-07-08): '충돌' 제거 — 영상 파이프라인 "충돌(collision) 컷" 잡담이
+    // 에러로 오분류되던 주 원인. 진짜 conflict 에러는 라틴 토큰으로 매칭됨.
+    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 +391,69 @@ 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;
+}
+/**
+ * URL 정규화: 같은 도메인 + path는 같은 노이즈로 취급
+ * (P1-3, 2026-05-22) Google Forms ID, AdMob app ID 같은 동적 segment 제거
+ *
+ * 예: https://docs.google.com/forms/d/e/1FAIpQLScm.../viewform
+ *  →  https://docs.google.com/forms/...
+ */
+function normalizeUrls(text) {
+    if (!text)
+        return text;
+    return text.replace(/(https?:\/\/[^\s]+)/gi, (match) => {
+        try {
+            const url = new URL(match);
+            // path의 첫 1~2 segment만 유지, 나머지(ID/토큰)는 '...'로 축약
+            const segments = url.pathname.split('/').filter(s => s);
+            const keepCount = segments.length <= 2 ? segments.length : 2;
+            const truncated = segments.slice(0, keepCount).join('/');
+            return `${url.protocol}//${url.host}/${truncated}${segments.length > keepCount ? '/...' : ''}`;
+        }
+        catch {
+            return match;
+        }
+    });
+}
 /**
  * 사용자 메시지들을 세션 요약으로 압축
  * 예: ["MCP 테스트해줘", "개선해줘", "npm 배포하고 커밋해줘"] → "MCP 테스트 + 개선 + npm 배포/커밋"
@@ -377,12 +461,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 +503,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 +568,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 +578,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 +658,79 @@ 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(`
+        // 중복 저장 방지 — 3단계 dedup
+        // P1-3 (2026-05-22): Q8에서 발견된 3 클러스터(25 세션) 분석 결과
+        //   • Google Forms URL × 12 (1h~2h 간격) — URL 정규화 + 24h 윈도우로 해결
+        //   • IAP "이어서 진행해줘" × 8 (5h 분포, 동일 텍스트) — 24h exact로 해결
+        //   • AdMob URL × 5 — URL 정규화로 해결
+        // 1단계: 24시간 내 exact 일치 차단 (이전 1h → 24h, 동일 last_work 반복 막음)
+        // 2단계: URL 정규화 후 exact 일치 (Forms/AdMob ID 무시)
+        // 3단계: stripSlashPrefix 정규화 후 Jaccard >= 0.85 (1h 윈도우)
+        const recentExact = db.prepare(`
       SELECT id FROM sessions
-      WHERE project = ? AND last_work = ? AND timestamp > datetime('now', '-1 hour')
+      WHERE project = ? AND last_work = ? AND timestamp > datetime('now', '-24 hour')
       LIMIT 1
     `).get(project, lastWork);
-        if (recentDup) {
-            console.log(`[SessionEnd] Skipping duplicate session for ${project}`);
+        if (recentExact) {
+            console.log(`[SessionEnd] Skipping duplicate (exact, 24h) for ${project}`);
             db.close();
             process.exit(0);
         }
+        // 2단계: URL 정규화 후 exact (24h 윈도우)
+        const normalizedLastWorkUrl = normalizeUrls(lastWork);
+        if (normalizedLastWorkUrl !== lastWork) {
+            const recent24h = db.prepare(`
+        SELECT last_work FROM sessions
+        WHERE project = ? AND timestamp > datetime('now', '-24 hour')
+        ORDER BY timestamp DESC LIMIT 20
+      `).all(project);
+            for (const row of recent24h) {
+                if (!row.last_work)
+                    continue;
+                if (normalizeUrls(row.last_work) === normalizedLastWorkUrl) {
+                    console.log(`[SessionEnd] Skipping URL-normalized duplicate for ${project}`);
+                    db.close();
+                    process.exit(0);
+                }
+            }
+        }
+        // 3단계: Jaccard 유사도 (24h 윈도우)
+        // P2 (2026-07-08): 1h 윈도우가 너무 좁아 시간 넘는 near-dup이 통과했음.
+        //   실측: /mcp-dev 클러스터 60건이 수 시간~수일 간격으로 반복 저장됨.
+        //   1·2단계(exact/URL)가 이미 24h이므로 Jaccard만 1h인 건 불일치 → 24h로 통일.
+        //   임계값 0.85는 매우 높아 "진짜 다른 작업"은 24h로 넓혀도 통과(Phase 4 검증).
+        const recentRows = db.prepare(`
+      SELECT last_work FROM sessions
+      WHERE project = ? AND timestamp > datetime('now', '-24 hour')
+      ORDER BY timestamp DESC LIMIT 30
+    `).all(project);
+        for (const row of recentRows) {
+            if (!row.last_work)
+                continue;
+            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,26 +738,69 @@ async function main() {
             errorsSolved
         };
         const hasMetadata = commitMessages.length > 0 || decisions.length > 0 || errorsSolved.length > 0;
-        // 세션 기록 저장
+        // P3 (2026-07-08): duration_minutes 계산 폐기.
+        // transcript first↔last 차이는 resume/continue 시 벽시계 경과(최대 30일)를 담아
+        // 실측 33%가 24h 초과로 신뢰 불가였고, 이 필드를 읽는 소비처가 코드 전체에 없음.
+        // 컬럼은 스키마에 유지(NULL로 남김), INSERT만 중단.
+        // 세션 기록 저장 — 원자적 조건부 INSERT로 페어 race 차단.
+        // P2b (2026-07-08): 두 hook 인스턴스가 같은 초에 동시 발화하면(transcript 락을
+        //   우회한 sid-less 페어) 앞 단계 dedup은 서로의 미커밋 행을 못 봐 둘 다 통과 →
+        //   id 897/898처럼 동일 last_work+timestamp 2행 저장(실측 재현).
+        //   INSERT ... WHERE NOT EXISTS로 "최근 10초 내 동일 project+last_work"를 원자적
+        //   단일 문장에서 재확인 → race 윈도우 제거. 10초 초과 정당한 재작업은 통과.
         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);
+      SELECT ?, ?, ?, ?, ?
+      WHERE NOT EXISTS (
+        SELECT 1 FROM sessions
+        WHERE project = ? AND last_work = ?
+          AND timestamp > datetime('now', '-10 seconds')
+      )
+    `).run(project, lastWork, JSON.stringify([...new Set(nextTasks)].slice(0, 5)), JSON.stringify(modifiedFiles.slice(0, 15)), hasMetadata ? JSON.stringify(metadata) : null, project, lastWork);
         // 활성 컨텍스트 업데이트
         db.prepare(`
       INSERT OR REPLACE INTO active_context (project, current_state, recent_files, updated_at)
       VALUES (?, ?, ?, datetime('now'))
     `).run(project, lastWork, JSON.stringify(modifiedFiles.slice(0, 15)));
         // 에러→솔루션 자동 기록 (solutions 테이블)
+        // P1-4 (2026-05-22): 품질 필터 + 동일 solution 텍스트 dedup 추가
         let solutionsRecorded = 0;
         if (transcript.errorFixPairs.length > 0) {
             try {
                 for (const pair of transcript.errorFixPairs) {
-                    const existing = db.prepare('SELECT id FROM solutions WHERE project = ? AND error_signature = ? LIMIT 1').get(project, pair.error);
-                    if (!existing) {
-                        db.prepare('INSERT INTO solutions (project, error_signature, solution) VALUES (?, ?, ?)').run(project, pair.error, pair.fix);
-                        solutionsRecorded++;
-                    }
+                    const errSig = pair.error?.trim() || '';
+                    const sol = pair.fix?.trim() || '';
+                    // 품질 필터: stub/짧음/footer 거부
+                    if (sol.length < 30)
+                        continue;
+                    if (/^(\[이미\s*완료\]|✅\s*완료|✅\s*푸시\s*완료|done|완료)\s*$/i.test(sol))
+                        continue;
+                    if (sol.includes('Co-Authored-By:'))
+                        continue;
+                    if (errSig.length < 5)
+                        continue;
+                    // P3 (2026-07-08): error_signature 품질 게이트 — 대화 잡음 거부.
+                    // errorRe가 '문제/충돌' 같은 일상어를 에러로 오분류해 내레이션 파편이
+                    // 시그니처로 저장됐음(실측 28% 노이즈).
+                    // 다국어(영어+한국어) 지원:
+                    //   - 라틴 문자([A-Za-z])가 있으면 영어 에러(TypeError, Build failed,
+                    //     ECONNREFUSED, undefined …)로 간주해 전부 통과.
+                    //   - 라틴이 없는 순수 한국어는 구체적 에러 표현이 있을 때만 통과.
+                    //   - 둘 다 없는 순수 파편(문제/충돌 단독)만 거부.
+                    const hasErrorSignal = /[A-Za-z]/.test(errSig) ||
+                        /(실패|오류|누락|초과|깨짐|깨진|중단|크래시|안 ?됨|불가|타임아웃|한도)/.test(errSig);
+                    if (!hasErrorSignal)
+                        continue;
+                    // 1차 dedup: 동일 error_signature
+                    const existingByError = db.prepare('SELECT id FROM solutions WHERE project = ? AND error_signature = ? LIMIT 1').get(project, errSig);
+                    if (existingByError)
+                        continue;
+                    // 2차 dedup: 동일 solution 텍스트 (다른 error라도 같은 해법은 중복)
+                    const existingBySol = db.prepare('SELECT id FROM solutions WHERE project = ? AND solution = ? LIMIT 1').get(project, sol);
+                    if (existingBySol)
+                        continue;
+                    db.prepare('INSERT INTO solutions (project, error_signature, solution) VALUES (?, ?, ?)').run(project, errSig, sol);
+                    solutionsRecorded++;
                 }
             }
             catch { /* solutions table may not exist */ }
@@ -588,6 +826,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);
@@ -608,6 +875,7 @@ async function main() {
         process.exit(0);
     }
     catch (e) {
+        logHookError('session-end', e);
         process.exit(0);
     }
 }

package/dist/hooks/session-start.js

@@ -5,6 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
+import { logHookError } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -72,6 +73,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`];
@@ -123,7 +125,10 @@ function loadContext(dbPath, project) {
         try {
             const directives = db.prepare(`
         SELECT directive, priority FROM user_directives
-        WHERE project = ? ORDER BY priority DESC, created_at DESC LIMIT 5
+        WHERE project = ?
+        ORDER BY CASE priority WHEN 'high' THEN 3 WHEN 'normal' THEN 2 WHEN 'low' THEN 1 ELSE 0 END DESC,
+                 created_at DESC
+        LIMIT 5
       `).all(project);
             if (directives.length > 0) {
                 const directiveLines = ['## Directives'];
@@ -172,21 +177,25 @@ function loadContext(dbPath, project) {
             catch { /* table may not exist */ }
         }
         // [Priority 5] 중요 메모리 (temporal decay 적용, 예산 내에서)
+        // P0 (2026-05-22): reference/observation 타입 + global(project=NULL) 메모리 포함
+        //   사용자 pain: "서버 주소 기억할 때도 있고 못할 때도 있다"
+        //   원인: SessionStart가 reference 타입 미포함 + project filter가 NULL 거름
         if (tokenBudget > 80)
             try {
                 const memories = db.prepare(`
         SELECT content, memory_type, importance, created_at, access_count FROM memories
-        WHERE project = ?
-          AND memory_type IN ('decision', 'learning', 'error', 'preference')
+        WHERE (project = ? OR project IS NULL)
+          AND memory_type IN ('decision', 'learning', 'error', 'preference', 'reference', 'observation')
           AND importance >= 3
           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 20
+        ORDER BY importance DESC, accessed_at DESC LIMIT 30
       `).all(project);
                 if (memories.length > 0) {
-                    // Decay 적용 후 top 5 선택
+                    // Decay 적용 후 top 5 선택 (reference는 decay 거의 0 — 인프라 정보는 영구)
                     const DECAY_RATES = {
-                        decision: 0.001, learning: 0.003, error: 0.01, preference: 0.002
+                        decision: 0.001, learning: 0.003, error: 0.01, preference: 0.002,
+                        reference: 0.0001, observation: 0.005
                     };
                     const scored = memories.map(m => {
                         const ageDays = (Date.now() - new Date(m.created_at).getTime()) / (1000 * 60 * 60 * 24);
@@ -195,7 +204,8 @@ function loadContext(dbPath, project) {
                         return { ...m, score };
                     }).sort((a, b) => b.score - a.score).slice(0, 5);
                     const typeIcons = {
-                        decision: '🎯', learning: '📚', error: '⚠️', preference: '💡'
+                        decision: '🎯', learning: '📚', error: '⚠️', preference: '💡',
+                        reference: '🔧', observation: '👁'
                     };
                     const memoryLines = ['## Key Memories'];
                     for (const m of scored) {
@@ -257,7 +267,7 @@ async function main() {
         process.exit(0);
     }
     catch (e) {
-        // 에러 시 조용히 종료
+        logHookError('session-start', e);
         process.exit(0);
     }
 }

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

@@ -5,6 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
+import { logHookError } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -46,14 +47,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) {
@@ -65,48 +71,221 @@ function extractPastKeywords(prompt) {
     }
     return null;
 }
+/**
+ * Korean + English 일반 stopword
+ * (Proactive trigger matching용 — 사용자 발상 "전부 기록하되 트리거 매칭" 구현)
+ */
+const STOPWORDS = new Set([
+    // 한국어 빈출 (조사/대명사/일반 동사/부사)
+    '있다', '없다', '하다', '되다', '이다', '아니다', '같다', '보다', '주다', '받다', '쓰다', '놓다',
+    '하는', '있는', '없는', '되는', '이런', '저런', '그런', '이게', '저게', '그게', '이것', '저것', '그것',
+    '내가', '네가', '우리', '저희', '당신', '자기', '지금', '이제', '오늘', '어제', '내일', '다음', '이전',
+    '하나', '둘', '셋', '정말', '진짜', '아주', '너무', '매우', '조금', '약간', '대충', '그냥', '일단',
+    '그리고', '하지만', '그래서', '그래도', '근데', '그런데', '또는', '또한', '이런데', '그런데',
+    '진행', '확인', '시작', '완료', '종료', '해줘', '해주세요', '부탁', '알려', '알려줘',
+    // 범용 명사 (LIKE 검색 시 아무 메모리나 잡는 오탐원 — 2026-07-08 C3)
+    '이름', '정보', '내용', '관련', '부분', '상태', '방법', '문제', '경우', '생각', '이야기', '얘기',
+    '어떻게', '무엇', '뭐가', '왜', '어디', '언제', '어느', '어떤', '어떻', '얼마',
+    // 한국어 2글자 빈출 (v1.14.3에서 한국어 길이 임계값 2로 낮춤에 따라 추가)
+    '이거', '그거', '저거', '한번', '두번', '코드', '작업', '뭐했지', '뭐였지', '봐줘', '한거지', '했지',
+    // 영어 빈출 추가 — Next.js 같은 동음이의 발생하는 토큰
+    'next', 'last', 'first', 'prev', 'previous', 'check', 'test', 'run', 'live', 'ready', 'verify', 'verification',
+    'session', 'task', 'item', 'case', 'file', 'line', 'data', 'code', 'word', 'time', 'step', 'part', 'side',
+    // 영어 빈출 stopwords
+    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
+    'do', 'does', 'did', 'will', 'would', 'should', 'could', 'can', 'may', 'might', 'must',
+    'this', 'that', 'these', 'those', 'it', 'its', 'they', 'them', 'their', 'we', 'our',
+    'you', 'your', 'i', 'my', 'me', 'what', 'when', 'where', 'why', 'how', 'which', 'who',
+    'and', 'or', 'but', 'if', 'then', 'else', 'also', 'so', 'as', 'at', 'by', 'for', 'from', 'in', 'of', 'on', 'to', 'with',
+    'just', 'only', 'very', 'really', 'also', 'too', 'still', 'here', 'there', 'now', 'then',
+]);
+/**
+ * Prompt에서 의미 있는 한국어/영어 키워드 추출
+ * (P0+ 2026-05-22: 사용자 "트리거 매칭" 발상 구현)
+ *
+ * @returns 키워드 배열 (3자 이상, stopword 제외, 중복 제거, 최대 5개)
+ */
+function extractTriggerKeywords(prompt) {
+    if (!prompt || prompt.length < 5)
+        return [];
+    // 1. 따옴표/괄호/마크다운/슬래시 명령 제거
+    const cleaned = prompt
+        .replace(/```[\s\S]*?```/g, ' ') // 코드 블록
+        .replace(/`[^`]+`/g, ' ') // 인라인 코드
+        .replace(/^\/[a-z-]+\s*/i, '') // 슬래시 명령 prefix
+        .replace(/[*_~`"'()[\]{}<>]/g, ' '); // 특수문자
+    // 2. 토큰화 (한글/영문 단어만)
+    // v1.14.3: 한국어 길이 임계값 2, 영어는 3 (한국어는 2글자 단어 많음 — 서버/주소/명령)
+    const tokens = cleaned
+        .split(/[\s,.!?;:/\\|]+/)
+        .map(t => t.trim().toLowerCase())
+        .filter(t => /^[a-z0-9가-힣]+$/i.test(t)) // 영숫자+한글만
+        .filter(t => {
+        // 한국어 단일 음절은 거의 무의미, 2글자 이상 허용
+        const hasHangul = /[가-힣]/.test(t);
+        return hasHangul ? t.length >= 2 : t.length >= 3;
+    })
+        .filter(t => !STOPWORDS.has(t))
+        .filter(t => !/^\d+$/.test(t)); // 숫자만은 제외
+    // 3. 중복 제거 (등장 순서 유지)
+    const seen = new Set();
+    const unique = [];
+    for (const t of tokens) {
+        if (!seen.has(t)) {
+            seen.add(t);
+            unique.push(t);
+        }
+    }
+    // 4. 최대 5개
+    return unique.slice(0, 5);
+}
+/**
+ * IDF 필터: 너무 흔한 토큰 제거
+ * (2026-05-23: "commit and push" false positive 발견 — feat/commit/fix 같은
+ *  커밋 메시지 토큰이 14/85 메모리에 등장해 IDF가 낮음)
+ *
+ * IDF = log(N / df), N = 총 메모리 수
+ * 임계값 IDF >= 2.0 (= 흔한 토큰 약 13% 이상 등장 시 제외)
+ * 실측: commit(idf 1.80), feat(1.96) 차단 + ec2(4.44), 서명키(4.44) 통과
+ *
+ * v1.14.3 (2026-05-23): df=0 토큰은 살리지 않고 제외 (이전엔 살림).
+ * 이유: "check next session for live verification" 케이스에서 session/live/
+ *      verification은 df=0인데 살아서 카운트만 채우고 실제 매칭은 next 단일
+ *      토큰("Next.js")에 의해 false positive 발생. df=0 토큰은 FTS5 매칭에
+ *      기여 0이므로 trigger 조건 자체에서 제외하는 게 맞음.
+ *
+ * @returns 살아남은 키워드 (희소한 의미 토큰만)
+ */
+function filterByIdf(db, keywords) {
+    if (keywords.length === 0)
+        return [];
+    try {
+        const totalRow = db.prepare('SELECT COUNT(*) AS n FROM memories').get();
+        const N = Math.max(totalRow.n, 1);
+        const survived = [];
+        const stmt = db.prepare('SELECT COUNT(*) AS df FROM memories_fts WHERE memories_fts MATCH ?');
+        for (const kw of keywords) {
+            try {
+                const ftsQ = `"${kw.replace(/"/g, '""')}"`;
+                const row = stmt.get(ftsQ);
+                const df = row.df;
+                // v1.14.3 다시 정정: df=0 토큰은 살림 (한국어 부분일치/표기 차이 보완)
+                // 예: 메모리에 "비번"으로 적혔지만 사용자가 "비밀번호" 입력 → df=0, 그러나
+                //     같이 추출된 "서명키"가 매칭해주면 trigger 정상 작동
+                if (df === 0) {
+                    survived.push(kw);
+                    continue;
+                }
+                const idf = Math.log(N / df);
+                if (idf >= 2.0) {
+                    survived.push(kw);
+                }
+            }
+            catch {
+                survived.push(kw); // FTS5 구문 오류 시 보수적으로 살림
+            }
+        }
+        return survived;
+    }
+    catch {
+        return keywords; // DF 측정 실패 시 원본 그대로
+    }
+}
+/**
+ * Proactive trigger: 추출된 키워드로 memories_fts + bm25 검색
+ * 임계값: bm25 score < -2 (강한 매칭만, false positive 최소화)
+ * + IDF 필터로 너무 흔한 토큰(commit/feat/fix 등) 제거
+ *
+ * @returns top 2 매칭 memories (or empty)
+ */
+function searchTriggeredMemories(db, keywords, project) {
+    // IDF 필터: 흔한 토큰 제거
+    const meaningful = filterByIdf(db, keywords);
+    if (meaningful.length < 2)
+        return []; // IDF 통과 토큰 2개 이상일 때만 trigger
+    try {
+        const ftsQuery = meaningful.map(k => `"${k.replace(/"/g, '""')}"`).join(' OR ');
+        const projectFilter = project ? `AND (m.project = ? OR m.project IS NULL)` : '';
+        const params = [ftsQuery];
+        if (project)
+            params.push(project);
+        const rows = db.prepare(`
+      SELECT m.content, m.memory_type, bm25(memories_fts) AS score
+      FROM memories_fts fts
+      JOIN memories m ON m.id = fts.rowid
+      WHERE memories_fts MATCH ?
+      ${projectFilter}
+      AND m.importance >= 5
+      AND (m.tags NOT LIKE '%auto-tracked%' OR m.tags IS NULL)
+      ORDER BY score ASC
+      LIMIT 5
+    `).all(...params);
+        // bm25 score < -2 강한 매칭만 (낮을수록 관련도 높음)
+        return rows.filter(r => r.score < -2).slice(0, 2);
+    }
+    catch {
+        return [];
+    }
+}
 function searchPastWork(db, keyword) {
     const result = { sessions: [], memories: [], solutions: [] };
-    const likeKeyword = `%${keyword}%`;
-    // 1. sessions 검색 (최근 30일, 상위 3건)
+    // C3 (2026-07-08): 다단어 구("GCP 코인 정보")를 통째 LIKE/MATCH하면
+    //   조사·어순 때문에 거의 안 맞았음. 구를 토큰화해 OR 검색으로 커버.
+    //   단, 흔한 토큰(이름/정보 등)은 IDF로 걸러야 오탐 방지 — "강아지 이름"의
+    //   '이름'이 무관한 앱-이름 메모리와 매칭되던 문제.
+    // 토큰화 결과가 비면 = 의미 토큰이 없는 질문(예: "내 정보 가지고 있나"의 '정보').
+    // 원본 keyword로 폴백하면 흔한 단어로 아무 메모리나 잡으므로 검색 안 함.
+    const rawTokens = extractTriggerKeywords(keyword);
+    if (rawTokens.length === 0)
+        return result;
+    // IDF로 흔한 토큰 추가 제거. 남는 게 없으면(전부 흔함) 검색 안 함.
+    const searchTokens = filterByIdf(db, rawTokens);
+    if (searchTokens.length === 0)
+        return result;
+    // 1. sessions 검색 (최근 30일, 상위 3건) — 토큰 LIKE OR
     try {
+        const likeClause = searchTokens.map(() => 'last_work LIKE ?').join(' OR ');
+        const likeParams = searchTokens.map(t => `%${t}%`);
         const sessions = db.prepare(`
       SELECT last_work, timestamp FROM sessions
-      WHERE last_work LIKE ?
+      WHERE (${likeClause})
         AND last_work != 'Session ended'
         AND last_work != 'Session work completed'
         AND last_work != 'Session started'
         AND last_work != ''
         AND timestamp > datetime('now', '-30 days')
       ORDER BY timestamp DESC LIMIT 3
-    `).all(likeKeyword);
+    `).all(...likeParams);
         for (const s of sessions) {
             const work = s.last_work.length > 80 ? s.last_work.slice(0, 80) + '...' : s.last_work;
             result.sessions.push({ date: s.timestamp?.slice(0, 10) || 'unknown', work });
         }
     }
     catch { /* ignore */ }
-    // 2. memories FTS5 검색 (상위 2건)
+    // 2. memories FTS5 검색 (상위 2건) — 토큰 OR 쿼리
     try {
+        const ftsQuery = searchTokens.map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
         const memories = db.prepare(`
       SELECT m.content, m.memory_type FROM memories m
       JOIN memories_fts fts ON m.id = fts.rowid
       WHERE memories_fts MATCH ?
       ORDER BY rank LIMIT 2
-    `).all(keyword);
+    `).all(ftsQuery);
         for (const m of memories) {
             const content = m.content.length > 80 ? m.content.slice(0, 80) + '...' : m.content;
             result.memories.push({ type: m.memory_type, content });
         }
     }
     catch {
-        // FTS5 매칭 실패 시 LIKE 폴백
+        // FTS5 매칭 실패 시 LIKE 폴백 (토큰 OR)
         try {
+            const likeClause = searchTokens.map(() => 'content LIKE ?').join(' OR ');
+            const likeParams = searchTokens.map(t => `%${t}%`);
             const memories = db.prepare(`
         SELECT content, memory_type FROM memories
-        WHERE content LIKE ?
+        WHERE ${likeClause}
         ORDER BY importance DESC, created_at DESC LIMIT 2
-      `).all(likeKeyword);
+      `).all(...likeParams);
             for (const m of memories) {
                 const content = m.content.length > 80 ? m.content.slice(0, 80) + '...' : m.content;
                 result.memories.push({ type: m.memory_type, content });
@@ -116,11 +295,16 @@ function searchPastWork(db, keyword) {
     }
     // 3. solutions 검색 (상위 2건)
     try {
+        const clause = searchTokens.map(() => '(error_signature LIKE ? OR solution LIKE ?)').join(' OR ');
+        const params = [];
+        for (const t of searchTokens) {
+            params.push(`%${t}%`, `%${t}%`);
+        }
         const solutions = db.prepare(`
       SELECT error_signature, solution FROM solutions
-      WHERE error_signature LIKE ? OR solution LIKE ?
+      WHERE ${clause}
       ORDER BY created_at DESC LIMIT 2
-    `).all(likeKeyword, likeKeyword);
+    `).all(...params);
         for (const s of solutions) {
             const sol = s.solution.length > 80 ? s.solution.slice(0, 80) + '...' : s.solution;
             result.solutions.push({ signature: s.error_signature, solution: sol });
@@ -173,15 +357,44 @@ const DIRECTIVE_PATTERNS = [
     { pattern: /(?:rule|규칙)[:\s]+(.+)/i, priority: 'normal' },
 ];
 const MAX_DIRECTIVES = 20;
+/**
+ * directive 품질 게이트 (P4, 2026-07-08).
+ * DIRECTIVE_PATTERNS의 `.+` 탐욕 캡처가, 사용자가 붙여넣은 어시스턴트 산출물
+ * (JSON 평가지/스토리보드/코드)에서 '절대/반드시/must' 부분문자열 뒤를 통째로
+ * 잡아 지시문으로 오추출했음(실측 45건 중 42건 오염, 30건이 200자 cap run-on).
+ * 진짜 지시문은 짧고 자족적 — 데이터/코드 구문 냄새가 나면 거부.
+ * 다국어(영어+한국어) 모두 커버.
+ */
+function isValidDirective(d) {
+    if (d.length > 120)
+        return false; // run-on 캡처
+    if (/"\s*:\s*|"\s*\}|\{\s*"|"\},\{"|\}\]|\}\}/.test(d))
+        return false; // JSON 구조 구문
+    if (/"(?:whatWorks|itemCode|weight|factor|impact|verdict|correction|role|path|purpose|problem|action|files)"/.test(d))
+        return false; // 평가지/JSON 키
+    if (d.includes('`') || d.includes('**') || /\|.*\|.*\|/.test(d))
+        return false; // 코드/마크다운 표
+    if ((d.match(/"/g) || []).length >= 4)
+        return false; // 따옴표 과다=구조화 데이터
+    // 어시스턴트 산문 중간이 잘린 파편은 소문자 라틴 문자로 시작함
+    // (진짜 영어 지시문은 대문자 명령형: "Never …", "Always …", "Do NOT …").
+    // 한국어 지시문은 이 검사에 안 걸림(라틴 소문자로 시작 안 함).
+    if (/^[a-z]/.test(d))
+        return false;
+    return true;
+}
 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]) {
                 const directive = match[1].trim().slice(0, 200);
                 if (directive.length < 5)
                     continue;
+                if (!isValidDirective(directive))
+                    continue;
                 // UPSERT directive
                 db.prepare(`
           INSERT INTO user_directives (project, directive, context, source, priority)
@@ -233,7 +446,7 @@ async function main() {
         if (input.prompt) {
             extractAndSaveDirectives(dbPath, project, input.prompt);
         }
-        // 과거 참조 감지 시에만 출력 (~200 토큰)
+        // 1. 명시적 과거 참조 ("저번에", "예전에" 등) — 기존 동작 유지
         if (input.prompt && fs.existsSync(dbPath)) {
             const keyword = extractPastKeywords(input.prompt);
             if (keyword) {
@@ -248,10 +461,33 @@ async function main() {
                 }
                 catch { /* ignore */ }
             }
+            else {
+                // 2. Proactive trigger: 명시적 참조 없어도 키워드 매칭으로 관련 메모리 inject
+                // (P0+ 2026-05-22: 사용자 "트리거 매칭" 발상 구현)
+                // 임계값: 추출 키워드 ≥2개 + bm25 score < -2 (강한 매칭만)
+                try {
+                    const triggerKws = extractTriggerKeywords(input.prompt);
+                    if (triggerKws.length >= 2) {
+                        const db = new Database(dbPath, { readonly: true });
+                        const triggered = searchTriggeredMemories(db, triggerKws, project);
+                        db.close();
+                        if (triggered.length > 0) {
+                            const lines = ['## Triggered Memory (auto-matched from your prompt)'];
+                            for (const m of triggered) {
+                                const content = m.content.length > 120 ? m.content.slice(0, 120) + '...' : m.content;
+                                lines.push(`- [${m.memory_type}] ${content}`);
+                            }
+                            console.log(`\n<triggered-context project="${project ?? 'global'}" keywords="${triggerKws.join(',')}">\n${lines.join('\n')}\n</triggered-context>\n`);
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+            }
         }
         process.exit(0);
     }
     catch (e) {
+        logHookError('user-prompt-submit', e);
         process.exit(0);
     }
 }

package/dist/index.js

@@ -1500,35 +1500,76 @@ async function handleTool(name, args) {
                     }
                 }
                 else {
-                    // LIKE 기반 키워드 검색 (FTS5보다 안정적)
-                    // 검색어를 단어로 분리하여 OR 조건으로 검색
+                    // FTS5 + bm25() 랭킹 우선, 결과 없으면 LIKE 폴백
+                    // (P1-2, 2026-05-22: 7-agent 검증 후 적용)
                     const words = query.split(/\s+/).filter(w => w.length > 0);
-                    const likeConditions = words.map(() => '(content LIKE ? OR tags LIKE ?)').join(' OR ');
-                    const likeParams = [];
-                    words.forEach(w => {
-                        likeParams.push(`%${w}%`, `%${w}%`);
-                    });
-                    let sql = `
-            SELECT * FROM memories
-            WHERE (${likeConditions || 'content LIKE ?'})
-            AND importance >= ?
-          `;
-                    const params = [...(likeConditions ? likeParams : [`%${query}%`]), minImportance];
-                    if (memoryType && memoryType !== 'all') {
-                        sql += ` AND memory_type = ?`;
-                        params.push(memoryType);
+                    // 1차: FTS5 MATCH + bm25() 점수
+                    let ftsResults = [];
+                    try {
+                        const ftsQuery = words.length > 0
+                            ? words.map(w => `"${w.replace(/"/g, '""')}"`).join(' OR ')
+                            : query;
+                        let ftsSql = `
+              SELECT m.*, bm25(memories_fts) AS bm25_score
+              FROM memories_fts fts
+              JOIN memories m ON m.id = fts.rowid
+              WHERE memories_fts MATCH ?
+              AND m.importance >= ?
+            `;
+                        const ftsParams = [ftsQuery, minImportance];
+                        if (memoryType && memoryType !== 'all') {
+                            ftsSql += ` AND m.memory_type = ?`;
+                            ftsParams.push(memoryType);
+                        }
+                        if (project) {
+                            ftsSql += ` AND m.project = ?`;
+                            ftsParams.push(project);
+                        }
+                        if (tags && tags.length > 0) {
+                            ftsSql += ` AND (${tags.map(() => 'm.tags LIKE ?').join(' OR ')})`;
+                            ftsParams.push(...tags.map(t => `%"${t}"%`));
+                        }
+                        // bm25는 낮을수록 관련도 높음. importance 가중치 더해 종합 랭킹.
+                        ftsSql += ` ORDER BY bm25_score ASC, m.importance DESC LIMIT ?`;
+                        ftsParams.push(limit);
+                        ftsResults = db.prepare(ftsSql).all(...ftsParams);
                     }
-                    if (project) {
-                        sql += ` AND project = ?`;
-                        params.push(project);
+                    catch {
+                        // FTS5 구문 오류(MATCH 토큰 이슈) 시 폴백
+                        ftsResults = [];
                     }
-                    if (tags && tags.length > 0) {
-                        sql += ` AND (${tags.map(() => 'tags LIKE ?').join(' OR ')})`;
-                        params.push(...tags.map(t => `%"${t}"%`));
+                    if (ftsResults.length > 0) {
+                        results = ftsResults;
+                    }
+                    else {
+                        // 2차 폴백: LIKE (FTS5 0건 시 — 한국어 부분일치 등)
+                        const likeConditions = words.map(() => '(content LIKE ? OR tags LIKE ?)').join(' OR ');
+                        const likeParams = [];
+                        words.forEach(w => {
+                            likeParams.push(`%${w}%`, `%${w}%`);
+                        });
+                        let sql = `
+              SELECT * FROM memories
+              WHERE (${likeConditions || 'content LIKE ?'})
+              AND importance >= ?
+            `;
+                        const params = [...(likeConditions ? likeParams : [`%${query}%`]), minImportance];
+                        if (memoryType && memoryType !== 'all') {
+                            sql += ` AND memory_type = ?`;
+                            params.push(memoryType);
+                        }
+                        if (project) {
+                            sql += ` AND project = ?`;
+                            params.push(project);
+                        }
+                        if (tags && tags.length > 0) {
+                            sql += ` AND (${tags.map(() => 'tags LIKE ?').join(' OR ')})`;
+                            params.push(...tags.map(t => `%"${t}"%`));
+                        }
+                        sql += ` ORDER BY importance DESC, accessed_at DESC LIMIT ?`;
+                        params.push(limit);
+                        results = db.prepare(sql).all(...params);
                     }
-                    sql += ` ORDER BY importance DESC, accessed_at DESC LIMIT ?`;
-                    params.push(limit);
-                    results = db.prepare(sql).all(...params);
                 }
                 // 접근 기록 업데이트
                 const ids = results.map(r => r.id);

package/dist/utils/logger.d.ts

@@ -14,4 +14,15 @@ declare class Logger {
     withTool<T>(toolName: string, fn: () => Promise<T>, args?: Record<string, unknown>): Promise<T>;
 }
 export declare const logger: Logger;
+/**
+ * Hook 치명적 오류 로거 — outer catch 전용.
+ *
+ * 배경: 2026-07-08, Node를 v26(ABI 147)로 업그레이드하면서 better-sqlite3
+ * 네이티브 모듈(ABI 141)이 로드 실패 → 5개 hook 전부 outer catch에서
+ * 조용히 exit(0). 18일간 세션이 한 건도 저장되지 않았는데 아무 흔적도 없었음.
+ * fail-soft는 유지하되, 반드시 흔적을 남긴다.
+ *
+ * 로그 위치: $HOOK_ERROR_LOG > cwd/.claude/hook-errors.log > ~/.claude/hook-errors.log
+ */
+export declare function logHookError(hook: string, err: unknown): void;
 export {};

package/dist/utils/logger.js

@@ -1,5 +1,6 @@
 // 구조화된 로깅 시스템
 import * as fs from 'fs';
+import * as path from 'path';
 // 민감 정보 패턴
 const SENSITIVE_PATTERNS = [
     /password["\s:=]+["']?[\w\-!@#$%^&*]+["']?/gi,
@@ -109,3 +110,31 @@ class Logger {
 }
 // 싱글톤 인스턴스
 export const logger = new Logger();
+/**
+ * Hook 치명적 오류 로거 — outer catch 전용.
+ *
+ * 배경: 2026-07-08, Node를 v26(ABI 147)로 업그레이드하면서 better-sqlite3
+ * 네이티브 모듈(ABI 141)이 로드 실패 → 5개 hook 전부 outer catch에서
+ * 조용히 exit(0). 18일간 세션이 한 건도 저장되지 않았는데 아무 흔적도 없었음.
+ * fail-soft는 유지하되, 반드시 흔적을 남긴다.
+ *
+ * 로그 위치: $HOOK_ERROR_LOG > cwd/.claude/hook-errors.log > ~/.claude/hook-errors.log
+ */
+export function logHookError(hook, err) {
+    try {
+        const candidates = [
+            process.env.HOOK_ERROR_LOG,
+            path.join(process.cwd(), '.claude', 'hook-errors.log'),
+            path.join(process.env.HOME || '/tmp', '.claude', 'hook-errors.log'),
+        ].filter(Boolean);
+        const line = `[${new Date().toISOString()}] hook=${hook} ${err instanceof Error ? (err.stack || err.message) : String(err)}\n`;
+        for (const p of candidates) {
+            try {
+                fs.appendFileSync(p, line);
+                return;
+            }
+            catch { /* try next candidate */ }
+        }
+    }
+    catch { /* never throw from the error logger */ }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-session-continuity-mcp",
-  "version": "1.13.1",
+  "version": "1.15.0",
   "description": "Session Continuity for Claude Code - Never re-explain your project again",
   "type": "module",
   "main": "dist/index.js",
@@ -60,7 +60,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@xenova/transformers": "^2.17.0",
-    "better-sqlite3": "^12.6.2",
+    "better-sqlite3": "^12.11.1",
     "zod": "^3.23.0"
   },
   "devDependencies": {