@wooojin/forgen 0.1.1 → 0.2.1

package/dist/hooks/shared/hook-timing.js

@@ -0,0 +1,64 @@
+/**
+ * Forgen — Hook Timing Profiler
+ *
+ * Records hook execution durations and provides timing statistics
+ * for visibility into which hooks are slow.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../../core/paths.js';
+const TIMING_LOG = path.join(STATE_DIR, 'hook-timing.jsonl');
+const MAX_LINES = 500;
+export function recordHookTiming(hookName, durationMs, event) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        const entry = JSON.stringify({ hook: hookName, ms: durationMs, event, at: Date.now() });
+        fs.appendFileSync(TIMING_LOG, entry + '\n');
+        // Rotate if too large
+        try {
+            const content = fs.readFileSync(TIMING_LOG, 'utf-8');
+            const lines = content.trim().split('\n');
+            if (lines.length > MAX_LINES) {
+                fs.writeFileSync(TIMING_LOG, lines.slice(-MAX_LINES).join('\n') + '\n');
+            }
+        }
+        catch { /* skip rotation on error */ }
+    }
+    catch { /* fail-open */ }
+}
+export function getTimingStats() {
+    try {
+        if (!fs.existsSync(TIMING_LOG))
+            return [];
+        const content = fs.readFileSync(TIMING_LOG, 'utf-8');
+        const entries = content.trim().split('\n')
+            .map(line => { try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        } })
+            .filter(Boolean);
+        const byHook = new Map();
+        for (const e of entries) {
+            if (!byHook.has(e.hook))
+                byHook.set(e.hook, []);
+            byHook.get(e.hook).push(e.ms);
+        }
+        const stats = [];
+        for (const [hook, times] of byHook) {
+            times.sort((a, b) => a - b);
+            stats.push({
+                hook,
+                count: times.length,
+                p50: times[Math.floor(times.length * 0.5)] ?? 0,
+                p95: times[Math.floor(times.length * 0.95)] ?? 0,
+                max: times[times.length - 1] ?? 0,
+            });
+        }
+        return stats.sort((a, b) => b.p95 - a.p95);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/hooks/skill-injector.js

@@ -34,10 +34,11 @@ function escapeXmlAttr(s) {
     return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 import { atomicWriteJSON } from './shared/atomic-write.js';
+import { withFileLockSync } from './shared/file-lock.js';
 import { FORGEN_HOME, ME_DIR, STATE_DIR } from '../core/paths.js';
 import { KEYWORD_PATTERNS } from './keyword-detector.js';
 import { isHookEnabled } from './hook-config.js';
-import { approve, approveWithContext, failOpen } from './shared/hook-response.js';
+import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
 /** keyword-detector가 처리하는 키워드 이름 집합 (skill + inject 모두 포함, 이중 주입 방지) */
 const KEYWORD_DETECTOR_SKILL_NAMES = new Set(KEYWORD_PATTERNS
     .filter(p => p.type === 'skill' || p.type === 'inject')
@@ -65,11 +66,39 @@ function loadSessionCache(sessionId) {
     }
     return new Set();
 }
-function saveSessionCache(sessionId, injected) {
-    atomicWriteJSON(getSessionCachePath(sessionId), {
-        injected: [...injected],
-        updatedAt: new Date().toISOString(),
-    });
+function saveSessionCache(sessionId, newSkillNames) {
+    const cachePath = getSessionCachePath(sessionId);
+    try {
+        withFileLockSync(cachePath, () => {
+            // Lock 안에서 fresh re-read → merge → write
+            const freshInjected = new Set();
+            try {
+                if (fs.existsSync(cachePath)) {
+                    const fresh = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+                    const age = fresh.updatedAt ? Date.now() - new Date(fresh.updatedAt).getTime() : Infinity;
+                    if (Number.isFinite(age) && age <= 24 * 60 * 60 * 1000) {
+                        for (const name of fresh.injected ?? [])
+                            freshInjected.add(name);
+                    }
+                }
+            }
+            catch { /* fresh re-read 실패 시 빈 set으로 진행 */ }
+            for (const name of newSkillNames)
+                freshInjected.add(name);
+            atomicWriteJSON(cachePath, {
+                injected: [...freshInjected],
+                updatedAt: new Date().toISOString(),
+            });
+        });
+    }
+    catch (e) {
+        // Lock 실패 시 fail-open: 직접 write (중복 주입 가능성 있지만 기능 차단 안 함)
+        log.debug('skill session cache lock 실패 — fallback write', e);
+        atomicWriteJSON(cachePath, {
+            injected: [...new Set([...loadSessionCache(sessionId), ...newSkillNames])],
+            updatedAt: new Date().toISOString(),
+        });
+    }
 }
 /** YAML frontmatter 파싱 (간단한 구현) */
 export function parseFrontmatter(content) {
@@ -258,11 +287,11 @@ async function main() {
     }
     // 최대 제한 적용
     const toInject = matched.slice(0, MAX_SKILLS_PER_SESSION - injected.size);
-    // 파일 기반 캐시 업데이트
-    for (const skill of toInject) {
-        injected.add(skill.name);
-    }
-    saveSessionCache(sessionId, injected);
+    // 파일 기반 캐시 업데이트 (lock 보호)
+    const newSkillNames = toInject.map(s => s.name);
+    for (const name of newSkillNames)
+        injected.add(name);
+    saveSessionCache(sessionId, newSkillNames);
     // Adaptive budget: 다른 플러그인 감지 시 스킬 주입량 축소
     let skillCap = 3000; // INJECTION_CAPS.skillContentMax 기본값
     try {
@@ -281,5 +310,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('skill-injector'));
 });

package/dist/hooks/slop-detector.js

@@ -9,7 +9,7 @@
 import { readStdinJSON } from './shared/read-stdin.js';
 import { createLogger } from '../core/logger.js';
 import { isHookEnabled, loadHookConfig } from './hook-config.js';
-import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { approve, approveWithWarning, failOpenWithTracking } from './shared/hook-response.js';
 const log = createLogger('slop-detector');
 export const SLOP_PATTERNS = [
     { pattern: /\/\/\s*TODO:?\s*(implement|add|fix|handle)/i, message: 'Leftover TODO comment', severity: 'warn' },
@@ -84,10 +84,10 @@ async function main() {
     }
     catch (e) {
         log.debug('슬롭 감지 실패', e);
-        console.log(failOpen());
+        console.log(failOpenWithTracking('slop-detector'));
     }
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('slop-detector'));
 });

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'));
 });