@wooojin/forgen 0.2.0 → 0.3.0

package/dist/hooks/solution-injector.js

@@ -25,8 +25,9 @@ import { withFileLock, withFileLockSync, FileLockError } from './shared/file-loc
 // v1: recordPrompt (regex 선호 감지) 제거
 import { calculateBudget } from './shared/context-budget.js';
 import { writeSignal } from './shared/plugin-signal.js';
-import { approve, approveWithContext, failOpen } from './shared/hook-response.js';
+import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
+import { recordHookTiming } from './shared/hook-timing.js';
 const MAX_SOLUTIONS_PER_SESSION = 10;
 /** 세션별 이미 주입된 솔루션 추적 (중복 방지) */
 function getSessionCachePath(sessionId) {
@@ -220,217 +221,243 @@ function backfillCacheTagsOnDisk(cachePath, allMatched) {
     }
 }
 async function main() {
-    const input = await readStdinJSON();
-    if (!isHookEnabled('solution-injector')) {
-        console.log(approve());
-        return;
-    }
-    if (!input?.prompt) {
-        console.log(approve());
-        return;
-    }
-    const sessionId = input.session_id ?? 'default';
-    // v1: 교정 감지 → correction-record 호출 유도 hint
-    const correctionPatterns = /하지\s*마|그렇게\s*말고|앞으로는|이렇게\s*해|stop\s+doing|don'?t\s+do|always\s+do|never\s+do|아니\s*그게\s*아니라/i;
-    if (correctionPatterns.test(input.prompt)) {
+    const _hookStart = Date.now();
+    try {
+        const input = await readStdinJSON();
+        if (!isHookEnabled('solution-injector')) {
+            console.log(approve());
+            return;
+        }
+        if (!input?.prompt) {
+            console.log(approve());
+            return;
+        }
+        const sessionId = input.session_id ?? 'default';
+        // v1: 교정 감지 → correction-record 호출 유도 hint
+        const correctionPatterns = /하지\s*마|그렇게\s*말고|앞으로는|이렇게\s*해|stop\s+doing|don'?t\s+do|always\s+do|never\s+do|아니\s*그게\s*아니라/i;
+        if (correctionPatterns.test(input.prompt)) {
+            try {
+                writeSignal(sessionId, 'correction-detected', 0);
+            }
+            catch { /* non-critical */ }
+        }
+        // 어댑티브 버짓: 다른 플러그인 감지 시 주입��� ���동 축소
+        const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+        const budget = calculateBudget(cwd);
+        const cache = loadSessionCache(sessionId);
+        const injected = cache.injected;
+        // H-1 fix: `let`으로 재할당을 허락하되, commit 이후 fresh total로 갱신된다.
+        // 이전엔 dead variable이었음 (선언 후 재할당 없음).
+        let totalInjectedChars = cache.totalInjectedChars;
+        if (injected.size >= MAX_SOLUTIONS_PER_SESSION || totalInjectedChars >= budget.solutionSessionMax) {
+            if (totalInjectedChars >= budget.solutionSessionMax) {
+                log.debug(`세션 토큰 상한 도달: ${totalInjectedChars}/${budget.solutionSessionMax} chars (factor=${budget.factor})`);
+            }
+            console.log(approve());
+            return;
+        }
+        const scope = resolveScope(cwd);
+        // 프롬프트와 관련된 솔루션 매칭
+        // allMatched는 backfill 용도로 보존: 이미 injected된 entry라도 같은 솔루션이
+        // 다시 매칭되면 그 정보로 cache의 missing tags를 채울 수 있다.
+        // matches는 새 주입 후보 (이미 injected는 제외).
+        const allMatched = matchSolutions(input.prompt, scope, cwd);
+        const matches = allMatched.filter(m => !injected.has(m.name));
+        // T3: emit a ranking-decision record for offline analysis. Fail-open —
+        // the logger swallows any error so this never blocks hook approval.
+        // Runs AFTER ranking (plan: "Add the logging call in solution-injector
+        // after ranking, not before."). `rankedTopN` records what the matcher
+        // returned at log time; subsequent caller-side filtering (budget cap,
+        // experiment cap, session-cache disjoint) is intentionally NOT captured
+        // here — the field's contract is "matcher's top, not final injection set".
         try {
-            writeSignal(sessionId, 'correction-detected', 0);
+            const promptTags = extractTags(input.prompt);
+            const normalizedQuery = defaultNormalizer.normalizeTerms(promptTags);
+            logMatchDecision({
+                source: 'hook',
+                rawQuery: input.prompt,
+                normalizedQuery,
+                candidates: allMatched.map(m => ({
+                    name: m.name,
+                    relevance: m.relevance,
+                    matchedTerms: m.matchedTags,
+                })),
+                rankedTopN: allMatched.slice(0, 5).map(m => m.name),
+            });
         }
-        catch { /* non-critical */ }
-    }
-    // 어댑티브 버짓: 다른 플러그인 감지 시 주입��� ���동 축소
-    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
-    const budget = calculateBudget(cwd);
-    const cache = loadSessionCache(sessionId);
-    const injected = cache.injected;
-    // H-1 fix: `let`으로 재할당을 허락하되, commit 이후 fresh total로 갱신된다.
-    // 이전엔 dead variable이었음 (선언 후 재할당 없음).
-    let totalInjectedChars = cache.totalInjectedChars;
-    if (injected.size >= MAX_SOLUTIONS_PER_SESSION || totalInjectedChars >= budget.solutionSessionMax) {
-        if (totalInjectedChars >= budget.solutionSessionMax) {
-            log.debug(`세션 토큰 상한 도달: ${totalInjectedChars}/${budget.solutionSessionMax} chars (factor=${budget.factor})`);
+        catch (e) {
+            log.debug('match-eval-log emit failed', e);
         }
-        console.log(approve());
-        return;
-    }
-    const scope = resolveScope(cwd);
-    // 프롬프트와 관련된 솔루션 매칭
-    // allMatched는 backfill 용도로 보존: 이미 injected된 entry라도 같은 솔루션이
-    // 다시 매칭되면 그 정보로 cache의 missing tags를 채울 수 있다.
-    // matches는 새 주입 후보 (이미 injected는 제외).
-    const allMatched = matchSolutions(input.prompt, scope, cwd);
-    const matches = allMatched.filter(m => !injected.has(m.name));
-    // T3: emit a ranking-decision record for offline analysis. Fail-open —
-    // the logger swallows any error so this never blocks hook approval.
-    // Runs AFTER ranking (plan: "Add the logging call in solution-injector
-    // after ranking, not before."). `rankedTopN` records what the matcher
-    // returned at log time; subsequent caller-side filtering (budget cap,
-    // experiment cap, session-cache disjoint) is intentionally NOT captured
-    // here — the field's contract is "matcher's top, not final injection set".
-    try {
-        const promptTags = extractTags(input.prompt);
-        const normalizedQuery = defaultNormalizer.normalizeTerms(promptTags);
-        logMatchDecision({
-            source: 'hook',
-            rawQuery: input.prompt,
-            normalizedQuery,
-            candidates: allMatched.map(m => ({
-                name: m.name,
-                relevance: m.relevance,
-                matchedTerms: m.matchedTags,
-            })),
-            rankedTopN: allMatched.slice(0, 5).map(m => m.name),
-        });
-    }
-    catch (e) {
-        log.debug('match-eval-log emit failed', e);
-    }
-    // 신규 주입할 게 없어도 backfill은 수행한다.
-    // R2 fix: matches.length === 0인 경우에도 allMatched에 정보가 있으면
-    // 기존 cache의 missing tags를 채울 수 있다. 이전엔 이 경로를 놓쳐서
-    // backfill fix가 절반만 적용된 상태였다 (Codex/code-reviewer 발견).
-    if (matches.length === 0) {
-        const earlyCachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);
-        backfillCacheTagsOnDisk(earlyCachePath, allMatched);
-        console.log(approve());
-        return;
-    }
-    // 어댑티브 프롬프트당 솔루션 수 제한, experiment는 1개 제한
-    let experimentCount = 0;
-    const toInject = [];
-    for (const sol of matches) {
-        if (injected.has(sol.name))
-            continue;
-        if (sol.status === 'experiment') {
-            if (experimentCount >= 1)
+        // 신규 주입할 게 없어도 backfill은 수행한다.
+        // R2 fix: matches.length === 0인 경우에도 allMatched에 정보가 있으면
+        // 기존 cache의 missing tags를 채울 수 있다. 이전엔 이 경로를 놓쳐서
+        // backfill fix가 절반만 적용된 상태였다 (Codex/code-reviewer 발견).
+        if (matches.length === 0) {
+            const earlyCachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);
+            backfillCacheTagsOnDisk(earlyCachePath, allMatched);
+            console.log(approve());
+            return;
+        }
+        // 어댑티브 프롬프트당 솔루션 수 제한, experiment는 1개 제한
+        let experimentCount = 0;
+        const toInject = [];
+        for (const sol of matches) {
+            if (injected.has(sol.name))
                 continue;
-            experimentCount++;
+            if (sol.status === 'experiment') {
+                if (experimentCount >= 1)
+                    continue;
+                experimentCount++;
+            }
+            toInject.push(sol);
+            if (toInject.length >= Math.min(budget.solutionsPerPrompt, MAX_SOLUTIONS_PER_SESSION - injected.size))
+                break;
         }
-        toInject.push(sol);
-        if (toInject.length >= Math.min(budget.solutionsPerPrompt, MAX_SOLUTIONS_PER_SESSION - injected.size))
-            break;
-    }
-    // Progressive Disclosure Tier 2: 요약만 push, 전문은 MCP compound-read로 pull
-    // 근거: Anthropic "smallest set of high-signal tokens" + Cursor 46.9% 토큰 절감
-    const summaries = new Map();
-    const candidateEntries = [];
-    for (const sol of toInject) {
-        // Tier 2: 한 줄 요약만 생성 (전문 읽기 없음 → 토큰 대폭 절감)
-        const summary = `${sol.name} [${sol.type}|${sol.confidence.toFixed(2)}]: ${sol.matchedTags.slice(0, 5).join(', ')}`;
-        summaries.set(sol.name, summary);
-        candidateEntries.push({ name: sol.name, chars: summary.length });
-    }
-    // H-1 + M-3 fix: lock 안 disjoint 검증으로 새로 추가된 entry만 반환받는다.
-    // 다른 hook이 같은 sessionId로 동시에 같은 솔루션을 inject했다면 이 hook의
-    // commit에서는 newlyAdded에 포함되지 않아 evidence 중복 카운트가 차단된다.
-    const commitResult = commitSessionCacheEntries(sessionId, candidateEntries);
-    // M-1 fix: lock 실패와 정상 0건을 구분.
-    // lock-failed / error: disk 상태 불명 → fail-open으로 approve 하되 warn으로 가시화
-    if (commitResult.status !== 'committed') {
-        log.warn(`session cache commit ${commitResult.status} — hook approving without injection`);
-        console.log(approve());
-        return;
-    }
-    // H-1 fix: commit 이후 fresh disk total로 caller 변수 갱신.
-    // 이전엔 dead variable이라 budget cap이 caller-side stale 값에 의존했다.
-    totalInjectedChars = commitResult.totalInjectedChars;
-    // toInject은 commit 결과의 newlyAdded만 의미 있음 — evidence/cache 갱신은 이 list 기준
-    const newlyAddedNames = new Set(commitResult.newlyAdded.map(e => e.name));
-    const effectiveToInject = toInject.filter(sol => newlyAddedNames.has(sol.name));
-    // 다른 hook이 모두 먼저 inject했다면 effectiveToInject가 0 — 출력할 게 없음
-    if (effectiveToInject.length === 0) {
-        console.log(approve());
-        return;
-    }
-    // Save injection cache for Code Reflection (Phase 2) — cumulative merge
-    // PR2c-1: withFileLock으로 read-modify-write 보호. 동시 hook이 같은 cache를
-    // 만지면 last-writer-wins로 _sessionCounted 등 비트가 사라질 수 있었음.
-    const injectionCachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);
-    try {
-        await withFileLock(injectionCachePath, () => {
-            // Lock 안에서 fresh re-read
-            let existingSolutions = [];
+        // Progressive Disclosure Tier 2.5: 핵심 요약 push (이름+태그+본문 핵심 3줄)
+        // 이전 Tier 2(이름+태그만)는 반영률 0% → Claude가 행동 가능한 정보 부족
+        // 토큰 예산: 솔루션당 최대 300자, 3개 제한 → 최대 ~900자
+        const SUMMARY_MAX_CHARS = 300;
+        const summaries = new Map();
+        const candidateEntries = [];
+        for (const sol of toInject) {
+            let contentSnippet = '';
             try {
-                if (fs.existsSync(injectionCachePath)) {
-                    const existing = JSON.parse(fs.readFileSync(injectionCachePath, 'utf-8'));
-                    if (Array.isArray(existing.solutions))
-                        existingSolutions = existing.solutions;
+                const raw = fs.readFileSync(sol.path, 'utf-8');
+                const contentMatch = raw.match(/## Content\n([\s\S]*?)(?:\n## |\n---|$)/);
+                if (contentMatch) {
+                    // 코드 블록 제거 후 핵심 텍스트만 추출, 최대 3줄
+                    const lines = contentMatch[1]
+                        .replace(/```[\s\S]*?```/g, '')
+                        .split('\n')
+                        .map(l => l.trim())
+                        .filter(l => l.length > 0);
+                    contentSnippet = lines.slice(0, 3).join('\n');
+                    if (contentSnippet.length > SUMMARY_MAX_CHARS) {
+                        contentSnippet = contentSnippet.slice(0, SUMMARY_MAX_CHARS - 3) + '...';
+                    }
                 }
             }
-            catch (e) {
-                log.debug('injection cache 읽기 실패 — 기존 캐시 없이 새로 시작', e);
+            catch { /* fail-open: 파일 읽기 실패 시 이름+태그만 사용 */ }
+            const header = `${sol.name} [${sol.type}|${sol.confidence.toFixed(2)}]: ${sol.matchedTags.slice(0, 5).join(', ')}`;
+            const summary = contentSnippet ? `${header}\n  ${contentSnippet.replace(/\n/g, '\n  ')}` : header;
+            summaries.set(sol.name, summary);
+            candidateEntries.push({ name: sol.name, chars: summary.length });
+        }
+        // H-1 + M-3 fix: lock 안 disjoint 검증으로 새로 추가된 entry만 반환받는다.
+        // 다른 hook이 같은 sessionId로 동시에 같은 솔루션을 inject했다면 이 hook의
+        // commit에서는 newlyAdded에 포함되지 않아 evidence 중복 카운트가 차단된다.
+        const commitResult = commitSessionCacheEntries(sessionId, candidateEntries);
+        // M-1 fix: lock 실패와 정상 0건을 구분.
+        // lock-failed / error: disk 상태 불명 → fail-open으로 approve 하되 warn으로 가시화
+        if (commitResult.status !== 'committed') {
+            log.warn(`session cache commit ${commitResult.status} — hook approving without injection`);
+            console.log(approve());
+            return;
+        }
+        // H-1 fix: commit 이후 fresh disk total로 caller 변수 갱신.
+        // 이전엔 dead variable이라 budget cap이 caller-side stale 값에 의존했다.
+        totalInjectedChars = commitResult.totalInjectedChars;
+        // toInject은 commit 결과의 newlyAdded만 의미 있음 — evidence/cache 갱신은 이 list 기준
+        const newlyAddedNames = new Set(commitResult.newlyAdded.map(e => e.name));
+        const effectiveToInject = toInject.filter(sol => newlyAddedNames.has(sol.name));
+        // 다른 hook이 모두 먼저 inject했다면 effectiveToInject가 0 — 출력할 게 없음
+        if (effectiveToInject.length === 0) {
+            console.log(approve());
+            return;
+        }
+        // Save injection cache for Code Reflection (Phase 2) — cumulative merge
+        // PR2c-1: withFileLock으로 read-modify-write 보호. 동시 hook이 같은 cache를
+        // 만지면 last-writer-wins로 _sessionCounted 등 비트가 사라질 수 있었음.
+        const injectionCachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);
+        try {
+            await withFileLock(injectionCachePath, () => {
+                // Lock 안에서 fresh re-read
+                let existingSolutions = [];
+                try {
+                    if (fs.existsSync(injectionCachePath)) {
+                        const existing = JSON.parse(fs.readFileSync(injectionCachePath, 'utf-8'));
+                        if (Array.isArray(existing.solutions))
+                            existingSolutions = existing.solutions;
+                    }
+                }
+                catch (e) {
+                    log.debug('injection cache 읽기 실패 — 기존 캐시 없이 새로 시작', e);
+                }
+                // R5: defensive copy로 SolutionMatch.tags / .identifiers reference 공유 차단.
+                // M-3 fix: effectiveToInject는 commitSessionCacheEntries가 검증한 disjoint set만 포함.
+                const newSolutions = effectiveToInject.map(sol => ({
+                    name: sol.name,
+                    identifiers: [...sol.identifiers],
+                    tags: [...sol.tags],
+                    status: sol.status,
+                    injectedAt: new Date().toISOString(),
+                }));
+                // BACKFILL: existing entry에 tags 키 자체가 없으면 fresh로 채움.
+                const matchedByName = new Map(allMatched.map(m => [m.name, m]));
+                const existingNames = new Set(existingSolutions.map(s => s.name));
+                const merged = [
+                    ...existingSolutions.map(existing => {
+                        if (existing.tags !== undefined)
+                            return existing;
+                        const fresh = matchedByName.get(existing.name);
+                        if (!fresh)
+                            return existing;
+                        return { ...existing, tags: [...fresh.tags] };
+                    }),
+                    ...newSolutions.filter(s => !existingNames.has(s.name)),
+                ];
+                const injectionData = {
+                    solutions: merged,
+                    updatedAt: new Date().toISOString(),
+                };
+                // mode 0o600 + dirMode 0o700 — STATE_DIR auto-detect 의존성을 명시화
+                atomicWriteJSON(injectionCachePath, injectionData, { mode: 0o600, dirMode: 0o700 });
+            });
+        }
+        catch (e) {
+            if (e instanceof FileLockError) {
+                log.warn(`injection cache lock 실패 — write skipped`, e);
+            }
+            else {
+                log.debug('injection cache 저장 실패', e);
             }
-            // R5: defensive copy로 SolutionMatch.tags / .identifiers reference 공유 차단.
-            // M-3 fix: effectiveToInject는 commitSessionCacheEntries가 검증한 disjoint set만 포함.
-            const newSolutions = effectiveToInject.map(sol => ({
-                name: sol.name,
-                identifiers: [...sol.identifiers],
-                tags: [...sol.tags],
-                status: sol.status,
-                injectedAt: new Date().toISOString(),
-            }));
-            // BACKFILL: existing entry에 tags 키 자체가 없으면 fresh로 채움.
-            const matchedByName = new Map(allMatched.map(m => [m.name, m]));
-            const existingNames = new Set(existingSolutions.map(s => s.name));
-            const merged = [
-                ...existingSolutions.map(existing => {
-                    if (existing.tags !== undefined)
-                        return existing;
-                    const fresh = matchedByName.get(existing.name);
-                    if (!fresh)
-                        return existing;
-                    return { ...existing, tags: [...fresh.tags] };
-                }),
-                ...newSolutions.filter(s => !existingNames.has(s.name)),
-            ];
-            const injectionData = {
-                solutions: merged,
-                updatedAt: new Date().toISOString(),
-            };
-            // mode 0o600 + dirMode 0o700 — STATE_DIR auto-detect 의존성을 명시화
-            atomicWriteJSON(injectionCachePath, injectionData, { mode: 0o600, dirMode: 0o700 });
-        });
-    }
-    catch (e) {
-        if (e instanceof FileLockError) {
-            log.warn(`injection cache lock 실패 — write skipped`, e);
         }
-        else {
-            log.debug('injection cache 저장 실패', e);
+        // Update evidence.injected counters on solution files.
+        // M-3 fix: effectiveToInject(commit이 검증한 disjoint set)만 evidence 갱신 →
+        // 동시 hook이 같은 솔루션을 inject해도 한 번만 카운트됨.
+        try {
+            const { updateSolutionEvidence } = await import('./pre-tool-use.js');
+            for (const sol of effectiveToInject) {
+                updateSolutionEvidence(sol.name, 'injected');
+            }
         }
-    }
-    // Update evidence.injected counters on solution files.
-    // M-3 fix: effectiveToInject(commit이 검증한 disjoint set)만 evidence 갱신 →
-    // 동시 hook이 같은 솔루션을 inject해도 한 번만 카운트됨.
-    try {
-        const { updateSolutionEvidence } = await import('./pre-tool-use.js');
-        for (const sol of effectiveToInject) {
-            updateSolutionEvidence(sol.name, 'injected');
+        catch (e) {
+            log.debug('evidence.injected counter 업데이트 실패', e);
         }
+        // Progressive Disclosure: Tier 1(인덱스) + Tier 2(매칭 요약) push
+        // Tier 3(전문)은 compound-read MCP tool로 pull
+        // effectiveToInject 사용 — 다른 hook이 이미 inject한 솔루션은 사용자에게 다시 push 안 함
+        const injections = effectiveToInject.map(sol => {
+            const summary = summaries.get(sol.name) ?? sol.name;
+            return `- ${summary}`;
+        }).join('\n');
+        const header = `Matched solutions (apply these patterns to your response):\n`;
+        const footer = `\n\nAPPLY the patterns above to your response. If a pattern is directly relevant, follow its guidance. Use compound-read MCP tool for full details if needed.\nWhen using Grep or Bash, always set head_limit or pipe through | head -n to limit output size.`;
+        const fullInjection = header + injections + footer;
+        // 플러그인 시그널 기록 (다른 플러그인이 참고할 수 있도록)
+        try {
+            writeSignal(sessionId, 'UserPromptSubmit', fullInjection.length);
+        }
+        catch (e) {
+            log.debug('plugin signal 기록 실패', e);
+        }
+        console.log(approveWithContext(fullInjection, 'UserPromptSubmit'));
     }
-    catch (e) {
-        log.debug('evidence.injected counter 업데이트 실패', e);
-    }
-    // Progressive Disclosure: Tier 1(인덱스) + Tier 2(매칭 요약) push
-    // Tier 3(전문)은 compound-read MCP tool로 pull
-    // effectiveToInject 사용 — 다른 hook이 이미 inject한 솔루션은 사용자에게 다시 push 안 함
-    const injections = effectiveToInject.map(sol => {
-        const summary = summaries.get(sol.name) ?? sol.name;
-        return `- ${summary}`;
-    }).join('\n');
-    const header = `Matched solutions (compound-read로 전문 확인 시 더 정확한 구현 가능):\n`;
-    const footer = `\n\nIMPORTANT: When you use compound knowledge above, briefly mention it naturally (e.g., "Based on accumulated patterns..." or "From past experience..."). This helps the user see compound learning in action.`;
-    const fullInjection = header + injections + footer;
-    // 플러그인 시그널 기록 (다른 플러그인이 참고할 수 있도록)
-    try {
-        writeSignal(sessionId, 'UserPromptSubmit', fullInjection.length);
-    }
-    catch (e) {
-        log.debug('plugin signal 기록 실패', e);
+    finally {
+        recordHookTiming('solution-injector', Date.now() - _hookStart, 'UserPromptSubmit');
     }
-    console.log(approveWithContext(fullInjection, 'UserPromptSubmit'));
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] solution-injector: ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('solution-injector'));
 });

package/dist/hooks/subagent-tracker.js

@@ -13,7 +13,7 @@ import { readStdinJSON } from './shared/read-stdin.js';
 import { isHookEnabled } from './hook-config.js';
 import { sanitizeId } from './shared/sanitize-id.js';
 import { atomicWriteJSON } from './shared/atomic-write.js';
-import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { approve, approveWithWarning, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
 const MAX_CONCURRENT_AGENTS = 10;
 const AGENT_GC_AGE_MS = 60 * 60 * 1000; // 1시간 이상 종료된 에이전트는 GC
@@ -86,5 +86,5 @@ async function main() {
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('subagent-tracker'));
 });

package/dist/host/codex-adapter.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Codex 훅 어댑터
+ *
+ * 목적:
+ * - codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema로 정규화
+ * - continue 누락 또는 codex 특화 판정 필드(approved/decision) 대응
+ * - 파싱 실패/실행 실패 시 fail-open(continue: true)
+ */
+export {};

package/dist/host/codex-adapter.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Codex 훅 어댑터
+ *
+ * 목적:
+ * - codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema로 정규화
+ * - continue 누락 또는 codex 특화 판정 필드(approved/decision) 대응
+ * - 파싱 실패/실행 실패 시 fail-open(continue: true)
+ */
+import { spawnSync } from 'node:child_process';
+function parseDecision(raw) {
+    if (typeof raw === 'boolean') {
+        return { continueFlag: raw };
+    }
+    if (typeof raw === 'string') {
+        const normalized = raw.toLowerCase();
+        if (normalized === 'continue')
+            return { continueFlag: true };
+        if (normalized === 'stop' || normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
+            return { continueFlag: false, permissionDecision: normalized };
+        }
+        return { continueFlag: true };
+    }
+    if (typeof raw !== 'object' || raw === null)
+        return { continueFlag: true };
+    const value = raw.decision;
+    if (typeof value === 'string') {
+        const normalized = value.toLowerCase();
+        if (normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
+            return { continueFlag: false, permissionDecision: normalized };
+        }
+        if (normalized === 'ask' || normalized === 'prompt' || normalized === 'confirm') {
+            return { continueFlag: true, permissionDecision: normalized };
+        }
+    }
+    if (typeof raw.approved === 'boolean') {
+        const approved = raw.approved;
+        return approved
+            ? { continueFlag: true, permissionDecision: raw.decision || 'approve' }
+            : { continueFlag: false, permissionDecision: 'deny' };
+    }
+    if (typeof raw.continue === 'boolean') {
+        return { continueFlag: raw.continue };
+    }
+    return { continueFlag: true };
+}
+function lastJSONObjectFromText(raw) {
+    const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        try {
+            return JSON.parse(lines[i]);
+        }
+        catch {
+            // continue
+        }
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeOutput(raw, input) {
+    const result = { continue: true };
+    const decision = parseDecision(raw);
+    result.continue = decision.continueFlag;
+    if (typeof raw === 'object' && raw !== null) {
+        const payload = raw;
+        if (typeof payload.continue === 'boolean')
+            result.continue = payload.continue;
+        if (typeof payload.systemMessage === 'string')
+            result.systemMessage = payload.systemMessage;
+        if (typeof payload.suppressOutput === 'boolean')
+            result.suppressOutput = payload.suppressOutput;
+        if (typeof payload.hookSpecificOutput === 'object' && payload.hookSpecificOutput !== null) {
+            result.hookSpecificOutput = { ...payload.hookSpecificOutput };
+        }
+        if (typeof payload.decision === 'string') {
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: payload.decision,
+            };
+        }
+    }
+    const eventName = result.hookSpecificOutput?.hookEventName ?? input.hookEventName ?? input.event;
+    if (eventName) {
+        result.hookSpecificOutput = {
+            hookEventName: eventName,
+            ...(result.hookSpecificOutput ?? {}),
+        };
+    }
+    if (!result.continue && !result.hookSpecificOutput?.permissionDecision) {
+        if (decision.permissionDecision)
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: decision.permissionDecision,
+            };
+        else
+            result.hookSpecificOutput = { ...(result.hookSpecificOutput ?? {}), permissionDecision: 'deny' };
+    }
+    return result;
+}
+async function main() {
+    const [delegatePath, ...restArgs] = process.argv.slice(2);
+    if (!delegatePath) {
+        console.log(JSON.stringify({ continue: true }));
+        return;
+    }
+    const input = await (async () => {
+        const chunks = [];
+        let totalBytes = 0;
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+            totalBytes += chunk.length;
+            if (totalBytes > 10 * 1024 * 1024)
+                break;
+        }
+        const raw = Buffer.concat(chunks.map(c => typeof c === 'string' ? Buffer.from(c) : c)).toString('utf-8').trim();
+        if (!raw)
+            return {};
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    })();
+    try {
+        const result = spawnSync(process.execPath, [delegatePath, ...restArgs], {
+            encoding: 'utf-8',
+            input: JSON.stringify(input),
+            cwd: process.cwd(),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (result.error) {
+            console.log(JSON.stringify({ continue: true }));
+            return;
+        }
+        const parsed = lastJSONObjectFromText(result.stdout ?? '');
+        if (!parsed) {
+            console.log(JSON.stringify({ continue: true }));
+            return;
+        }
+        const output = normalizeOutput(parsed, input);
+        console.log(JSON.stringify(output));
+    }
+    catch {
+        console.log(JSON.stringify({ continue: true }));
+    }
+}
+main().catch(() => {
+    console.log(JSON.stringify({ continue: true }));
+});