claude-session-continuity-mcp 1.15.0 → 1.16.0

package/README.md

@@ -1,13 +1,14 @@
-# claude-session-continuity-mcp (v1.13.2)
+# 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,6 +63,42 @@ 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.
+
+---
+
+## 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
@@ -635,3 +672,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/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,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 } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -83,6 +83,10 @@ const STOPWORDS = new Set([
     '하나', '둘', '셋', '정말', '진짜', '아주', '너무', '매우', '조금', '약간', '대충', '그냥', '일단',
     '그리고', '하지만', '그래서', '그래도', '근데', '그런데', '또는', '또한', '이런데', '그런데',
     '진행', '확인', '시작', '완료', '종료', '해줘', '해주세요', '부탁', '알려', '알려줘',
+    // 흔한 작업 동사·부사 (P1, 2026-07-08: 작은 코퍼스에서 df가 낮아 IDF를 통과해
+    //   오탐을 유발했음. "저장/기억/다시" 등이 GCP·영상 메모리를 엉뚱하게 소환)
+    '저장', '기억', '삭제', '수정', '검색', '등록', '변경', '추가', '제거', '생성', '실행', '설정',
+    '전체', '다시', '이렇게', '그렇게', '저렇게', '계속', '먼저', '바로', '같이', '제대로', '하나하나',
     // 범용 명사 (LIKE 검색 시 아무 메모리나 잡는 오탐원 — 2026-07-08 C3)
     '이름', '정보', '내용', '관련', '부분', '상태', '방법', '문제', '경우', '생각', '이야기', '얘기',
     '어떻게', '무엇', '뭐가', '왜', '어디', '언제', '어느', '어떤', '어떻', '얼마',
@@ -91,6 +95,11 @@ const STOPWORDS = new Set([
     // 영어 빈출 추가 — 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',
@@ -120,6 +129,12 @@ function extractTriggerKeywords(prompt) {
         .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);
@@ -154,7 +169,8 @@ function extractTriggerKeywords(prompt) {
  *      토큰("Next.js")에 의해 false positive 발생. df=0 토큰은 FTS5 매칭에
  *      기여 0이므로 trigger 조건 자체에서 제외하는 게 맞음.
  *
- * @returns 살아남은 키워드 (희소한 의미 토큰만)
+ * @returns 살아남은 키워드 + 각 df (P1 audit-7 2026-07-08: df를 함께 반환해
+ *          searchTriggeredMemories의 inCorpus 재쿼리 제거)
  */
 function filterByIdf(db, keywords) {
     if (keywords.length === 0)
@@ -173,22 +189,22 @@ function filterByIdf(db, keywords) {
                 // 예: 메모리에 "비번"으로 적혔지만 사용자가 "비밀번호" 입력 → df=0, 그러나
                 //     같이 추출된 "서명키"가 매칭해주면 trigger 정상 작동
                 if (df === 0) {
-                    survived.push(kw);
+                    survived.push({ kw, df: 0 });
                     continue;
                 }
                 const idf = Math.log(N / df);
                 if (idf >= 2.0) {
-                    survived.push(kw);
+                    survived.push({ kw, df });
                 }
             }
             catch {
-                survived.push(kw); // FTS5 구문 오류 시 보수적으로 살림
+                survived.push({ kw, df: -1 }); // FTS5 구문 오류 시 보수적으로 살림 (df 불명=-1)
             }
         }
         return survived;
     }
     catch {
-        return keywords; // DF 측정 실패 시 원본 그대로
+        return keywords.map(kw => ({ kw, df: -1 })); // DF 측정 실패 시 원본 그대로
     }
 }
 /**
@@ -203,8 +219,17 @@ function searchTriggeredMemories(db, keywords, project) {
     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 = meaningful.map(k => `"${k.replace(/"/g, '""')}"`).join(' OR ');
+        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)
@@ -239,7 +264,8 @@ function searchPastWork(db, keyword) {
     if (rawTokens.length === 0)
         return result;
     // IDF로 흔한 토큰 추가 제거. 남는 게 없으면(전부 흔함) 검색 안 함.
-    const searchTokens = filterByIdf(db, rawTokens);
+    // 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
@@ -456,7 +482,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 */ }
@@ -477,7 +503,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/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/package.json

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