@wooojin/forgen 0.2.0 → 0.3.0

package/dist/hooks/context-guard.js

@@ -16,14 +16,18 @@ import { createLogger } from '../core/logger.js';
 import { readStdinJSON } from './shared/read-stdin.js';
 import { atomicWriteJSON } from './shared/atomic-write.js';
 import { loadHookConfig, isHookEnabled } from './hook-config.js';
-import { approve, approveWithContext, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { approve, approveWithContext, approveWithWarning, failOpenWithTracking } from './shared/hook-response.js';
 import { HANDOFFS_DIR, STATE_DIR } from '../core/paths.js';
+import { recordHookTiming } from './shared/hook-timing.js';
 const log = createLogger('context-guard');
 const CONTEXT_STATE_PATH = path.join(STATE_DIR, 'context-guard.json');
 // 경고 임계값: 프롬프트 50회 또는 총 문자 수 200K 이상
 const PROMPT_WARNING_THRESHOLD = 50;
 const CHARS_WARNING_THRESHOLD = 200_000;
 const WARNING_COOLDOWN_MS = 10 * 60 * 1000; // 10분 쿨다운
+// Auto-compact 임계값: 추적된 문자 120K ≈ 실제 context ~20%
+const AUTO_COMPACT_CHARS_THRESHOLD = 120_000;
+const AUTO_COMPACT_COOLDOWN_MS = 5 * 60 * 1000; // 5분 쿨다운
 /** 경고 표시 여부 판정 (순수 함수) */
 export function shouldWarn(contextPercent, thresholds = {}) {
     const promptThreshold = thresholds.promptThreshold ?? PROMPT_WARNING_THRESHOLD;
@@ -33,6 +37,21 @@ export function shouldWarn(contextPercent, thresholds = {}) {
     return ((contextPercent.promptCount >= promptThreshold || contextPercent.totalChars >= charsThreshold) &&
         (now - contextPercent.lastWarningAt > cooldownMs));
 }
+/** auto-compact 트리거 여부 판정 (순수 함수) */
+export function shouldAutoCompact(state, thresholds = {}) {
+    const charsThreshold = thresholds.charsThreshold ?? AUTO_COMPACT_CHARS_THRESHOLD;
+    const cooldownMs = thresholds.cooldownMs ?? AUTO_COMPACT_COOLDOWN_MS;
+    const now = Date.now();
+    return state.totalChars >= charsThreshold && (now - state.lastAutoCompactAt > cooldownMs);
+}
+/** auto-compact 지시 메시지 생성 (순수 함수) */
+export function buildAutoCompactMessage(totalChars) {
+    return `<forgen-auto-compact>
+[Forgen] Context 사용량이 ${Math.round(totalChars / 1000)}K 문자에 도달했습니다 (추정 ~20%+).
+지금 즉시 /compact를 실행하여 컨텍스트를 압축하세요. 이 지시는 자동으로 생성되었습니다.
+현재 작업을 마무리하지 말고, 다음 응답에서 바로 compact를 실행하세요.
+</forgen-auto-compact>`;
+}
 /** 경고 메시지 생성 (순수 함수) */
 export function buildContextWarningMessage(promptCount, totalChars) {
     return `<compound-context-warning>\n[Forgen] Context limit approaching: ${promptCount} prompts, ${Math.round(totalChars / 1000)}K characters.\nIf you have important progress, save it now:\n- Use cancelforgen to reset mode state and start a new session\n- Or continue current work (auto compaction may occur)\n</compound-context-warning>`;
@@ -48,77 +67,220 @@ function loadContextState(sessionId) {
     catch (e) {
         log.debug('context state 파일 읽기/파싱 실패', e);
     }
-    return { promptCount: 0, totalChars: 0, lastWarningAt: 0, sessionId };
+    return { promptCount: 0, totalChars: 0, lastWarningAt: 0, lastAutoCompactAt: 0, sessionId };
 }
 function saveContextState(state) {
     atomicWriteJSON(CONTEXT_STATE_PATH, state);
 }
 export async function main() {
-    const input = await readStdinJSON();
-    if (!isHookEnabled('context-guard')) {
-        console.log(approve());
-        return;
-    }
-    if (!input) {
-        console.log(approve());
-        return;
-    }
-    const sessionId = input.session_id ?? 'default';
-    // Stop 훅: stop_hook_type이 있으면 처리
-    if (input.stop_hook_type) {
-        // 에러가 포함된 경우: context limit 감지
-        if (input.error) {
-            const errorMsg = input.error;
-            if (/context.*limit|token.*limit|conversation.*too.*long/i.test(errorMsg)) {
-                saveHandoff(sessionId, 'context-limit', errorMsg);
-                try {
-                    const resumePath = path.join(STATE_DIR, 'pending-resume.json');
-                    fs.writeFileSync(resumePath, JSON.stringify({
-                        reason: 'token-limit',
-                        sessionId,
-                        savedAt: new Date().toISOString(),
-                        cwd: process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd(),
-                    }, null, 2));
-                }
-                catch { /* fail-open */ }
-                console.log(approveWithWarning(`[Forgen] Context limit reached. Current state has been saved to ~/.forgen/handoffs/.\nThe previous work will be automatically recovered in the next session.`));
+    const _hookStart = Date.now();
+    let _hookEvent = 'UserPromptSubmit';
+    try {
+        const input = await readStdinJSON();
+        if (!isHookEnabled('context-guard')) {
+            console.log(approve());
+            return;
+        }
+        if (!input) {
+            console.log(approve());
+            return;
+        }
+        const sessionId = input.session_id ?? 'default';
+        // Stop 훅: stop_hook_type이 있으면 처리
+        if (input.stop_hook_type) {
+            _hookEvent = 'Stop';
+            // forge-loop 활성 시 미완료 스토리 감지 → 지속 메시지 주입 (polite-stop 방지)
+            const forgeLoopBlock = checkForgeLoopActive();
+            if (forgeLoopBlock) {
+                console.log(forgeLoopBlock);
                 return;
             }
+            // 에러가 포함된 경우: context limit 감지
+            if (input.error) {
+                const errorMsg = input.error;
+                if (/context.*limit|token.*limit|conversation.*too.*long/i.test(errorMsg)) {
+                    saveHandoff(sessionId, 'context-limit', errorMsg);
+                    try {
+                        const resumePath = path.join(STATE_DIR, 'pending-resume.json');
+                        fs.writeFileSync(resumePath, JSON.stringify({
+                            reason: 'token-limit',
+                            sessionId,
+                            savedAt: new Date().toISOString(),
+                            cwd: process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd(),
+                        }, null, 2));
+                    }
+                    catch { /* fail-open */ }
+                    console.log(approveWithWarning(`[Forgen] Context limit reached. Current state has been saved to ~/.forgen/handoffs/.\nThe previous work will be automatically recovered in the next session.`));
+                    return;
+                }
+            }
+            // 정상 종료 시: 의미 있는 세션이었으면 compound 안내/자동 트리거
+            if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
+                const state = loadContextState(sessionId);
+                if (state.promptCount >= 20) {
+                    // 20+ prompts: auto-trigger compound by writing marker
+                    try {
+                        fs.mkdirSync(STATE_DIR, { recursive: true });
+                        const marker = { reason: 'session-end', promptCount: state.promptCount, detectedAt: new Date().toISOString() };
+                        fs.writeFileSync(path.join(STATE_DIR, 'pending-compound.json'), JSON.stringify(marker));
+                    }
+                    catch { /* fail-open: marker write failure is non-critical */ }
+                    const summary = buildSessionSummary(sessionId, state.promptCount);
+                    console.log(approveWithWarning(`[Forgen] Session with ${state.promptCount} prompts ended.\n${summary}\nCompound loop will auto-trigger on next session start.`));
+                    return;
+                }
+                if (state.promptCount >= 10) {
+                    // 10-19 prompts: suggest /compound manually
+                    const summary = buildSessionSummary(sessionId, state.promptCount);
+                    console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다.\n${summary}/compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
+                    return;
+                }
+            }
+            console.log(approve());
+            return;
         }
-        // 정상 종료 시: 의미 있는 세션이었으면 compound 안내
-        if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
+        // error만 있는 경우 (stop_hook_type 없이)
+        if (input.error) {
+            console.log(approve());
+            return;
+        }
+        // UserPromptSubmit 훅: 대화 길이 추적
+        if (input.prompt) {
+            const config = loadHookConfig('context-guard');
+            // maxTokens가 설정되어 있으면 chars threshold로 사용 (토큰 ≈ 4자 기준 환산)
+            const charsThreshold = typeof config?.maxTokens === 'number' ? config.maxTokens * 4 : undefined;
             const state = loadContextState(sessionId);
-            if (state.promptCount >= 10) {
-                // 10 프롬프트 이상이면 의미 있는 세션 — compound 안내
-                console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다. /compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
+            state.promptCount++;
+            state.totalChars += input.prompt.length;
+            // auto-compact: 추적 문자 120K 이상이면 compact 지시 주입
+            const autoCompactThreshold = typeof config?.autoCompactChars === 'number' ? config.autoCompactChars : undefined;
+            if (shouldAutoCompact(state, autoCompactThreshold !== undefined ? { charsThreshold: autoCompactThreshold } : {})) {
+                state.lastAutoCompactAt = Date.now();
+                saveContextState(state);
+                console.log(approveWithContext(buildAutoCompactMessage(state.totalChars), 'UserPromptSubmit'));
                 return;
             }
+            if (shouldWarn(state, charsThreshold !== undefined ? { charsThreshold } : {})) {
+                state.lastWarningAt = Date.now();
+                saveContextState(state);
+                console.log(approveWithContext(buildContextWarningMessage(state.promptCount, state.totalChars), 'UserPromptSubmit'));
+                return;
+            }
+            saveContextState(state);
         }
         console.log(approve());
-        return;
     }
-    // error만 있는 경우 (stop_hook_type 없이)
-    if (input.error) {
-        console.log(approve());
-        return;
+    finally {
+        recordHookTiming('context-guard', Date.now() - _hookStart, _hookEvent);
     }
-    // UserPromptSubmit 훅: 대화 길이 추적
-    if (input.prompt) {
-        const config = loadHookConfig('context-guard');
-        // maxTokens가 설정되어 있으면 chars threshold로 사용 (토큰 ≈ 4자 기준 환산)
-        const charsThreshold = typeof config?.maxTokens === 'number' ? config.maxTokens * 4 : undefined;
-        const state = loadContextState(sessionId);
-        state.promptCount++;
-        state.totalChars += input.prompt.length;
-        if (shouldWarn(state, charsThreshold !== undefined ? { charsThreshold } : {})) {
-            state.lastWarningAt = Date.now();
-            saveContextState(state);
-            console.log(approveWithContext(buildContextWarningMessage(state.promptCount, state.totalChars), 'UserPromptSubmit'));
-            return;
+}
+/**
+ * 세션 종료 시 "forgen이 도움이 된 정도"를 요약.
+ * solution-cache에서 이번 세션에 주입된 compound 솔루션 수를 집계하여
+ * 카운터팩추얼 "forgen 없었으면 ~N분 더 걸렸을 것" 메시지 생성.
+ */
+function buildSessionSummary(sessionId, promptCount) {
+    try {
+        const cachePath = path.join(STATE_DIR, `solution-cache-${sessionId}.json`);
+        if (!fs.existsSync(cachePath))
+            return '';
+        const cache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        const injected = Array.isArray(cache.injected) ? cache.injected : [];
+        if (injected.length === 0)
+            return '';
+        // 카운터팩추얼: 주입된 compound 1건당 평균 8분 절약 가정 (하한 추정)
+        const savedMins = injected.length * 8;
+        const savedStr = savedMins >= 60
+            ? `${Math.floor(savedMins / 60)}시간 ${savedMins % 60}분`
+            : `${savedMins}분`;
+        // 상위 3개 솔루션
+        const topNames = injected.slice(0, 3).map(i => `"${i.name}"`).join(', ');
+        const moreCount = injected.length - 3;
+        const topStr = moreCount > 0 ? `${topNames} 외 ${moreCount}개` : topNames;
+        return [
+            `\n📊 이번 세션 forgen 효과:`,
+            `  주입된 compound: ${injected.length}건 (${topStr})`,
+            `  추정 절약 시간: ${savedStr} (forgen 없었으면 시행착오 필요)`,
+            `  프롬프트 대비 효율: ${(injected.length / promptCount * 100).toFixed(0)}% 의 대화가 축적된 지식의 도움을 받음\n`,
+        ].join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+// forge-loop 상태 파일 경로
+const FORGE_LOOP_STATE_PATH = path.join(STATE_DIR, 'forge-loop.json');
+// forge-loop 차단 안전 상한 (무한 루프 방지)
+const FORGE_LOOP_MAX_BLOCKS = 30;
+const FORGE_LOOP_STALE_MS = 2 * 60 * 60 * 1000; // 2시간
+/**
+ * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
+ * OMC의 persistent-mode.cjs 패턴 참고.
+ */
+export function checkForgeLoopActive() {
+    try {
+        if (!fs.existsSync(FORGE_LOOP_STATE_PATH))
+            return null;
+        const state = JSON.parse(fs.readFileSync(FORGE_LOOP_STATE_PATH, 'utf-8'));
+        if (!state.active)
+            return null;
+        // Stale 감지: 2시간+ 미활동 → 자동 비활성화
+        const startedAt = new Date(state.startedAt).getTime();
+        if (Number.isFinite(startedAt) && Date.now() - startedAt > FORGE_LOOP_STALE_MS) {
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 확인 대기 중이면 차단하지 않음 (사용자 개입 허용)
+        if (state.awaitingConfirmation)
+            return null;
+        // 안전 상한: 30회 이상 차단 시 무한 루프로 간주하여 해제
+        const blockCount = state.blockCount ?? 0;
+        if (blockCount >= FORGE_LOOP_MAX_BLOCKS) {
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 미완료 스토리 확인
+        const stories = Array.isArray(state.stories) ? state.stories : [];
+        const pending = stories.filter((s) => !s.passes);
+        if (pending.length === 0) {
+            // 모든 스토리 완료 → forge-loop 종료
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
         }
-        saveContextState(state);
+        // 차단 카운트 증가 + 지속 메시지 주입
+        state.blockCount = blockCount + 1;
+        state.lastBlockAt = new Date().toISOString();
+        atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+        const nextStory = pending[0];
+        const message = [
+            `<forgen-forge-loop iteration="${state.blockCount}/${FORGE_LOOP_MAX_BLOCKS}">`,
+            `[FORGE-LOOP] ${pending.length}개 스토리가 미완료입니다.`,
+            `현재 스토리: ${nextStory.id} — ${nextStory.title}`,
+            ``,
+            `계속 진행하세요. 보고는 다음 시점에만 합니다:`,
+            `  1. 모든 스토리 완료 (최종 리포트)`,
+            `  2. 3회 실패 (에스컬레이션)`,
+            `  3. Context limit 접근 (handoff)`,
+            ``,
+            `중간 "완료했습니다" 보고는 polite-stop anti-pattern입니다.`,
+            `취소하려면: "/forge-loop cancel" 또는 "cancelforgen" 입력`,
+            `</forgen-forge-loop>`,
+        ].join('\n');
+        // block 결정으로 Claude가 계속 작업하도록 강제
+        return JSON.stringify({
+            continue: true,
+            decision: 'block',
+            reason: message,
+        });
+    }
+    catch (e) {
+        // fail-open: forge-loop 상태 읽기 실패는 차단하지 않음
+        log.debug('forge-loop 상태 확인 실패', e);
+        return null;
     }
-    console.log(approve());
 }
 function saveHandoff(sessionId, reason, detail) {
     fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
@@ -161,6 +323,6 @@ function saveHandoff(sessionId, reason, detail) {
 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('context-guard'));
     });
 }

package/dist/hooks/db-guard.js

@@ -9,7 +9,7 @@ import * as path from 'node:path';
 import { readStdinJSON } from './shared/read-stdin.js';
 import { atomicWriteJSON } from './shared/atomic-write.js';
 import { isHookEnabled } from './hook-config.js';
-import { approve, approveWithWarning, deny, failOpen } from './shared/hook-response.js';
+import { approve, approveWithWarning, deny, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
 const FAIL_COUNTER_PATH = path.join(STATE_DIR, 'db-guard-fail-counter.json');
 const FAIL_CLOSE_THRESHOLD = 3;
@@ -101,5 +101,5 @@ async function main() {
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] DB Guard error: ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('db-guard'));
 });

package/dist/hooks/hook-config.d.ts

@@ -1,9 +1,17 @@
 /**
  * Forgen — Hook Config Loader
  *
- * ~/.compound/hook-config.json 에서 훅별 설정을 읽어 반환합니다.
+ * hook-config.json 에서 훅별 설정을 읽어 반환합니다.
  * 파일이 없거나 읽기에 실패하면 null 을 반환합니다 (failure-tolerant).
  *
+ * 설정 로딩 우선순위:
+ *   1. 프로젝트 레벨: {cwd}/.forgen/hook-config.json
+ *   2. 글로벌 레벨: FORGEN_HOME/hook-config.json (~/.forgen/hook-config.json)
+ *   프로젝트 설정은 글로벌 설정과 머지됩니다 (훅 단위 오버라이드).
+ *   프로젝트 설정이 없으면 글로벌 설정만 사용 (하위호환).
+ *
+ * cwd 결정: process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd()
+ *
  * 설정 형식 (hook-config.json):
  * {
  *   "tiers": { "compound-core": { "enabled": true }, "safety": { "enabled": true }, "workflow": { "enabled": true } },
@@ -15,6 +23,24 @@
  *   - compound-core 티어는 tiers 설정으로 비활성화 불가 (복리화 보호)
  *   - 개별 hooks.hookName.enabled: false 로만 비활성화 가능
  */
+/** 훅 설정 파일의 전체 구조 타입 */
+export type HookConfig = Record<string, unknown>;
+/**
+ * 프로젝트의 작업 디렉토리를 결정합니다.
+ * FORGEN_CWD → COMPOUND_CWD → process.cwd() 순서.
+ */
+export declare function resolveProjectCwd(): string;
+/**
+ * 글로벌 설정과 프로젝트 설정을 머지합니다.
+ * 프로젝트 설정이 글로벌 설정을 훅 단위로 오버라이드합니다.
+ *
+ * 머지 규칙:
+ *   - tiers: 프로젝트가 글로벌을 훅 단위로 오버라이드 (shallow merge)
+ *   - hooks: 프로젝트가 글로벌을 훅 단위로 오버라이드 (shallow merge)
+ *   - 최상위 레거시 키: 프로젝트가 글로벌을 키 단위로 오버라이드
+ *   - 프로젝트에 없는 키는 글로벌에서 상속
+ */
+export declare function mergeHookConfigs(global: HookConfig, project: HookConfig): HookConfig;
 /** 특정 훅의 설정을 반환합니다. 실패 시 null 반환. */
 export declare function loadHookConfig(hookName: string): Record<string, unknown> | null;
 /**

package/dist/hooks/hook-config.js

@@ -1,9 +1,17 @@
 /**
  * Forgen — Hook Config Loader
  *
- * ~/.compound/hook-config.json 에서 훅별 설정을 읽어 반환합니다.
+ * hook-config.json 에서 훅별 설정을 읽어 반환합니다.
  * 파일이 없거나 읽기에 실패하면 null 을 반환합니다 (failure-tolerant).
  *
+ * 설정 로딩 우선순위:
+ *   1. 프로젝트 레벨: {cwd}/.forgen/hook-config.json
+ *   2. 글로벌 레벨: FORGEN_HOME/hook-config.json (~/.forgen/hook-config.json)
+ *   프로젝트 설정은 글로벌 설정과 머지됩니다 (훅 단위 오버라이드).
+ *   프로젝트 설정이 없으면 글로벌 설정만 사용 (하위호환).
+ *
+ * cwd 결정: process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd()
+ *
  * 설정 형식 (hook-config.json):
  * {
  *   "tiers": { "compound-core": { "enabled": true }, "safety": { "enabled": true }, "workflow": { "enabled": true } },
@@ -19,30 +27,82 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { HOOK_REGISTRY } from './hook-registry.js';
 import { FORGEN_HOME } from '../core/paths.js';
-const HOOK_CONFIG_PATH = path.join(FORGEN_HOME, 'hook-config.json');
+const GLOBAL_CONFIG_PATH = path.join(FORGEN_HOME, 'hook-config.json');
 /**
  * 훅 → 티어 매핑 (hook-registry.ts에서 자동 파생).
  * 이중 구현 방지: HOOK_REGISTRY가 단일 소스 오브 트루스.
  */
 const HOOK_TIER_MAP = Object.fromEntries(HOOK_REGISTRY.map(h => [h.name, h.tier]));
+/**
+ * 프로젝트의 작업 디렉토리를 결정합니다.
+ * FORGEN_CWD → COMPOUND_CWD → process.cwd() 순서.
+ */
+export function resolveProjectCwd() {
+    return process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+}
+/** JSON 파일을 파싱하여 반환. 파일 없음 또는 파싱 실패 시 null. */
+function loadJsonFile(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 글로벌 설정과 프로젝트 설정을 머지합니다.
+ * 프로젝트 설정이 글로벌 설정을 훅 단위로 오버라이드합니다.
+ *
+ * 머지 규칙:
+ *   - tiers: 프로젝트가 글로벌을 훅 단위로 오버라이드 (shallow merge)
+ *   - hooks: 프로젝트가 글로벌을 훅 단위로 오버라이드 (shallow merge)
+ *   - 최상위 레거시 키: 프로젝트가 글로벌을 키 단위로 오버라이드
+ *   - 프로젝트에 없는 키는 글로벌에서 상속
+ */
+export function mergeHookConfigs(global, project) {
+    const merged = { ...global };
+    // tiers 머지 (shallow per-tier)
+    const globalTiers = global.tiers;
+    const projectTiers = project.tiers;
+    if (globalTiers || projectTiers) {
+        merged.tiers = { ...globalTiers, ...projectTiers };
+    }
+    // hooks 머지 (shallow per-hook)
+    const globalHooks = global.hooks;
+    const projectHooks = project.hooks;
+    if (globalHooks || projectHooks) {
+        merged.hooks = { ...globalHooks, ...projectHooks };
+    }
+    // 나머지 최상위 키: 프로젝트가 글로벌을 오버라이드
+    for (const key of Object.keys(project)) {
+        if (key === 'tiers' || key === 'hooks')
+            continue;
+        merged[key] = project[key];
+    }
+    return merged;
+}
 /** 프로세스 내 설정 캐시 (각 훅은 별도 프로세스이므로 수명 = 1회 실행) */
 let _configCache;
-/** 전체 설정 파일을 파싱합니다. 실패 시 null. 프로세스 내 캐싱. */
+/** 전체 설정 파일을 파싱합니다 (글로벌 + 프로젝트 머지). 실패 시 null. 프로세스 내 캐싱. */
 function loadFullConfig() {
     if (_configCache !== undefined)
         return _configCache;
-    try {
-        if (!fs.existsSync(HOOK_CONFIG_PATH)) {
-            _configCache = null;
-            return null;
-        }
-        _configCache = JSON.parse(fs.readFileSync(HOOK_CONFIG_PATH, 'utf-8'));
-        return _configCache;
-    }
-    catch {
+    const globalConfig = loadJsonFile(GLOBAL_CONFIG_PATH);
+    const projectConfigPath = path.join(resolveProjectCwd(), '.forgen', 'hook-config.json');
+    const projectConfig = loadJsonFile(projectConfigPath);
+    if (!globalConfig && !projectConfig) {
         _configCache = null;
         return null;
     }
+    if (globalConfig && projectConfig) {
+        _configCache = mergeHookConfigs(globalConfig, projectConfig);
+    }
+    else {
+        _configCache = globalConfig ?? projectConfig ?? null;
+    }
+    return _configCache;
 }
 /** 특정 훅의 설정을 반환합니다. 실패 시 null 반환. */
 export function loadHookConfig(hookName) {

package/dist/hooks/hooks-generator.d.ts

@@ -9,6 +9,7 @@
  *   - forgen config hooks (사용자 설정 변경 후)
  *   - forgen install (플러그인 설치 후)
  */
+import { type RuntimeHost } from '../core/types.js';
 interface HookCommand {
     type: 'command';
     command: string;
@@ -27,6 +28,8 @@ interface GenerateOptions {
     cwd?: string;
     /** 훅 실행 스크립트의 루트 경로 */
     pluginRoot?: string;
+    /** 런타임 (claude|codex) */
+    runtime?: RuntimeHost;
 }
 /**
  * 활성 훅만 포함한 hooks.json 객체를 생성합니다.

package/dist/hooks/hooks-generator.js

@@ -14,6 +14,27 @@ import * as path from 'node:path';
 import { HOOK_REGISTRY } from './hook-registry.js';
 import { isHookEnabled } from './hook-config.js';
 import { detectInstalledPlugins, getHookConflicts } from '../core/plugin-detector.js';
+function splitCommand(raw) {
+    const tokens = raw.match(/"([^"]+)"|\S+/g) ?? [];
+    const unquoted = tokens.map(token => token.replace(/^"/, '').replace(/"$/, ''));
+    return { script: unquoted[0] ?? '', args: unquoted.slice(1) };
+}
+function quoteArg(raw) {
+    return `"${raw.replace(/"/g, '\\"')}"`;
+}
+function buildHookCommand(pluginRoot, rawScript, runtime) {
+    const { script, args } = splitCommand(rawScript);
+    const scriptPath = `${pluginRoot}/${script}`;
+    const quotedArgs = args.map(quoteArg).join(' ');
+    if (runtime === 'codex') {
+        const adapterPath = `${pluginRoot}/host/codex-adapter.js`;
+        const baseCommand = `node ${quoteArg(adapterPath)} ${quoteArg(scriptPath)}`;
+        return `${baseCommand}${quotedArgs ? ` ${quotedArgs}` : ''}`;
+    }
+    return quotedArgs
+        ? `node ${quoteArg(scriptPath)} ${quotedArgs}`
+        : `node ${quoteArg(scriptPath)}`;
+}
 /**
  * 활성 훅만 포함한 hooks.json 객체를 생성합니다.
  *
@@ -27,6 +48,7 @@ export function generateHooksJson(options) {
     const cwd = options?.cwd;
     // biome-ignore lint/suspicious/noTemplateCurlyInString: CLAUDE_PLUGIN_ROOT is a Claude Code Plugin SDK variable resolved at runtime
     const pluginRoot = options?.pluginRoot ?? '${CLAUDE_PLUGIN_ROOT}/dist';
+    const runtime = options?.runtime ?? 'claude';
     // 다른 플러그인의 충돌 훅 감지
     const hookConflicts = getHookConflicts(cwd);
     const detectedPlugins = detectInstalledPlugins(cwd);
@@ -64,12 +86,7 @@ export function generateHooksJson(options) {
         hooks[event] = [...byMatcher.entries()].map(([matcher, matcherEntries]) => ({
             matcher,
             hooks: matcherEntries.map(h => {
-                // script에 인자가 포함된 경우 (예: "hooks/subagent-tracker.js start")
-                // 파일 경로와 인자를 분리해야 셸에서 ENOENT를 방지
-                const spaceIdx = h.script.indexOf(' ');
-                const command = spaceIdx === -1
-                    ? `node "${pluginRoot}/${h.script}"`
-                    : `node "${pluginRoot}/${h.script.slice(0, spaceIdx)}" ${h.script.slice(spaceIdx + 1)}`;
+                const command = buildHookCommand(pluginRoot, h.script, runtime);
                 return { type: 'command', command, timeout: h.timeout };
             }),
         }));

package/dist/hooks/intent-classifier.d.ts

@@ -10,5 +10,3 @@
  */
 export type Intent = 'implement' | 'debug' | 'refactor' | 'explain' | 'review' | 'explore' | 'design' | 'general';
 export declare function classifyIntent(prompt: string): Intent;
-/** 프롬프트에 매칭되는 모든 의도를 반환. 없으면 ['general']. */
-export declare function classifyAllIntents(prompt: string): Intent[];

package/dist/hooks/intent-classifier.js

@@ -10,9 +10,9 @@
  */
 import { readStdinJSON } from './shared/read-stdin.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';
 const INTENT_RULES = [
-    { intent: 'implement', pattern: /(?:만들어|추가해|구현해|생성해|작성해|넣어|create|add|implement|build|write|make)\b/i },
+    { intent: 'implement', pattern: /(?:만들어|추가해|구현해|생성해|작성해|넣어|create|add|implement|build|write|make)(?:\b|(?=[가-힣\s]|$))/i },
     { intent: 'debug', pattern: /(?:에러|버그|안돼|안\s*되|안\s*됨|왜|고쳐|수정해|fix|bug|error|debug|문제|실패|fail|crash|broken)/i },
     { intent: 'refactor', pattern: /(?:리팩토링|리팩터|정리|개선|refactor|clean\s*up|improve|optimize|최적화)/i },
     { intent: 'explain', pattern: /(?:설명|알려|뭐야|뭔가요|어떻게|explain|what\s+is|how\s+does|why\s+does|tell\s+me)/i },
@@ -30,6 +30,29 @@ const INTENT_HINTS = {
     design: 'Design task. Specify trade-offs explicitly.',
     general: 'General request.',
 };
+/** Intent-specific context rules injected via additionalContext */
+const INTENT_CONTEXT = {
+    implement: `[quality-rules]
+- Write tests for new logic (branch coverage 83%+)
+- Build + lint + type-check must pass before completion
+- Prefer small incremental changes (<200 lines)
+- Interfaces and type contracts before implementation`,
+    review: `[review-rules]
+- Report format: [SEVERITY] file:line — issue
+- Check: logic errors, security (OWASP), performance, maintainability
+- Verify edge cases and error handling at system boundaries
+- No empty catch blocks, no eslint-disable without justification`,
+    debug: `[debug-rules]
+- Reproduce the bug first, then isolate the root cause
+- Write a failing test that captures the bug before fixing
+- Check for regression: does the fix break anything else?
+- Read error messages carefully — they usually point to the cause`,
+    refactor: `[refactor-rules]
+- Ensure all tests pass before AND after refactoring
+- Make one structural change at a time, verify between each
+- Preserve external behavior — refactoring changes structure, not function
+- Avoid mixing refactoring with feature changes in the same pass`,
+};
 export function classifyIntent(prompt) {
     for (const rule of INTENT_RULES) {
         if (rule.pattern.test(prompt)) {
@@ -38,16 +61,6 @@ export function classifyIntent(prompt) {
     }
     return 'general';
 }
-/** 프롬프트에 매칭되는 모든 의도를 반환. 없으면 ['general']. */
-export function classifyAllIntents(prompt) {
-    const matches = [];
-    for (const rule of INTENT_RULES) {
-        if (rule.pattern.test(prompt)) {
-            matches.push(rule.intent);
-        }
-    }
-    return matches.length > 0 ? matches : ['general'];
-}
 async function main() {
     const input = await readStdinJSON();
     if (!isHookEnabled('intent-classifier')) {
@@ -58,16 +71,17 @@ async function main() {
         console.log(approve());
         return;
     }
-    const intents = classifyAllIntents(input.prompt);
-    if (intents.length === 1 && intents[0] === 'general') {
+    const intent = classifyIntent(input.prompt);
+    if (intent === 'general') {
         console.log(approve());
         return;
     }
-    const label = intents.join('+');
-    const hint = INTENT_HINTS[intents[0]];
-    console.log(approveWithContext(`[intent: ${label}] ${hint}`, 'UserPromptSubmit'));
+    const hint = INTENT_HINTS[intent];
+    const extra = INTENT_CONTEXT[intent] ?? '';
+    const context = extra ? `[intent: ${intent}] ${hint}\n${extra}` : `[intent: ${intent}] ${hint}`;
+    console.log(approveWithContext(context, 'UserPromptSubmit'));
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('intent-classifier'));
 });