@wooojin/forgen 0.1.1 → 0.2.1

package/dist/hooks/session-recovery.js

@@ -15,8 +15,9 @@ const log = createLogger('session-recovery');
 import { atomicWriteJSON } from './shared/atomic-write.js';
 import { sanitizeId } from './shared/sanitize-id.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';
 import { HANDOFFS_DIR, STATE_DIR } from '../core/paths.js';
+import { recordHookTiming } from './shared/hook-timing.js';
 /** 체크포인트 저장 */
 export function saveCheckpoint(data) {
     try {
@@ -129,271 +130,290 @@ export function resolveSessionStartContext(rawInput) {
     }
 }
 async function main() {
-    // SessionStart 훅은 stdin으로 세션 정보를 받음 (타임아웃 포함)
-    const chunks = [];
-    process.stdin.setEncoding('utf-8');
-    await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            process.stdin.removeAllListeners('data');
-            process.stdin.removeAllListeners('end');
-            resolve();
-        }, 2000);
-        process.stdin.on('data', (chunk) => chunks.push(String(chunk)));
-        process.stdin.on('end', () => { clearTimeout(timeout); resolve(); });
-    });
-    const sessionContext = resolveSessionStartContext(chunks.join(''));
-    if (!isHookEnabled('session-recovery')) {
-        console.log(approve());
-        return;
-    }
-    if (!fs.existsSync(STATE_DIR)) {
-        console.log(approve());
-        return;
-    }
-    // 활성 모드 찾기
-    const recoveryMessages = [];
-    for (const mode of PERSISTENT_MODES) {
-        const statePath = path.join(STATE_DIR, `${mode}-state.json`);
-        if (!fs.existsSync(statePath))
-            continue;
-        try {
-            const parsed = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-            if (!isValidModeState(parsed)) {
-                log.debug(`상태 파일 구조 검증 실패: ${mode}`);
-                continue;
-            }
-            const state = parsed;
-            if (!state.active)
-                continue;
-            // 24시간 이상 경과한 상태는 만료
-            const startedAt = new Date(state.startedAt).getTime();
-            const elapsed = Date.now() - startedAt;
-            if (elapsed > 24 * 60 * 60 * 1000) {
-                fs.unlinkSync(statePath);
-                continue;
-            }
-            const elapsedMinutes = Math.round(elapsed / 60000);
-            // Security: 상태 파일의 사용자 입력을 XML에 삽입하기 전 이스케이프
-            const escXml = (s) => s.replace(/[<>&"]/g, c => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;' })[c] ?? c);
-            recoveryMessages.push(`<compound-recovery mode="${mode}">` +
-                `\n${mode} mode from previous session has been recovered.` +
-                `\nStarted: ${state.startedAt} (${elapsedMinutes} minutes ago)` +
-                (state.prompt ? `\nOriginal request: ${escXml(state.prompt)}` : '') +
-                (state.stage ? `\nCurrent stage: ${escXml(state.stage)}` : '') +
-                (state.completedSteps?.length ? `\nCompleted steps: ${state.completedSteps.map((s) => escXml(s)).join(', ')}` : '') +
-                `\n\nContinue the previous work. To stop, type "cancelforgen".` +
-                `\n</compound-recovery>`);
-        }
-        catch (e) {
-            log.debug(`상태 파일 파싱 실패`, e);
-        }
-    }
-    // Phase 0: endTime이 없는 이전 세션 backfill (file mtime 기반)
-    // 최근 7일 파일만 대상 — 오래된 파일은 무시하여 성능 보장
+    const _hookStart = Date.now();
     try {
-        const { SESSIONS_DIR: sessDir } = await import('../core/paths.js');
-        if (fs.existsSync(sessDir)) {
-            const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
-            const sessionFiles = fs.readdirSync(sessDir)
-                .filter(f => f.endsWith('.json'))
-                .filter(f => {
-                try {
-                    return fs.statSync(path.join(sessDir, f)).mtimeMs > cutoff;
-                }
-                catch {
-                    return false;
-                }
-            });
-            for (const file of sessionFiles) {
-                const fp = path.join(sessDir, file);
-                try {
-                    const raw = JSON.parse(fs.readFileSync(fp, 'utf-8'));
-                    if (raw.startTime && !raw.endTime) {
-                        const mtime = fs.statSync(fp).mtime;
-                        raw.endTime = mtime.toISOString();
-                        raw.durationMs = mtime.getTime() - new Date(raw.startTime).getTime();
-                        raw.recoveredEndTime = true;
-                        atomicWriteJSON(fp, raw);
-                    }
-                }
-                catch { /* individual file recovery failure — skip and continue */ }
-            }
+        // SessionStart 훅은 stdin으로 세션 정보를 받음 (타임아웃 포함)
+        const chunks = [];
+        process.stdin.setEncoding('utf-8');
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                process.stdin.removeAllListeners('data');
+                process.stdin.removeAllListeners('end');
+                resolve();
+            }, 2000);
+            process.stdin.on('data', (chunk) => chunks.push(String(chunk)));
+            process.stdin.on('end', () => { clearTimeout(timeout); resolve(); });
+        });
+        const sessionContext = resolveSessionStartContext(chunks.join(''));
+        if (!isHookEnabled('session-recovery')) {
+            console.log(approve());
+            return;
         }
-    }
-    catch (e) {
-        log.debug('세션 endTime backfill 실패', e);
-    }
-    // 미완료 체크포인트 감지
-    try {
-        const checkpointFiles = fs.readdirSync(STATE_DIR)
-            .filter(f => f.startsWith('checkpoint-') && f.endsWith('.json'));
-        for (const file of checkpointFiles) {
+        if (!fs.existsSync(STATE_DIR)) {
+            console.log(approve());
+            return;
+        }
+        // 활성 모드 찾기
+        const recoveryMessages = [];
+        for (const mode of PERSISTENT_MODES) {
+            const statePath = path.join(STATE_DIR, `${mode}-state.json`);
+            if (!fs.existsSync(statePath))
+                continue;
             try {
-                const parsedCp = JSON.parse(fs.readFileSync(path.join(STATE_DIR, file), 'utf-8'));
-                if (!isValidCheckpoint(parsedCp)) {
-                    log.debug(`체크포인트 파일 구조 검증 실패: ${file}`);
+                const parsed = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+                if (!isValidModeState(parsed)) {
+                    log.debug(`상태 파일 구조 검증 실패: ${mode}`);
                     continue;
                 }
-                const cp = parsedCp;
-                const age = Date.now() - new Date(cp.timestamp).getTime();
-                if (age > 24 * 60 * 60 * 1000) {
-                    fs.unlinkSync(path.join(STATE_DIR, file));
+                const state = parsed;
+                if (!state.active)
+                    continue;
+                // 24시간 이상 경과한 상태는 만료
+                const startedAt = new Date(state.startedAt).getTime();
+                const elapsed = Date.now() - startedAt;
+                if (elapsed > 24 * 60 * 60 * 1000) {
+                    fs.unlinkSync(statePath);
                     continue;
                 }
-                const elapsedMin = Math.round(age / 60000);
-                const safeSessionId = String(cp.sessionId).replace(/[&"<>]/g, '_');
-                const safeLastTool = String(cp.lastToolCall ?? '').replace(/[<>]/g, '_');
-                const safeCwd = String(cp.cwd ?? '').replace(/[<>]/g, '_');
-                recoveryMessages.push(`<compound-checkpoint session="${safeSessionId}">` +
-                    `\nIncomplete checkpoint found (${elapsedMin} minutes ago)` +
-                    `\n- Modified files: ${cp.modifiedFiles.length}` +
-                    `\n- Tool calls: ${cp.toolCallCount}` +
-                    `\n- Last tool: ${safeLastTool}` +
-                    `\n- Working directory: ${safeCwd}` +
-                    `\n</compound-checkpoint>`);
+                const elapsedMinutes = Math.round(elapsed / 60000);
+                // Security: 상태 파일의 사용자 입력을 XML에 삽입하기 전 이스케이프
+                const escXml = (s) => s.replace(/[<>&"]/g, c => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;' })[c] ?? c);
+                recoveryMessages.push(`<compound-recovery mode="${mode}">` +
+                    `\n${mode} mode from previous session has been recovered.` +
+                    `\nStarted: ${state.startedAt} (${elapsedMinutes} minutes ago)` +
+                    (state.prompt ? `\nOriginal request: ${escXml(state.prompt)}` : '') +
+                    (state.stage ? `\nCurrent stage: ${escXml(state.stage)}` : '') +
+                    (state.completedSteps?.length ? `\nCompleted steps: ${state.completedSteps.map((s) => escXml(s)).join(', ')}` : '') +
+                    `\n\nContinue the previous work. To stop, type "cancelforgen".` +
+                    `\n</compound-recovery>`);
+            }
+            catch (e) {
+                log.debug(`상태 파일 파싱 실패`, e);
             }
-            catch { /* 개별 파일 파싱 실패 무시 */ }
         }
-    }
-    catch (e) {
-        log.debug('체크포인트 스캔 실패', e);
-    }
-    // pending-compound 마커 확인 (이전 세션에서 compound loop 필요 표시)
-    const pendingPath = path.join(STATE_DIR, 'pending-compound.json');
-    if (fs.existsSync(pendingPath)) {
+        // Phase 0: endTime이 없는 이전 세션 backfill (file mtime 기반)
+        // 최근 7일 파일만 대상 — 오래된 파일은 무시하여 성능 보장
         try {
-            const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
-            recoveryMessages.push(`<compound-pending>` +
-                `\nCompound loop was scheduled in the previous session (${pending.promptCount ?? '?'} prompts).` +
-                `\nRun \`forgen compound\` to preview, then \`forgen compound --save\` to persist patterns/solutions.` +
-                `\n</compound-pending>`);
-            // 마커 삭제 (한 번만 안내)
-            fs.unlinkSync(pendingPath);
+            const { SESSIONS_DIR: sessDir } = await import('../core/paths.js');
+            if (fs.existsSync(sessDir)) {
+                const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+                const sessionFiles = fs.readdirSync(sessDir)
+                    .filter(f => f.endsWith('.json'))
+                    .filter(f => {
+                    try {
+                        return fs.statSync(path.join(sessDir, f)).mtimeMs > cutoff;
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                for (const file of sessionFiles) {
+                    const fp = path.join(sessDir, file);
+                    try {
+                        const raw = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+                        if (raw.startTime && !raw.endTime) {
+                            const mtime = fs.statSync(fp).mtime;
+                            raw.endTime = mtime.toISOString();
+                            raw.durationMs = mtime.getTime() - new Date(raw.startTime).getTime();
+                            raw.recoveredEndTime = true;
+                            atomicWriteJSON(fp, raw);
+                        }
+                    }
+                    catch { /* individual file recovery failure — skip and continue */ }
+                }
+            }
         }
         catch (e) {
-            log.debug('pending-compound 마커 읽기 실패', e);
+            log.debug('세션 endTime backfill 실패', e);
         }
-    }
-    // 핸드오프 파일 확인
-    const handoffDir = HANDOFFS_DIR;
-    if (fs.existsSync(handoffDir)) {
+        // 미완료 체크포인트 감지
         try {
-            const handoffs = fs.readdirSync(handoffDir)
-                .filter(f => f.endsWith('.md'))
-                .sort();
-            if (handoffs.length > 0) {
-                const latest = handoffs[handoffs.length - 1];
-                const latestPath = path.join(handoffDir, latest);
-                // Security: symlink 방지 + XML 이스케이프
-                if (fs.lstatSync(latestPath).isSymbolicLink())
-                    throw new Error('symlink rejected');
-                const raw = fs.readFileSync(latestPath, 'utf-8');
-                const safeName = latest.replace(/[&"<>]/g, '_');
-                const escaped = raw.replace(/<\/?[a-zA-Z][\w-]*(?:\s[^>]*)?\/?>/g, m => m.replace(/</g, '&lt;').replace(/>/g, '&gt;'));
-                recoveryMessages.push(`<compound-handoff file="${safeName}">\n${escaped}\n</compound-handoff>`);
-                // 마커 삭제 (한 번만 안내 — pending-compound.json과 동일 패턴)
+            const checkpointFiles = fs.readdirSync(STATE_DIR)
+                .filter(f => f.startsWith('checkpoint-') && f.endsWith('.json'));
+            for (const file of checkpointFiles) {
                 try {
-                    fs.unlinkSync(latestPath);
-                }
-                catch (e) {
-                    log.debug('handoff 파일 삭제 실패', e);
+                    const parsedCp = JSON.parse(fs.readFileSync(path.join(STATE_DIR, file), 'utf-8'));
+                    if (!isValidCheckpoint(parsedCp)) {
+                        log.debug(`체크포인트 파일 구조 검증 실패: ${file}`);
+                        continue;
+                    }
+                    const cp = parsedCp;
+                    const age = Date.now() - new Date(cp.timestamp).getTime();
+                    if (age > 24 * 60 * 60 * 1000) {
+                        fs.unlinkSync(path.join(STATE_DIR, file));
+                        continue;
+                    }
+                    const elapsedMin = Math.round(age / 60000);
+                    const safeSessionId = String(cp.sessionId).replace(/[&"<>]/g, '_');
+                    const safeLastTool = String(cp.lastToolCall ?? '').replace(/[<>]/g, '_');
+                    const safeCwd = String(cp.cwd ?? '').replace(/[<>]/g, '_');
+                    recoveryMessages.push(`<compound-checkpoint session="${safeSessionId}">` +
+                        `\nIncomplete checkpoint found (${elapsedMin} minutes ago)` +
+                        `\n- Modified files: ${cp.modifiedFiles.length}` +
+                        `\n- Tool calls: ${cp.toolCallCount}` +
+                        `\n- Last tool: ${safeLastTool}` +
+                        `\n- Working directory: ${safeCwd}` +
+                        `\n</compound-checkpoint>`);
                 }
+                catch { /* 개별 파일 파싱 실패 무시 */ }
             }
         }
         catch (e) {
-            log.debug('handoff 파일 읽기 실패', e);
+            log.debug('체크포인트 스캔 실패', e);
         }
-    }
-    const sessionId = sessionContext.sessionId;
-    // 이전 세션 자동 compound (fire-and-forget)
-    // /new로 세션 리셋 시 SessionStart가 다시 호출됨 — 이때 이전 transcript를 compound
-    try {
-        const cwd = sessionContext.cwd;
-        const sanitized = cwd.replace(/\//g, '-');
-        const projectDir = path.join(os.homedir(), '.claude', 'projects', sanitized);
-        if (fs.existsSync(projectDir)) {
-            const transcripts = fs.readdirSync(projectDir)
-                .filter(f => f.endsWith('.jsonl') && f !== `${sessionId}.jsonl`) // 현재 세션 제외
-                .map(f => ({ name: f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
-                .sort((a, b) => b.mtime - a.mtime);
-            if (transcripts.length > 0) {
-                const prevTranscript = path.join(projectDir, transcripts[0].name);
-                const lastCompoundPath = path.join(STATE_DIR, 'last-auto-compound.json');
-                let lastCompoundedSession = '';
-                try {
-                    lastCompoundedSession = JSON.parse(fs.readFileSync(lastCompoundPath, 'utf-8')).sessionId ?? '';
+        // pending-compound 마커 확인 (이전 세션에서 compound loop 필요 표시)
+        const pendingPath = path.join(STATE_DIR, 'pending-compound.json');
+        if (fs.existsSync(pendingPath)) {
+            try {
+                const pending = JSON.parse(fs.readFileSync(pendingPath, 'utf-8'));
+                recoveryMessages.push(`<compound-pending>` +
+                    `\nCompound loop was scheduled in the previous session (${pending.promptCount ?? '?'} prompts).` +
+                    `\nRun \`forgen compound\` to preview, then \`forgen compound --save\` to persist patterns/solutions.` +
+                    `\n</compound-pending>`);
+                // 마커 삭제 (한 번만 안내)
+                fs.unlinkSync(pendingPath);
+            }
+            catch (e) {
+                log.debug('pending-compound 마커 읽기 실패', e);
+            }
+        }
+        // 핸드오프 파일 확인
+        const handoffDir = HANDOFFS_DIR;
+        if (fs.existsSync(handoffDir)) {
+            try {
+                const handoffs = fs.readdirSync(handoffDir)
+                    .filter(f => f.endsWith('.md'))
+                    .sort();
+                if (handoffs.length > 0) {
+                    const latest = handoffs[handoffs.length - 1];
+                    const latestPath = path.join(handoffDir, latest);
+                    // Security: symlink 방지 + XML 이스케이프
+                    if (fs.lstatSync(latestPath).isSymbolicLink())
+                        throw new Error('symlink rejected');
+                    const raw = fs.readFileSync(latestPath, 'utf-8');
+                    const safeName = latest.replace(/[&"<>]/g, '_');
+                    const escaped = raw.replace(/<\/?[a-zA-Z][\w-]*(?:\s[^>]*)?\/?>/g, m => m.replace(/</g, '&lt;').replace(/>/g, '&gt;'));
+                    recoveryMessages.push(`<compound-handoff file="${safeName}">\n${escaped}\n</compound-handoff>`);
+                    // 마커 삭제 (한 번만 안내 — pending-compound.json과 동일 패턴)
+                    try {
+                        fs.unlinkSync(latestPath);
+                    }
+                    catch (e) {
+                        log.debug('handoff 파일 삭제 실패', e);
+                    }
                 }
-                catch { /* first time */ }
-                const prevSessionId = transcripts[0].name.replace('.jsonl', '');
-                if (prevSessionId !== lastCompoundedSession) {
-                    // 이전 세션이 compound 안 된 상태 — 메시지 수 확인
-                    // W-D2: 대용량 transcript 보호 — 앞 200KB만 읽어 메시지 수 추정
-                    const fd = fs.openSync(prevTranscript, 'r');
-                    const buf = Buffer.alloc(200 * 1024);
-                    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
-                    fs.closeSync(fd);
-                    const content = buf.toString('utf-8', 0, bytesRead);
-                    const userMsgCount = content.split('\n')
-                        .filter(l => { try {
-                        const t = JSON.parse(l).type;
-                        return t === 'user' || t === 'queue-operation';
+            }
+            catch (e) {
+                log.debug('handoff 파일 읽기 실패', e);
+            }
+        }
+        // Load latest session brief
+        try {
+            const briefFiles = fs.readdirSync(HANDOFFS_DIR)
+                .filter(f => f.endsWith('-session-brief.json'))
+                .sort()
+                .reverse();
+            if (briefFiles.length > 0) {
+                const brief = JSON.parse(fs.readFileSync(path.join(HANDOFFS_DIR, briefFiles[0]), 'utf-8'));
+                const briefContext = `Previous session: ${brief.mode || 'general'}, ${brief.promptCount || 0} prompts, ${(brief.modifiedFiles || []).length} files modified, ${(brief.solutionsInjected || []).length} solutions used.`;
+                recoveryMessages.push(briefContext);
+            }
+        }
+        catch { /* fail-open */ }
+        const sessionId = sessionContext.sessionId;
+        // 이전 세션 자동 compound (fire-and-forget)
+        // /new로 세션 리셋 시 SessionStart가 다시 호출됨 — 이때 이전 transcript를 compound
+        try {
+            const cwd = sessionContext.cwd;
+            const sanitized = cwd.replace(/\//g, '-');
+            const projectDir = path.join(os.homedir(), '.claude', 'projects', sanitized);
+            if (fs.existsSync(projectDir)) {
+                const transcripts = fs.readdirSync(projectDir)
+                    .filter(f => f.endsWith('.jsonl') && f !== `${sessionId}.jsonl`) // 현재 세션 제외
+                    .map(f => ({ name: f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+                    .sort((a, b) => b.mtime - a.mtime);
+                if (transcripts.length > 0) {
+                    const prevTranscript = path.join(projectDir, transcripts[0].name);
+                    const lastCompoundPath = path.join(STATE_DIR, 'last-auto-compound.json');
+                    let lastCompoundedSession = '';
+                    try {
+                        lastCompoundedSession = JSON.parse(fs.readFileSync(lastCompoundPath, 'utf-8')).sessionId ?? '';
                     }
-                    catch {
-                        return false;
-                    } })
-                        .length;
-                    if (userMsgCount >= 10) {
-                        // background로 auto-compound 실행 (hook timeout과 무관)
-                        const { spawn: spawnProcess } = await import('node:child_process');
-                        const autoCompound = spawnProcess('node', [
-                            path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'core', 'auto-compound-runner.js'),
-                            cwd, prevTranscript, prevSessionId,
-                        ], { detached: true, stdio: 'ignore' });
-                        autoCompound.unref();
-                        log.debug(`이전 세션 auto-compound 시작: ${prevSessionId} (${userMsgCount} messages)`);
+                    catch { /* first time */ }
+                    const prevSessionId = transcripts[0].name.replace('.jsonl', '');
+                    if (prevSessionId !== lastCompoundedSession) {
+                        // 이전 세션이 compound 안 된 상태 — 메시지 수 확인
+                        // W-D2: 대용량 transcript 보호 — 앞 200KB만 읽어 메시지 수 추정
+                        const fd = fs.openSync(prevTranscript, 'r');
+                        const buf = Buffer.alloc(200 * 1024);
+                        const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+                        fs.closeSync(fd);
+                        const content = buf.toString('utf-8', 0, bytesRead);
+                        const userMsgCount = content.split('\n')
+                            .filter(l => { try {
+                            const t = JSON.parse(l).type;
+                            return t === 'user' || t === 'queue-operation';
+                        }
+                        catch {
+                            return false;
+                        } })
+                            .length;
+                        if (userMsgCount >= 10) {
+                            // background로 auto-compound 실행 (hook timeout과 무관)
+                            const { spawn: spawnProcess } = await import('node:child_process');
+                            const autoCompound = spawnProcess('node', [
+                                path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'core', 'auto-compound-runner.js'),
+                                cwd, prevTranscript, prevSessionId,
+                            ], { detached: true, stdio: 'ignore' });
+                            autoCompound.unref();
+                            log.debug(`이전 세션 auto-compound 시작: ${prevSessionId} (${userMsgCount} messages)`);
+                        }
                     }
                 }
             }
         }
-    }
-    catch (e) {
-        log.debug('이전 세션 auto-compound 체크 실패', e);
-    }
-    // v1: regex 기반 패턴 학습(prompt-learner) 제거. Evidence 기반으로 전환됨.
-    // Compound v3: Run lifecycle check once per day
-    try {
-        const lifecycleModulePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'engine', 'compound-lifecycle.js');
-        const lastLifecyclePath = path.join(STATE_DIR, 'last-lifecycle.json');
-        let shouldRun = true;
+        catch (e) {
+            log.debug('이전 세션 auto-compound 체크 실패', e);
+        }
+        // v1: regex 기반 패턴 학습(prompt-learner) 제거. Evidence 기반으로 전환됨.
+        // Compound v3: Run lifecycle check once per day
         try {
-            if (fs.existsSync(lastLifecyclePath)) {
-                const data = JSON.parse(fs.readFileSync(lastLifecyclePath, 'utf-8'));
-                const last = new Date(data.lastRun).getTime();
-                shouldRun = Date.now() - last > 24 * 60 * 60 * 1000;
+            const lifecycleModulePath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'engine', 'compound-lifecycle.js');
+            const lastLifecyclePath = path.join(STATE_DIR, 'last-lifecycle.json');
+            let shouldRun = true;
+            try {
+                if (fs.existsSync(lastLifecyclePath)) {
+                    const data = JSON.parse(fs.readFileSync(lastLifecyclePath, 'utf-8'));
+                    const last = new Date(data.lastRun).getTime();
+                    shouldRun = Date.now() - last > 24 * 60 * 60 * 1000;
+                }
             }
+            catch { /* last-lifecycle.json parse failure — run lifecycle check anyway */ }
+            if (shouldRun) {
+                // B-4: detached background spawn으로 분리 — hook timeout 초과 방지
+                const { spawn: spawnLifecycle } = await import('node:child_process');
+                const lifecycleRunner = spawnLifecycle('node', [
+                    '--input-type=module',
+                    '-e',
+                    `import('${lifecycleModulePath.replace(/\\/g, '/')}').then(m => m.runLifecycleCheck('${sessionId}'))`,
+                ], { detached: true, stdio: 'ignore' });
+                lifecycleRunner.unref();
+                const { atomicWriteJSON: writeJSON } = await import('./shared/atomic-write.js');
+                writeJSON(lastLifecyclePath, { lastRun: new Date().toISOString() });
+            }
+        }
+        catch (e) {
+            log.debug('lifecycle check 실패', e);
         }
-        catch { /* last-lifecycle.json parse failure — run lifecycle check anyway */ }
-        if (shouldRun) {
-            // B-4: detached background spawn으로 분리 — hook timeout 초과 방지
-            const { spawn: spawnLifecycle } = await import('node:child_process');
-            const lifecycleRunner = spawnLifecycle('node', [
-                '--input-type=module',
-                '-e',
-                `import('${lifecycleModulePath.replace(/\\/g, '/')}').then(m => m.runLifecycleCheck('${sessionId}'))`,
-            ], { detached: true, stdio: 'ignore' });
-            lifecycleRunner.unref();
-            const { atomicWriteJSON: writeJSON } = await import('./shared/atomic-write.js');
-            writeJSON(lastLifecyclePath, { lastRun: new Date().toISOString() });
+        if (recoveryMessages.length > 0) {
+            console.log(approveWithContext(recoveryMessages.join('\n\n'), 'SessionStart'));
+        }
+        else {
+            console.log(approve());
         }
     }
-    catch (e) {
-        log.debug('lifecycle check 실패', e);
-    }
-    if (recoveryMessages.length > 0) {
-        console.log(approveWithContext(recoveryMessages.join('\n\n'), 'SessionStart'));
-    }
-    else {
-        console.log(approve());
+    finally {
+        recordHookTiming('session-recovery', Date.now() - _hookStart, 'SessionStart');
     }
 }
 // ESM main guard: 다른 모듈에서 import 시 main() 실행 방지
@@ -401,6 +421,6 @@ async function main() {
 if (process.argv[1] && fs.realpathSync(path.resolve(process.argv[1])) === fileURLToPath(import.meta.url)) {
     main().catch((e) => {
         process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-        console.log(failOpen());
+        console.log(failOpenWithTracking('session-recovery'));
     });
 }

package/dist/hooks/shared/hook-response.d.ts

@@ -31,3 +31,10 @@ export declare function deny(reason: string): string;
 export declare function ask(reason: string): string;
 /** fail-open: 에러 시 안전하게 통과 */
 export declare function failOpen(): string;
+/**
+ * fail-open with error tracking: 에러 시 안전하게 통과하되, 실패 정보를 기록.
+ * forgen doctor의 Hook Health 섹션에서 실패 이력을 표시할 수 있도록 JSONL 로그에 기록.
+ *
+ * @fail-open: hook failure must never block the user's workflow
+ */
+export declare function failOpenWithTracking(hookName: string): string;

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

@@ -13,6 +13,9 @@
  *   systemMessage 필드는 UI 표시용으로만 사용되며 모델에 전달되지 않음.
  *   모델에 컨텍스트를 주입하려면 반드시 additionalContext를 사용해야 함.
  */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
 /** 통과 응답 (컨텍스트 없음, 모든 이벤트 공통) */
 export function approve() {
     return JSON.stringify({ continue: true });
@@ -60,3 +63,20 @@ export function ask(reason) {
 export function failOpen() {
     return JSON.stringify({ continue: true });
 }
+/**
+ * fail-open with error tracking: 에러 시 안전하게 통과하되, 실패 정보를 기록.
+ * forgen doctor의 Hook Health 섹션에서 실패 이력을 표시할 수 있도록 JSONL 로그에 기록.
+ *
+ * @fail-open: hook failure must never block the user's workflow
+ */
+export function failOpenWithTracking(hookName) {
+    try {
+        const stateDir = path.join(os.homedir(), '.forgen', 'state');
+        fs.mkdirSync(stateDir, { recursive: true });
+        const logPath = path.join(stateDir, 'hook-errors.jsonl');
+        const entry = JSON.stringify({ hook: hookName, at: Date.now() });
+        fs.appendFileSync(logPath, entry + '\n');
+    }
+    catch { /* fail-open: tracking itself must not throw */ }
+    return JSON.stringify({ continue: true });
+}

package/dist/hooks/shared/hook-timing.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Forgen — Hook Timing Profiler
+ *
+ * Records hook execution durations and provides timing statistics
+ * for visibility into which hooks are slow.
+ */
+export declare function recordHookTiming(hookName: string, durationMs: number, event: string): void;
+export interface TimingStats {
+    hook: string;
+    count: number;
+    p50: number;
+    p95: number;
+    max: number;
+}
+export declare function getTimingStats(): TimingStats[];