claude-session-continuity-mcp 1.15.1 → 1.16.1

package/README.md

@@ -81,6 +81,24 @@ If you want zero-config, offline, no-cost memory that just *happens* while you w
 
 ---
 
+## Works with Codex CLI too (v1.16.0+)
+
+Beyond Claude Code, this also supports **OpenAI Codex CLI**. If `~/.codex` exists,
+the installer registers the same hooks in `~/.codex/hooks.json` (SessionStart,
+UserPromptSubmit, PreCompact, Stop), and the hooks auto-detect the host and emit
+the right output format (Codex's `hookSpecificOutput.additionalContext`).
+
+The same local `sessions.db` is shared, so context carries across both agents:
+what you did in Codex is available in Claude Code and vice versa.
+
+**Scope:** session save + context injection work on both. Codex file-change
+tracking (PostToolUse) isn't wired yet — session save already covers most of it
+via transcript parsing. Codex's `transcript_path` is treated as an unstable
+interface (it can be null at startup), so host detection uses an installer-injected
+`--codex` marker rather than relying on the path.
+
+---
+
 ## Quick Start
 
 ### Recommended: Global Installation

package/dist/hooks/install.js

@@ -16,6 +16,9 @@ const CLAUDE_DIR = path.join(os.homedir(), '.claude');
 const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
 const LEGACY_SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.local.json');
 const MCP_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
+// Codex CLI (2026-07-09): hooks register in ~/.codex/hooks.json (same JSON shape as Claude)
+const CODEX_DIR = path.join(os.homedir(), '.codex');
+const CODEX_HOOKS_FILE = path.join(CODEX_DIR, 'hooks.json');
 // 설치된 패키지 경로 찾기
 function getPackagePath() {
     // 1. 글로벌 설치 확인
@@ -123,6 +126,44 @@ function installMcpServer() {
         return false;
     }
 }
+/**
+ * Register the same hooks in ~/.codex/hooks.json for OpenAI Codex CLI (2026-07-09).
+ * Only runs if ~/.codex exists (Codex installed). Preserves user's existing hooks;
+ * replaces only ours (matched by the claude-hook- command prefix).
+ */
+function installCodexHooks() {
+    if (!fs.existsSync(CODEX_DIR))
+        return; // Codex not installed -> skip silently
+    const OUR_PREFIX = 'claude-hook-';
+    let hooksConfig = { hooks: {} };
+    if (fs.existsSync(CODEX_HOOKS_FILE)) {
+        try {
+            hooksConfig = JSON.parse(fs.readFileSync(CODEX_HOOKS_FILE, 'utf-8'));
+        }
+        catch {
+            hooksConfig = { hooks: {} };
+        }
+    }
+    const hooks = hooksConfig.hooks || {};
+    const merge = (event, ourEntries) => {
+        const existing = (hooks[event] || []);
+        const userEntries = existing.filter(e => !(e.hooks || []).some(h => h.command && h.command.includes(OUR_PREFIX)));
+        hooks[event] = [...userEntries, ...ourEntries];
+    };
+    // Codex uses the same event names as Claude (SessionStart/UserPromptSubmit/Stop...).
+    // Append "--codex" so hooks detect the host reliably: Codex passes transcript_path
+    // as null at SessionStart, so the argv marker is the only dependable signal.
+    merge('SessionStart', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-session-start --codex' }] }]);
+    merge('UserPromptSubmit', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-user-prompt --codex' }] }]);
+    merge('PreCompact', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-pre-compact --codex' }] }]);
+    merge('Stop', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-session-end --codex' }] }]);
+    hooksConfig.hooks = hooks;
+    try {
+        fs.writeFileSync(CODEX_HOOKS_FILE, JSON.stringify(hooksConfig, null, 2));
+        console.log('✅ Codex CLI hooks installed (~/.codex/hooks.json)');
+    }
+    catch { /* non-fatal: Codex hooks are optional */ }
+}
 function install() {
     console.log('');
     console.log('╔════════════════════════════════════════════════════════════╗');
@@ -170,6 +211,9 @@ function install() {
     ]);
     settings.hooks = hooks;
     saveSettings(settings);
+    // Codex CLI hooks (2026-07-09): register the same hooks in ~/.codex/hooks.json
+    // if Codex is present. Hooks auto-detect the host and emit the right output format.
+    installCodexHooks();
     console.log('✅ Hooks installed (npm exec mode - works with local or global install!)');
     console.log('   SessionStart: context auto-load');
     console.log('   UserPromptSubmit: relevant memory injection');
@@ -224,6 +268,24 @@ function uninstall() {
         settings.hooks = hooks;
     }
     saveSettings(settings);
+    // Also remove our hooks from Codex (2026-07-09), preserving user's hooks.
+    if (fs.existsSync(CODEX_HOOKS_FILE)) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(CODEX_HOOKS_FILE, 'utf-8'));
+            const ch = cfg.hooks || {};
+            for (const event of ['SessionStart', 'UserPromptSubmit', 'PreCompact', 'Stop']) {
+                const existing = (ch[event] || []);
+                const remaining = existing.filter(e => !(e.hooks || []).some(h => h.command && h.command.includes(OUR_PREFIX)));
+                if (remaining.length === 0)
+                    delete ch[event];
+                else
+                    ch[event] = remaining;
+            }
+            cfg.hooks = ch;
+            fs.writeFileSync(CODEX_HOOKS_FILE, JSON.stringify(cfg, null, 2));
+        }
+        catch { /* non-fatal */ }
+    }
     console.log('✅ Hooks removed successfully!');
 }
 function status() {

package/dist/hooks/session-end.js

@@ -14,7 +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';
+import { logHookError, isCodexHost } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -207,6 +207,8 @@ function parseUserText(entry) {
     }
     // system-reminder, local-command 태그 제거
     text = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+    // Codex support (2026-07-09): Codex injects <environment_context> into the first user message -> strip it
+    text = text.replace(/<environment_context>[\s\S]*?<\/environment_context>/g, '').trim();
     text = text.replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, '').trim();
     text = text.replace(/<command-name>[\s\S]*?<\/command-name>/g, '').trim();
     text = text.replace(/<command-message>[\s\S]*?<\/command-message>/g, '').trim();
@@ -237,6 +239,64 @@ function extractTextFromContent(content) {
     }
     return '';
 }
+/**
+ * Codex support (2026-07-09): normalize a Codex CLI rollout JSONL line into the
+ * Claude transcript entry shape, so the rest of parseTranscriptSinglePass
+ * (role/content/timestamp/commit/user-request extraction) can be reused as-is.
+ *
+ * Codex format: {timestamp, type, payload}
+ *   - payload.type=message, role=user/assistant, content[].text (input_text/output_text)
+ *   - payload.type=function_call, arguments={command:["zsh","-lc","git commit..."]}
+ *   - payload.type=session_meta (first line, ignored)
+ *   - reasoning/token_count etc. are ignored
+ * Returns a Claude-shaped entry ({type, timestamp, message:{content:[...]}}) or null (skip).
+ */
+function normalizeCodexLine(codexEntry) {
+    const p = codexEntry.payload;
+    if (!p)
+        return null;
+    const ts = codexEntry.timestamp;
+    // 1. user/assistant message -> text block
+    if (p.type === 'message' && (p.role === 'user' || p.role === 'assistant')) {
+        const text = (p.content || [])
+            .filter(c => c.type === 'input_text' || c.type === 'output_text' || c.type === 'text')
+            .map(c => c.text || '')
+            .join('\n');
+        if (!text)
+            return null;
+        return {
+            type: p.role === 'user' ? 'user' : 'assistant',
+            timestamp: ts,
+            message: { content: [{ type: 'text', text }] },
+        };
+    }
+    // 2. function_call(shell) -> tool_use block (for git commit extraction).
+    //    Codex passes command as an argv array (["zsh","-lc","git commit -m ..."]).
+    if (p.type === 'function_call' && p.arguments) {
+        let cmd = '';
+        try {
+            const args = JSON.parse(p.arguments);
+            if (Array.isArray(args.command)) {
+                // Codex uses ["zsh","-lc","<actual cmd>"]. The commit regex requires
+                // "^git" or "&& git", so strip the shell wrapper (zsh/bash -lc/-c)
+                // and keep only the actual command.
+                const a = args.command;
+                cmd = (a.length >= 3 && /^(zsh|bash|sh)$/.test(a[0]) && /^-[lc]+$/.test(a[1]))
+                    ? a.slice(2).join(' ')
+                    : a.join(' ');
+            }
+        }
+        catch { /* arguments not JSON -> skip */ }
+        if (!cmd)
+            return null;
+        return {
+            type: 'assistant',
+            timestamp: ts,
+            message: { content: [{ type: 'tool_use', input: { command: cmd } }] },
+        };
+    }
+    return null; // skip reasoning/token_count/session_meta etc.
+}
 /**
  * Single-Pass Transcript Parser
  * JSONL을 1회 스트림으로 읽으며 모든 데이터를 동시 추출
@@ -254,6 +314,8 @@ async function parseTranscriptSinglePass(transcriptPath) {
     };
     if (!transcriptPath || !fs.existsSync(transcriptPath))
         return result;
+    // Host detection: Codex uses ~/.codex/sessions/...rollout-*.jsonl, Claude uses ~/.claude/projects/...
+    const isCodex = isCodexHost(transcriptPath); // shared detection (argv marker or path)
     // commit 추출용 패턴
     const commitPatterns = [
         /git commit.*?-m\s*"\$\(cat <<'?EOF'?\n(.+?)(?:\n\n|\nCo-Authored|\nEOF)/s,
@@ -277,7 +339,11 @@ async function parseTranscriptSinglePass(transcriptPath) {
             if (!line.trim())
                 continue;
             try {
-                const entry = JSON.parse(line);
+                const rawEntry = JSON.parse(line);
+                // For Codex, normalize the rollout line into a Claude entry shape. Skipped lines (reasoning etc.) return null.
+                const entry = isCodex ? normalizeCodexLine(rawEntry) : rawEntry;
+                if (!entry)
+                    continue;
                 const role = entry.type || entry.role || '';
                 const content = entry.message?.content;
                 // === 0. Timestamp 추출 (세션 duration 계산용) ===

package/dist/hooks/session-start.js

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
-import { logHookError } from '../utils/logger.js';
+import { logHookError, emitContext, isCodexHost } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -259,10 +259,13 @@ async function main() {
         const dbPath = path.join(workspaceRoot, '.claude', 'sessions.db');
         const context = loadContext(dbPath, project);
         if (context) {
-            console.log(`\n<session-context project="${project}">\n${context}\n</session-context>\n`);
+            emitContext(`\n<session-context project="${project}">\n${context}\n</session-context>\n`, 'SessionStart', input.transcript_path);
         }
         else {
-            console.log(`\n[Session] Project: ${project} (no context yet)\n`);
+            // Only Claude gets the "no context" placeholder; Codex would just get empty context.
+            if (!isCodexHost(input.transcript_path)) {
+                console.log(`\n[Session] Project: ${project} (no context yet)\n`);
+            }
         }
         process.exit(0);
     }

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

@@ -5,7 +5,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
-import { logHookError } from '../utils/logger.js';
+import { logHookError, emitContext } from '../utils/logger.js';
+import { tokenizeQuery } from '../utils/tokenize.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -72,87 +73,14 @@ 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개)
+ * Prompt에서 의미 있는 한국어/영어 키워드 추출 (트리거용, 최대 5개)
+ * 토큰화 로직은 utils/tokenize.ts로 공용화됨 (memory_search와 공유, 2026-07-09).
+ * 트리거는 프롬프트 길이 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);
+    return tokenizeQuery(prompt, 5);
 }
 /**
  * IDF 필터: 너무 흔한 토큰 제거
@@ -482,7 +410,7 @@ async function main() {
                     const pastSection = formatPastWork(pastWork);
                     db.close();
                     if (pastSection) {
-                        console.log(`\n<past-context project="${project}">\n${pastSection}\n</past-context>\n`);
+                        emitContext(`\n<past-context project="${project}">\n${pastSection}\n</past-context>\n`, 'UserPromptSubmit', input.transcript_path);
                     }
                 }
                 catch { /* ignore */ }
@@ -503,7 +431,7 @@ async function main() {
                                 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`);
+                            emitContext(`\n<triggered-context project="${project ?? 'global'}" keywords="${triggerKws.join(',')}">\n${lines.join('\n')}\n</triggered-context>\n`, 'UserPromptSubmit', input.transcript_path);
                         }
                     }
                 }

package/dist/index.js

@@ -22,6 +22,7 @@ import { mkdirSync, existsSync } from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
 import Database from 'better-sqlite3';
+import { tokenizeQuery, buildFtsQuery } from './utils/tokenize.js';
 // @xenova/transformers - 동적 import (sharp 의존성 문제 방지)
 let transformersModule = null;
 async function loadTransformers() {
@@ -1265,7 +1266,12 @@ async function handleTool(name, args) {
                 }
                 else {
                     // 키워드 검색 (LIKE 기반, 단어별 OR)
-                    const words = query.split(/\s+/).filter(w => w.length > 0);
+                    // 2026-07-09 audit-7 방안A: 공용 토큰화(stopword 제거)로 흔한 단어가 아무
+                    //   solution이나 잡는 오탐 감소. 의미 토큰이 없으면 raw split 폴백.
+                    const solTokens = tokenizeQuery(query);
+                    const words = solTokens.length > 0
+                        ? solTokens
+                        : query.split(/\s+/).filter(w => w.length > 0);
                     const wordConditions = words.map(() => '(error_signature LIKE ? OR error_message LIKE ? OR solution LIKE ? OR keywords LIKE ?)').join(' OR ');
                     const wordParams = [];
                     words.forEach(w => {
@@ -1502,13 +1508,16 @@ async function handleTool(name, args) {
                 else {
                     // FTS5 + bm25() 랭킹 우선, 결과 없으면 LIKE 폴백
                     // (P1-2, 2026-05-22: 7-agent 검증 후 적용)
-                    const words = query.split(/\s+/).filter(w => w.length > 0);
+                    // 2026-07-09 audit-7 방안A: 공용 토큰화로 자동주입과 같은 한국어/다구 품질.
+                    //   의미 토큰이 없으면 raw split 폴백(recall 보존).
+                    const semanticTokens = tokenizeQuery(query);
+                    const words = semanticTokens.length > 0
+                        ? semanticTokens
+                        : query.split(/\s+/).filter(w => w.length > 0);
                     // 1차: FTS5 MATCH + bm25() 점수
                     let ftsResults = [];
                     try {
-                        const ftsQuery = words.length > 0
-                            ? words.map(w => `"${w.replace(/"/g, '""')}"`).join(' OR ')
-                            : query;
+                        const ftsQuery = buildFtsQuery(words, true) ?? query; // expandEnglish: 영어 복수/시제 recall
                         let ftsSql = `
               SELECT m.*, bm25(memories_fts) AS bm25_score
               FROM memories_fts fts

package/dist/tools-v2/memory.js

@@ -4,6 +4,7 @@ import { db } from '../db/database.js';
 import { generateEmbedding, embeddingToBuffer, bufferToEmbedding, cosineSimilarity } from '../utils/embedding.js';
 import { logger } from '../utils/logger.js';
 import { MemoryStoreSchema, MemorySearchSchema, MemoryGetSchema, MemoryDeleteSchema } from '../schemas.js';
+import { tokenizeQuery, buildFtsQuery } from '../utils/tokenize.js';
 // ===== Temporal Decay =====
 const DECAY_RATES = {
     decision: 0.001, // 반감기 ~693일
@@ -228,7 +229,11 @@ export async function handleMemorySearch(args) {
     }, args);
 }
 async function performFTSSearch(query, type, project, limit = 10, minImportance = 1, detail = false) {
-    const ftsQuery = query.split(/\s+/).filter(w => w.length > 1).join(' OR ');
+    // 공용 토큰화(어미 절삭+STOPWORDS+길이 필터)로 자동주입과 같은 검색 품질.
+    // 의미 토큰이 하나도 안 남으면(전부 stopword) raw split으로 폴백 — recall 보존.
+    const tokens = tokenizeQuery(query);
+    const ftsQuery = buildFtsQuery(tokens, true) // expandEnglish: 복수/시제 변형 OR (영어권 recall)
+        ?? query.split(/\s+/).filter(w => w.length > 1).join(' OR ');
     let sql = `
     SELECT m.id, m.content, m.memory_type, m.tags, m.project, m.importance, m.created_at, m.access_count
     FROM memories_fts fts

package/dist/utils/logger.d.ts

@@ -25,4 +25,21 @@ export declare const logger: Logger;
  * 로그 위치: $HOOK_ERROR_LOG > cwd/.claude/hook-errors.log > ~/.claude/hook-errors.log
  */
 export declare function logHookError(hook: string, err: unknown): void;
+/**
+ * Detect whether the hook is running under OpenAI Codex CLI (vs Claude Code).
+ *
+ * Two signals (either is sufficient):
+ *  1. A "--codex" argv marker injected by our installer into ~/.codex/hooks.json.
+ *     This is the reliable signal — Codex passes transcript_path as null at
+ *     SessionStart (fresh session, rollout not yet written), so path alone fails.
+ *  2. Transcript path under ~/.codex/sessions/...rollout-*.jsonl (fallback for
+ *     Stop/UserPromptSubmit where the rollout already exists).
+ */
+export declare function isCodexHost(transcriptPath?: string): boolean;
+/**
+ * Emit context to stdout in the host's expected format (Codex support, 2026-07-09).
+ * - Claude Code injects raw stdout text directly.
+ * - Codex CLI expects {hookSpecificOutput:{hookEventName, additionalContext}}.
+ */
+export declare function emitContext(context: string, hookEventName: string, transcriptPath?: string): void;
 export {};

package/dist/utils/logger.js

@@ -138,3 +138,35 @@ export function logHookError(hook, err) {
     }
     catch { /* never throw from the error logger */ }
 }
+/**
+ * Detect whether the hook is running under OpenAI Codex CLI (vs Claude Code).
+ *
+ * Two signals (either is sufficient):
+ *  1. A "--codex" argv marker injected by our installer into ~/.codex/hooks.json.
+ *     This is the reliable signal — Codex passes transcript_path as null at
+ *     SessionStart (fresh session, rollout not yet written), so path alone fails.
+ *  2. Transcript path under ~/.codex/sessions/...rollout-*.jsonl (fallback for
+ *     Stop/UserPromptSubmit where the rollout already exists).
+ */
+export function isCodexHost(transcriptPath) {
+    if (process.argv.includes('--codex'))
+        return true;
+    if (!transcriptPath)
+        return false;
+    return transcriptPath.includes('/.codex/sessions/') || /rollout-.*\.jsonl$/.test(transcriptPath);
+}
+/**
+ * Emit context to stdout in the host's expected format (Codex support, 2026-07-09).
+ * - Claude Code injects raw stdout text directly.
+ * - Codex CLI expects {hookSpecificOutput:{hookEventName, additionalContext}}.
+ */
+export function emitContext(context, hookEventName, transcriptPath) {
+    if (isCodexHost(transcriptPath)) {
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: { hookEventName, additionalContext: context },
+        }));
+    }
+    else {
+        console.log(context);
+    }
+}

package/dist/utils/tokenize.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Korean + English 일반 stopword
+ * (자동주입 트리거 매칭 + 명시 검색 공용)
+ */
+export declare const STOPWORDS: Set<string>;
+/**
+ * 쿼리/프롬프트에서 의미 있는 한국어/영어 키워드 추출.
+ *
+ * - 한국어 동사 어미 절삭("저장해줘"→"저장"), 단일 조사(로/를/이/가)는 명사 훼손 방지로 보존
+ * - 한국어 2글자 이상, 영어 3글자 이상
+ * - STOPWORDS 및 숫자-only 제외
+ * - 중복 제거(등장 순서 유지)
+ *
+ * @param text 원본 문자열
+ * @param maxTokens 상한 (자동주입 트리거는 5, 명시 검색은 무제한 = Infinity)
+ * @returns 키워드 배열
+ */
+export declare function tokenizeQuery(text: string, maxTokens?: number): string[];
+/**
+ * 토큰들을 FTS5 MATCH 쿼리로 조립("token1" OR "token2" ...). 토큰이 없으면 null.
+ * memory_search 계열이 raw split 대신 이걸 쓰면 자동주입과 같은 품질을 얻는다.
+ *
+ * @param expandEnglish 영어 복수/시제 변형도 OR에 포함(명시 검색 recall↑). 자동주입
+ *   트리거는 오탐 억제가 중요하니 기본 false, memory_search는 true 권장.
+ */
+export declare function buildFtsQuery(tokens: string[], expandEnglish?: boolean): string | null;

package/dist/utils/tokenize.js

@@ -0,0 +1,128 @@
+// 공용 쿼리 토큰화 (2026-07-09, audit-7 방안 A)
+// 배경: 자동주입 hook(user-prompt-submit)은 어미 절삭 + STOPWORDS + 길이 필터로
+//   한국어/다구 검색 품질을 확보하는데, 명시 검색(memory_search)은 raw split(/\s+/)만
+//   써서 품질이 낮았다(audit-7 Stage2 실측 CONFIRMED). 이 토큰화를 공용화해 양쪽이 공유한다.
+/**
+ * Korean + English 일반 stopword
+ * (자동주입 트리거 매칭 + 명시 검색 공용)
+ */
+export const STOPWORDS = new Set([
+    // 한국어 빈출 (조사/대명사/일반 동사/부사)
+    '있다', '없다', '하다', '되다', '이다', '아니다', '같다', '보다', '주다', '받다', '쓰다', '놓다',
+    '하는', '있는', '없는', '되는', '이런', '저런', '그런', '이게', '저게', '그게', '이것', '저것', '그것',
+    '내가', '네가', '우리', '저희', '당신', '자기', '지금', '이제', '오늘', '어제', '내일', '다음', '이전',
+    '하나', '둘', '셋', '정말', '진짜', '아주', '너무', '매우', '조금', '약간', '대충', '그냥', '일단',
+    '그리고', '하지만', '그래서', '그래도', '근데', '그런데', '또는', '또한', '이런데', '그런데',
+    '진행', '확인', '시작', '완료', '종료', '해줘', '해주세요', '부탁', '알려', '알려줘',
+    // 흔한 작업 동사·부사
+    '저장', '기억', '삭제', '수정', '검색', '등록', '변경', '추가', '제거', '생성', '실행', '설정',
+    '전체', '다시', '이렇게', '그렇게', '저렇게', '계속', '먼저', '바로', '같이', '제대로', '하나하나',
+    // 범용 명사
+    '이름', '정보', '내용', '관련', '부분', '상태', '방법', '문제', '경우', '생각', '이야기', '얘기',
+    '어떻게', '무엇', '뭐가', '왜', '어디', '언제', '어느', '어떤', '어떻', '얼마',
+    // 한국어 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',
+    // 영어 작업 동사
+    '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',
+]);
+/**
+ * 쿼리/프롬프트에서 의미 있는 한국어/영어 키워드 추출.
+ *
+ * - 한국어 동사 어미 절삭("저장해줘"→"저장"), 단일 조사(로/를/이/가)는 명사 훼손 방지로 보존
+ * - 한국어 2글자 이상, 영어 3글자 이상
+ * - STOPWORDS 및 숫자-only 제외
+ * - 중복 제거(등장 순서 유지)
+ *
+ * @param text 원본 문자열
+ * @param maxTokens 상한 (자동주입 트리거는 5, 명시 검색은 무제한 = Infinity)
+ * @returns 키워드 배열
+ */
+export function tokenizeQuery(text, maxTokens = Infinity) {
+    if (!text || text.length < 2)
+        return [];
+    const cleaned = text
+        .replace(/```[\s\S]*?```/g, ' ') // 코드 블록
+        .replace(/`[^`]+`/g, ' ') // 인라인 코드
+        .replace(/^\/[a-z-]+\s*/i, '') // 슬래시 명령 prefix
+        .replace(/[*_~`"'()[\]{}<>]/g, ' '); // 특수문자
+    const tokens = cleaned
+        .split(/[\s,.!?;:/\\|]+/)
+        .map(t => t.trim().toLowerCase())
+        .filter(t => /^[a-z0-9가-힣]+$/i.test(t))
+        .map(t => t.replace(/(해줘|해주세요|해주라|했어|했지|하는|하고|해서|합니다|드려|드릴게)$/, ''))
+        .filter(t => t.length > 0)
+        .filter(t => {
+        const hasHangul = /[가-힣]/.test(t);
+        return hasHangul ? t.length >= 2 : t.length >= 3;
+    })
+        .filter(t => !STOPWORDS.has(t))
+        .filter(t => !/^\d+$/.test(t));
+    const seen = new Set();
+    const unique = [];
+    for (const t of tokens) {
+        if (!seen.has(t)) {
+            seen.add(t);
+            unique.push(t);
+        }
+    }
+    return maxTokens === Infinity ? unique : unique.slice(0, maxTokens);
+}
+/**
+ * 영어 토큰의 경량 어간 변형 생성 (2026-07-09, 영어권 유저 고려).
+ * FTS5는 정확 일치라 "servers"로 검색하면 "server"로 저장된 메모리를 놓친다.
+ * Porter 같은 무거운 stemmer 대신, 흔한 어미(복수 s/es, 과거 ed, 진행 ing)만
+ * 벗겨 원형 후보를 만든다. 원형과 변형을 FTS5 OR에 함께 넣어 recall을 높인다.
+ *
+ * 보수적 규칙 (과절삭 방지):
+ *  - 5글자 미만은 건드리지 않음(bus/class 훼손 방지)
+ *  - 한글 포함 토큰은 그대로(영어 규칙 미적용)
+ *
+ * @returns 원형 후보 (없으면 빈 배열). 호출부에서 원 토큰과 합쳐 dedupe.
+ */
+function englishVariants(token) {
+    if (/[가-힣]/.test(token) || token.length < 5)
+        return [];
+    const out = [];
+    if (token.endsWith('ies') && token.length > 4)
+        out.push(token.slice(0, -3) + 'y'); // libraries→library
+    else if (token.endsWith('es') && token.length > 4)
+        out.push(token.slice(0, -2)); // boxes→box
+    if (token.endsWith('s') && !token.endsWith('ss') && !token.endsWith('us'))
+        out.push(token.slice(0, -1)); // servers→server
+    if (token.endsWith('ing') && token.length > 5)
+        out.push(token.slice(0, -3)); // deploying→deploy
+    if (token.endsWith('ed') && token.length > 4)
+        out.push(token.slice(0, -2)); // saved→sav (불완전하나 FTS OR라 무해)
+    return out;
+}
+/**
+ * 토큰들을 FTS5 MATCH 쿼리로 조립("token1" OR "token2" ...). 토큰이 없으면 null.
+ * memory_search 계열이 raw split 대신 이걸 쓰면 자동주입과 같은 품질을 얻는다.
+ *
+ * @param expandEnglish 영어 복수/시제 변형도 OR에 포함(명시 검색 recall↑). 자동주입
+ *   트리거는 오탐 억제가 중요하니 기본 false, memory_search는 true 권장.
+ */
+export function buildFtsQuery(tokens, expandEnglish = false) {
+    if (tokens.length === 0)
+        return null;
+    const terms = new Set();
+    for (const t of tokens) {
+        terms.add(t);
+        if (expandEnglish)
+            for (const v of englishVariants(t))
+                terms.add(v);
+    }
+    return [...terms].map(t => `"${t.replace(/"/g, '""')}"`).join(' OR ');
+}

package/package.json

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