@wooojin/forgen 0.2.0 → 0.2.1

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,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);
-                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));
+    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;
                 }
-                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 });
@@ -161,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.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'));
 });