@wooojin/forgen 0.1.1 → 0.2.1

package/dist/engine/solution-matcher.js

@@ -31,6 +31,73 @@ export function expandTagsWithSynonyms(tags) {
     return defaultNormalizer.normalizeTerms(tags);
 }
 // ── TF-IDF weighting for common tags ──
+// ── Character bigram similarity (Dice coefficient) ──
+/**
+ * Compute the Dice coefficient between two strings using character bigrams.
+ *
+ * Dice = 2 * |intersection| / (|A| + |B|)
+ *
+ * Both strings are lowercased and whitespace-stripped before bigram generation.
+ * Returns 0 for empty strings or single-character strings (no bigrams possible).
+ * Returns 1.0 for identical non-trivial strings.
+ *
+ * This is used as a lightweight fuzzy matching signal for borderline cases
+ * where the TF-IDF tag intersection produces a low score but the query and
+ * solution tags are character-similar (e.g., "database" vs "데이터베이스"
+ * won't match, but "database" vs "databse" will get a high score).
+ */
+export function bigramSimilarity(a, b) {
+    const na = a.toLowerCase().replace(/\s+/g, '');
+    const nb = b.toLowerCase().replace(/\s+/g, '');
+    if (na.length < 2 || nb.length < 2)
+        return 0;
+    if (na === nb)
+        return 1.0;
+    const bigramsA = new Map();
+    for (let i = 0; i < na.length - 1; i++) {
+        const bg = na.slice(i, i + 2);
+        bigramsA.set(bg, (bigramsA.get(bg) ?? 0) + 1);
+    }
+    const bigramsB = new Map();
+    for (let i = 0; i < nb.length - 1; i++) {
+        const bg = nb.slice(i, i + 2);
+        bigramsB.set(bg, (bigramsB.get(bg) ?? 0) + 1);
+    }
+    let intersectionSize = 0;
+    for (const [bg, countA] of bigramsA) {
+        const countB = bigramsB.get(bg) ?? 0;
+        intersectionSize += Math.min(countA, countB);
+    }
+    const totalA = na.length - 1;
+    const totalB = nb.length - 1;
+    return (2 * intersectionSize) / (totalA + totalB);
+}
+// ── BM25-like scoring ──
+/**
+ * Simplified BM25 score for a single query-document pair.
+ * Uses tag overlap with term frequency normalization.
+ * k1=1.2, b=0.75 (standard BM25 parameters).
+ */
+export function bm25Score(queryTags, docTags, avgDocLength) {
+    const k1 = 1.2;
+    const b = 0.75;
+    const docLen = docTags.length;
+    if (docLen === 0 || queryTags.length === 0 || avgDocLength === 0)
+        return 0;
+    let score = 0;
+    for (const qt of queryTags) {
+        // Term frequency in document
+        const tf = docTags.filter(dt => dt === qt || (dt.length > 3 && qt.length > 3 && (dt.includes(qt) || qt.includes(dt)))).length;
+        if (tf === 0)
+            continue;
+        // BM25 TF saturation
+        const numerator = tf * (k1 + 1);
+        const denominator = tf + k1 * (1 - b + b * (docLen / avgDocLength));
+        score += numerator / denominator;
+    }
+    // Normalize by query length
+    return score / queryTags.length;
+}
 /** High-frequency tags that should be weighted lower */
 const COMMON_TAGS = new Set([
     'typescript', 'ts', 'javascript', 'js', 'fix', 'update', 'add', 'change',
@@ -72,20 +139,66 @@ export function calculateRelevance(promptOrTags, keywordsOrTags, confidence, opt
     // Apply TF-IDF weighting: common tags count less
     const weightedMatched = intersection.reduce((sum, t) => sum + tagWeight(t), 0)
         + partialMatches.reduce((sum, t) => sum + tagWeight(t) * 0.5, 0);
-    // 완화된 임계값: 가중 점수 0.5 이상이면 후보
-    if (weightedMatched < 0.5)
+    // ── Bigram similarity boost for borderline cases ──
+    //
+    // When the TF-IDF intersection score is below the match threshold (0.5),
+    // compute a character-bigram Dice coefficient between the query tags and
+    // the solution tags. If the best bigram similarity is high enough, blend
+    // it in at 20% weight (TF-IDF 80%, bigram 20%) to rescue fuzzy matches
+    // that the exact/substring intersection missed (e.g., typos, slight
+    // morphological variants).
+    //
+    // When TF-IDF score is already above threshold, the bigram boost is NOT
+    // applied — this preserves existing match quality and avoids disturbing
+    // already-good rankings. The bigram path is purely a rescue mechanism
+    // for borderline cases.
+    if (weightedMatched < 0.5) {
+        // Compute best bigram similarity across all (promptTag, solutionTag) pairs
+        let bestBigramScore = 0;
+        const bigramMatchedTags = [];
+        for (const st of matchTags) {
+            for (const pt of expandedPromptTags) {
+                const sim = bigramSimilarity(pt, st);
+                if (sim > bestBigramScore) {
+                    bestBigramScore = sim;
+                }
+                // Track solution tags with meaningful bigram similarity (> 0.4)
+                if (sim > 0.4 && !bigramMatchedTags.includes(st)) {
+                    bigramMatchedTags.push(st);
+                }
+            }
+        }
+        // Only rescue if the bigram signal is strong enough (> 0.4 threshold)
+        // to avoid noise from weakly similar strings
+        if (bestBigramScore > 0.4) {
+            const union = new Set([...promptOrTags, ...keywordsOrTags]).size;
+            const tfidfScore = weightedMatched / Math.max(union, 1);
+            const blendedScore = tfidfScore * 0.8 + bestBigramScore * 0.2;
+            return {
+                relevance: blendedScore * (confidence ?? 1),
+                matchedTags: [...intersection, ...partialMatches, ...bigramMatchedTags.filter(t => !intersection.includes(t) && !partialMatches.includes(t))],
+            };
+        }
         return { relevance: 0, matchedTags: [] };
-    // Jaccard-like: weighted matched / union.
-    // Union uses RAW promptTags and RAW solutionTags — not the expanded set —
-    // so that the denominator semantics are unchanged from pre-T2 behaviour.
-    // This is intentional: expanding both sides of the Jaccard would
-    // asymmetrically inflate recall and silently shift all baseline metrics.
-    // R4-T1 explicitly preserves this: `keywordsOrTags` is the raw solution
-    // tag list, not the compound-expanded `matchTags` used above.
+    }
+    // Ensemble: TF-IDF (Jaccard) 0.5 + BM25 0.3 + bigram 0.2
     const union = new Set([...promptOrTags, ...keywordsOrTags]).size;
-    const tagScore = weightedMatched / Math.max(union, 1);
+    const tfidfScore = weightedMatched / Math.max(union, 1);
+    // BM25 component: average doc length defaults to 6 tags (typical solution)
+    const avgDocLen = options?.avgDocLength ?? 6;
+    const bm25 = bm25Score(promptOrTags, keywordsOrTags, avgDocLen);
+    // Bigram component (mild boost for partial string matches)
+    let bigramBoost = 0;
+    for (const st of matchTags) {
+        for (const pt of expandedPromptTags) {
+            const sim = bigramSimilarity(pt, st);
+            if (sim > bigramBoost)
+                bigramBoost = sim;
+        }
+    }
+    const ensembleScore = tfidfScore * 0.5 + bm25 * 0.3 + bigramBoost * 0.2;
     return {
-        relevance: tagScore * (confidence ?? 1),
+        relevance: ensembleScore * (confidence ?? 1),
         matchedTags: [...intersection, ...partialMatches],
     };
 }

package/dist/forge/mismatch-detector.js

@@ -34,6 +34,9 @@ export function computeSessionSignals(sessionId, corrections, summaries, newStro
                 if (direction === 'opposite') {
                     signals.push({ session_id: sessionId, axis, score: 2, reason: `반대 방향 correction: ${c.summary}` });
                 }
+                if (direction === 'same' && (axis === 'quality_safety' || axis === 'autonomy')) {
+                    signals.push({ session_id: sessionId, axis, score: 1, reason: `교정 누적: ${c.summary}` });
+                }
             }
         }
     }

package/dist/hooks/context-guard.d.ts

@@ -19,6 +19,16 @@ export declare function shouldWarn(contextPercent: {
     charsThreshold?: number;
     cooldownMs?: number;
 }): boolean;
+/** auto-compact 트리거 여부 판정 (순수 함수) */
+export declare function shouldAutoCompact(state: {
+    totalChars: number;
+    lastAutoCompactAt: number;
+}, thresholds?: {
+    charsThreshold?: number;
+    cooldownMs?: number;
+}): boolean;
+/** auto-compact 지시 메시지 생성 (순수 함수) */
+export declare function buildAutoCompactMessage(totalChars: number): string;
 /** 경고 메시지 생성 (순수 함수) */
 export declare function buildContextWarningMessage(promptCount: number, totalChars: number): string;
 export declare function main(): Promise<void>;

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,67 +67,104 @@ 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);
-                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;
+    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';
+            // 에러가 포함된 경우: 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 */ }
+                    console.log(approveWithWarning(`[Forgen] Session with ${state.promptCount} prompts ended. Compound loop will auto-trigger on next session start.`));
+                    return;
+                }
+                if (state.promptCount >= 10) {
+                    // 10-19 prompts: suggest /compound manually
+                    console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다. /compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
+                    return;
+                }
+            }
+            console.log(approve());
+            return;
+        }
+        // error만 있는 경우 (stop_hook_type 없이)
+        if (input.error) {
+            console.log(approve());
+            return;
         }
-        // 정상 종료 시: 의미 있는 세션이었으면 compound 안내
-        if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
+        // 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;
     }
-    // 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;
-        }
-        saveContextState(state);
+    finally {
+        recordHookTiming('context-guard', Date.now() - _hookStart, _hookEvent);
     }
-    console.log(approve());
 }
 function saveHandoff(sessionId, reason, detail) {
     fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
@@ -151,6 +207,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/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)) {
@@ -54,9 +77,11 @@ async function main() {
         return;
     }
     const hint = INTENT_HINTS[intent];
-    console.log(approveWithContext(`[intent: ${intent}] ${hint}`, 'UserPromptSubmit'));
+    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'));
 });