claude-session-continuity-mcp 1.13.2 → 1.15.1

package/README.md

@@ -1,13 +1,14 @@
-# claude-session-continuity-mcp (v1.13.0)
+# claude-session-continuity-mcp
 
-> **Zero Re-explanation Session Continuity for Claude Code** — Automatic context capture + semantic search + auto error→solution pipeline
+> **Never re-explain your project to Claude again.** 100% local session memory for Claude Code — auto context injection, semantic search, and error→solution recall. Zero config, zero API cost.
 
 [![npm version](https://img.shields.io/npm/v/claude-session-continuity-mcp.svg)](https://www.npmjs.com/package/claude-session-continuity-mcp)
+[![npm downloads](https://img.shields.io/npm/dm/claude-session-continuity-mcp.svg)](https://www.npmjs.com/package/claude-session-continuity-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-111%20passed-brightgreen.svg)]()
-[![Node](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)]()
 [![claude-session-continuity-mcp MCP server](https://glama.ai/mcp/servers/leesgit/claude-session-continuity-mcp/badges/card.svg)](https://glama.ai/mcp/servers/leesgit/claude-session-continuity-mcp)
 
+![Session continuity demo — Claude auto-restores your project context on session start](assets/demo.gif)
+
 ## The Problem
 
 Every new Claude Code session:
@@ -62,18 +63,96 @@ Every new Claude Code session:
 
 ---
 
+## Why this over other memory tools?
+
+Most Claude memory tools rely on **explicit tool calls** ("remember this"), a **cloud API**, or a **background AI worker**. This one is deliberately different:
+
+| | claude-session-continuity-mcp | Typical cloud/AI-memory MCP |
+|---|---|---|
+| **Setup** | `npm i -g` → hooks auto-install | Manual server + API key |
+| **Trigger** | 5 automatic hooks (no commands) | You call a `remember` tool |
+| **Storage** | 100% local SQLite | Cloud / external service |
+| **API cost** | **$0** — local embeddings | Per-token / subscription |
+| **Latency** | < 5ms (on-device) | Network round-trip |
+| **Privacy** | Never leaves your machine | Sent to a provider |
+| **Search** | FTS5 + local semantic, KO/EN/JA cross-lingual | Varies |
+
+If you want zero-config, offline, no-cost memory that just *happens* while you work — this is it.
+
+---
+
 ## 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`):
@@ -575,3 +654,11 @@ PRs welcome! Please:
 
 - [Model Context Protocol](https://modelcontextprotocol.io/) by Anthropic
 - [Xenova Transformers](https://github.com/xenova/transformers.js) for embeddings
+
+---
+
+<div align="center">
+
+**If this saves you from re-explaining your project, consider giving it a ⭐ — it genuinely helps others find it.**
+
+</div>

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 초과 시 정리
@@ -320,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,11 +201,20 @@ 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);
         }
@@ -230,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)');
@@ -277,15 +290,30 @@ 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

@@ -14,6 +14,7 @@ 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;
@@ -184,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') {
@@ -195,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();
@@ -353,7 +363,9 @@ async function parseTranscriptSinglePass(transcriptPath) {
     }
     result.decisions = [...decisionSet].slice(0, 3);
     // Error-Fix pairs (한국어 패턴 보강)
-    const errorRe = /(?:error|Error|ERROR|오류|에러|버그|예외|실패|FAILED|Exception|TypeError|ReferenceError|SyntaxError|crash|crashed|충돌|문제)[:\s](.{5,80})/;
+    // 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++) {
@@ -418,6 +430,30 @@ function jaccardSimilarity(a, b) {
     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 배포/커밋"
@@ -638,28 +674,55 @@ async function main() {
             db.close();
             process.exit(0);
         }
-        // 중복 저장 방지 — Jaccard 유사도 기반 (1시간 이내, 동일 프로젝트)
-        // 베이스라인: 동일 last_work가 4~5분 간격으로 반복 INSERT되는 케이스 5건/24h 발견
-        // 정확 일치 + Jaccard >= 0.85 둘 다 차단
+        // 중복 저장 방지 — 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 (recentExact) {
-            console.log(`[SessionEnd] Skipping duplicate (exact) for ${project}`);
+            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', '-1 hour')
-      ORDER BY timestamp DESC LIMIT 10
+      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;
-            // Phase 5: 비교 전 양쪽 모두 stripSlashPrefix 정규화 → 표현 차이 흡수
             const normalizedCurrent = stripSlashPrefix(lastWork) || lastWork;
             const normalizedRow = stripSlashPrefix(row.last_work) || row.last_work;
             if (jaccardSimilarity(normalizedCurrent, normalizedRow) >= 0.85) {
@@ -675,35 +738,69 @@ async function main() {
             errorsSolved
         };
         const hasMetadata = commitMessages.length > 0 || decisions.length > 0 || errorsSolved.length > 0;
-        // 세션 duration 계산 (transcript first ↔ last timestamp)
-        let durationMinutes = null;
-        if (transcript.firstTimestamp && transcript.lastTimestamp) {
-            const start = new Date(transcript.firstTimestamp).getTime();
-            const end = new Date(transcript.lastTimestamp).getTime();
-            if (!isNaN(start) && !isNaN(end) && end >= start) {
-                durationMinutes = Math.round((end - start) / 60000);
-            }
-        }
-        // 세션 기록 저장
+        // 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, duration_minutes)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(project, lastWork, JSON.stringify([...new Set(nextTasks)].slice(0, 5)), JSON.stringify(modifiedFiles.slice(0, 15)), hasMetadata ? JSON.stringify(metadata) : null, durationMinutes);
+      INSERT INTO sessions (project, last_work, next_tasks, modified_files, issues)
+      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 */ }
@@ -778,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;
@@ -124,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'];
@@ -173,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);
@@ -196,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) {
@@ -258,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;
@@ -70,48 +71,247 @@ function extractPastKeywords(prompt) {
     }
     return null;
 }
+/**
+ * Korean + English 일반 stopword
+ * (Proactive trigger matching용 — 사용자 발상 "전부 기록하되 트리거 매칭" 구현)
+ */
+const STOPWORDS = new Set([
+    // 한국어 빈출 (조사/대명사/일반 동사/부사)
+    '있다', '없다', '하다', '되다', '이다', '아니다', '같다', '보다', '주다', '받다', '쓰다', '놓다',
+    '하는', '있는', '없는', '되는', '이런', '저런', '그런', '이게', '저게', '그게', '이것', '저것', '그것',
+    '내가', '네가', '우리', '저희', '당신', '자기', '지금', '이제', '오늘', '어제', '내일', '다음', '이전',
+    '하나', '둘', '셋', '정말', '진짜', '아주', '너무', '매우', '조금', '약간', '대충', '그냥', '일단',
+    '그리고', '하지만', '그래서', '그래도', '근데', '그런데', '또는', '또한', '이런데', '그런데',
+    '진행', '확인', '시작', '완료', '종료', '해줘', '해주세요', '부탁', '알려', '알려줘',
+    // 흔한 작업 동사·부사 (P1, 2026-07-08: 작은 코퍼스에서 df가 낮아 IDF를 통과해
+    //   오탐을 유발했음. "저장/기억/다시" 등이 GCP·영상 메모리를 엉뚱하게 소환)
+    '저장', '기억', '삭제', '수정', '검색', '등록', '변경', '추가', '제거', '생성', '실행', '설정',
+    '전체', '다시', '이렇게', '그렇게', '저렇게', '계속', '먼저', '바로', '같이', '제대로', '하나하나',
+    // 범용 명사 (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',
+    // 영어 작업 동사 (P1 audit-7, 2026-07-08: 한국어 저장/기억/검색과 대칭. 이들이
+    //   df 낮아 IDF 통과 시 오탐 유발. inCorpus 게이트가 사후 방어하나 명시 차단이 견고)
+    'save', 'store', 'remember', 'search', 'find', 'delete', 'remove', 'update', 'create', 'add',
+    'change', 'edit', 'fix', 'make', 'show', 'list', 'get', 'set', 'build', 'lint', 'deploy',
+    'whole', 'thing', 'again', 'entire', 'stuff', 'something', 'anything', 'everything',
+    // 영어 빈출 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)) // 영숫자+한글만
+        // P1 (2026-07-08): 흔한 한국어 동사 어미만 벗겨 stopword 체크가 먹게 함.
+        //   "저장해줘"→"저장"이 안 되면 STOPWORDS(저장)를 우회해 오탐.
+        //   ⚠️ 단일 글자 조사(로/를/이/가 등)는 절삭 금지 — "경로→경","추가→추"처럼
+        //      진짜 2글자 명사를 훼손함(실측 확인). 명확한 다글자 동사 어미만.
+        .map(t => t.replace(/(해줘|해주세요|해주라|했어|했지|하는|하고|해서|합니다|드려|드릴게)$/, ''))
+        .filter(t => t.length > 0)
+        .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 살아남은 키워드 + 각 df (P1 audit-7 2026-07-08: df를 함께 반환해
+ *          searchTriggeredMemories의 inCorpus 재쿼리 제거)
+ */
+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, df: 0 });
+                    continue;
+                }
+                const idf = Math.log(N / df);
+                if (idf >= 2.0) {
+                    survived.push({ kw, df });
+                }
+            }
+            catch {
+                survived.push({ kw, df: -1 }); // FTS5 구문 오류 시 보수적으로 살림 (df 불명=-1)
+            }
+        }
+        return survived;
+    }
+    catch {
+        return keywords.map(kw => ({ kw, df: -1 })); // 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
+    // P1 (2026-07-08): 실제 코퍼스에 존재하는(df>0) 토큰이 2개 이상일 때만 trigger.
+    //   filterByIdf가 df=0 토큰(코퍼스에 없음)을 살려주는데, 그게 length>=2 게이트를
+    //   우회시켜 실질 단일 토큰 매칭으로 trigger되던 오탐 차단.
+    //   예: "gmail draft로 저장" → gmail(df=1) + draft로(df=0) → 실매칭 1개인데 trigger됐음.
+    //   audit-7 2026-07-08: filterByIdf가 반환한 df를 재사용(중복 쿼리 제거).
+    const inCorpus = meaningful.filter(m => m.df > 0);
+    if (inCorpus.length < 2)
+        return [];
+    const meaningfulKws = meaningful.map(m => m.kw);
+    try {
+        const ftsQuery = meaningfulKws.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로 흔한 토큰 추가 제거. 남는 게 없으면(전부 흔함) 검색 안 함.
+    // audit-7 2026-07-08: filterByIdf가 {kw,df} 반환하도록 바뀜 → kw만 추출.
+    const searchTokens = filterByIdf(db, rawTokens).map(m => m.kw);
+    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 });
@@ -121,11 +321,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 });
@@ -178,6 +383,32 @@ 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);
@@ -188,6 +419,8 @@ function extractAndSaveDirectives(dbPath, project, prompt) {
                 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)
@@ -239,7 +472,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) {
@@ -254,10 +487,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.2",
+  "version": "1.15.1",
   "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": {