@wooojin/forgen 0.1.0 → 0.2.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { prepareHarness, isFirstRun } from './core/harness.js';
-import { spawnClaude } from './core/spawn.js';
+import { spawnClaudeWithResume } from './core/spawn.js';
 // global-config is used by harness internally
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const pkgJson = JSON.parse(fs.readFileSync(path.resolve(__dirname, '..', 'package.json'), 'utf-8'));
@@ -245,7 +245,7 @@ async function main() {
   ${dim}Scope: v1(${context.v1.session?.quality_pack ?? 'onboarding needed'})${reset}
 `);
         console.log('[forgen] Starting Claude Code...\n');
-        await spawnClaude(args, context);
+        await spawnClaudeWithResume(args, context, () => prepareHarness(process.cwd()));
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/core/auto-compound-runner.js

@@ -14,6 +14,8 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import { execFileSync } from 'node:child_process';
 import { containsPromptInjection, filterSolutionContent } from '../hooks/prompt-injection-filter.js';
+import { createEvidence, saveEvidence, promoteSessionCandidates } from '../store/evidence-store.js';
+import { loadProfile } from '../store/profile-store.js';
 /** Auto-compound에 사용할 모델 — background 추출이므로 haiku로 충분 */
 const COMPOUND_MODEL = 'haiku';
 /** execFileSync wrapper: transient 에러(ETIMEDOUT 등) 시 1회 재시도 */
@@ -349,6 +351,20 @@ ${sanitizedSummary.slice(0, 4000)}
                     fs.writeFileSync(behaviorPath, content);
                 }
             }
+            // behavior_observation evidence 저장 (mismatch detector 신호 확대)
+            const behaviorEvidence = createEvidence({
+                type: 'behavior_observation',
+                session_id: sessionId,
+                source_component: 'auto-compound-runner',
+                summary: trimmed.slice(0, 200),
+                axis_refs: kind === 'workflow' ? ['judgment_philosophy']
+                    : kind === 'preference' ? ['communication_style']
+                        : kind === 'thinking' ? ['judgment_philosophy']
+                            : [],
+                confidence: 0.6,
+                raw_payload: { kind, observedCount: 1 },
+            });
+            saveEvidence(behaviorEvidence);
         }
     }
     catch (e) {
@@ -361,8 +377,15 @@ ${sanitizedSummary.slice(0, 4000)}
         const V1_PROFILE = path.join(V1_ME_DIR, 'forge-profile.json');
         const V1_EVIDENCE_DIR = path.join(V1_ME_DIR, 'behavior');
         if (fs.existsSync(V1_PROFILE)) {
+            const currentProfile = loadProfile();
+            let profileContext = '';
+            if (currentProfile) {
+                const qf = currentProfile.axes.quality_safety.facets;
+                const af = currentProfile.axes.autonomy.facets;
+                profileContext = `\n현재 프로필:\n- 팩: quality=${currentProfile.base_packs.quality_pack}, autonomy=${currentProfile.base_packs.autonomy_pack}\n- quality_safety facets: verification_depth=${qf.verification_depth.toFixed(2)}, stop_threshold=${qf.stop_threshold.toFixed(2)}, change_conservatism=${qf.change_conservatism.toFixed(2)}\n- autonomy facets: confirmation_independence=${af.confirmation_independence.toFixed(2)}, assumption_tolerance=${af.assumption_tolerance.toFixed(2)}, scope_expansion_tolerance=${af.scope_expansion_tolerance.toFixed(2)}, approval_threshold=${af.approval_threshold.toFixed(2)}\n`;
+            }
             const learningSummaryPrompt = `다음 Claude Code 세션 대화를 분석하여 사용자의 개인화 학습 요약을 JSON으로 출력해주세요.
-
+${profileContext}
 출력 형식 (JSON만, 설명 없이):
 {
   "corrections": ["사용자가 명시적으로 교정한 내용 목록"],
@@ -450,6 +473,16 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-auto-compound] session learning: ${e instanceof Error ? e.message : String(e)}\n`);
     }
+    // Step 4: prefer-from-now / avoid-this 교정 → scope:'me' 영구 규칙 승격
+    try {
+        const promotedCount = promoteSessionCandidates(sessionId);
+        if (promotedCount > 0) {
+            process.stderr.write(`[forgen-auto-compound] promoted ${promotedCount} correction(s) to permanent rules\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-auto-compound] rule promotion: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
     // 완료 기록
     const statePath = path.join(FORGEN_HOME, 'state', 'last-auto-compound.json');
     fs.mkdirSync(path.dirname(statePath), { recursive: true });

package/dist/core/doctor.js

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { FORGEN_HOME, LAB_DIR, ME_BEHAVIOR, ME_DIR, ME_PHILOSOPHY, ME_SOLUTIONS, ME_RULES, PACKS_DIR, SESSIONS_DIR } from './paths.js';
+import { FORGEN_HOME, LAB_DIR, ME_BEHAVIOR, ME_DIR, ME_PHILOSOPHY, ME_SOLUTIONS, ME_RULES, PACKS_DIR, SESSIONS_DIR, STATE_DIR } from './paths.js';
 /** ~/.claude/projects/ — Claude Code 세션 저장 경로 */
 const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 function check(label, condition, hint) {
@@ -149,6 +149,32 @@ export async function runDoctor() {
             console.log();
         }
     }
+    // 훅 에러 카운트
+    console.log('  [Hook Health]');
+    const hookErrorPath = path.join(STATE_DIR, 'hook-errors.json');
+    if (fs.existsSync(hookErrorPath)) {
+        try {
+            const errors = JSON.parse(fs.readFileSync(hookErrorPath, 'utf-8'));
+            const entries = Object.entries(errors);
+            if (entries.length === 0) {
+                console.log('  No hook errors recorded');
+            }
+            else {
+                for (const [hookName, { count, lastAt }] of entries) {
+                    const icon = count === 0 ? '✓' : '⚠';
+                    const lastDate = lastAt ? lastAt.split('T')[0] : 'unknown';
+                    console.log(`  ${icon} ${hookName}: ${count} error${count !== 1 ? 's' : ''}${count > 0 ? ` (last: ${lastDate})` : ''}`);
+                }
+            }
+        }
+        catch {
+            console.log('  (hook-errors.json read failed)');
+        }
+    }
+    else {
+        console.log('  No hook errors recorded');
+    }
+    console.log();
     // 현재 디렉토리 git 정보
     console.log('  [Git]');
     try {

package/dist/core/global-config.js

@@ -1,4 +1,5 @@
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { GLOBAL_CONFIG, V1_GLOBAL_CONFIG } from './paths.js';
 /** v1 config 로드 (~/.forgen/config.json 우선, 레거시 폴백) */
 export function loadGlobalConfig() {
@@ -20,6 +21,6 @@ export function loadGlobalConfig() {
 }
 /** v1 config 저장 (~/.forgen/config.json) */
 export function saveGlobalConfig(config) {
-    fs.mkdirSync(require('node:path').dirname(V1_GLOBAL_CONFIG), { recursive: true });
+    fs.mkdirSync(path.dirname(V1_GLOBAL_CONFIG), { recursive: true });
     fs.writeFileSync(V1_GLOBAL_CONFIG, JSON.stringify(config, null, 2));
 }

package/dist/core/inspect-cli.js

@@ -4,11 +4,15 @@
  * forgen inspect profile|rules|evidence|session
  * Authoritative: docs/plans/2026-04-03-forgen-rule-renderer-spec.md §6
  */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 import { loadProfile } from '../store/profile-store.js';
-import { loadAllRules } from '../store/rule-store.js';
+import { loadAllRules, loadActiveRules } from '../store/rule-store.js';
 import { loadRecentEvidence } from '../store/evidence-store.js';
 import { loadRecentSessions } from '../store/session-state-store.js';
 import * as inspect from '../renderer/inspect-renderer.js';
+import { ME_BEHAVIOR, ME_SOLUTIONS, STATE_DIR } from './paths.js';
+import { safeReadJSON } from '../hooks/shared/atomic-write.js';
 export async function handleInspect(args) {
     const sub = args[0];
     if (sub === 'profile') {
@@ -18,6 +22,55 @@ export async function handleInspect(args) {
             return;
         }
         console.log('\n' + inspect.renderProfile(profile) + '\n');
+        // ── Learning Loop Status ──
+        const activeRules = loadActiveRules();
+        const rulesByScope = {
+            me: activeRules.filter(r => r.scope === 'me').length,
+            session: activeRules.filter(r => r.scope === 'session').length,
+        };
+        const evidenceCount = (() => {
+            if (!fs.existsSync(ME_BEHAVIOR))
+                return 0;
+            return fs.readdirSync(ME_BEHAVIOR).filter(f => f.endsWith('.json')).length;
+        })();
+        const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+        const recentEvidence = loadRecentEvidence(100);
+        const recentCount = recentEvidence.filter(e => e.timestamp >= sevenDaysAgo).length;
+        const solutionCount = (() => {
+            if (!fs.existsSync(ME_SOLUTIONS))
+                return 0;
+            return fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md')).length;
+        })();
+        const lastExtractionData = safeReadJSON(path.join(STATE_DIR, 'last-extraction.json'), null);
+        const lastExtractionTs = lastExtractionData?.timestamp ?? lastExtractionData?.date;
+        const lastExtractionLabel = (() => {
+            if (!lastExtractionTs)
+                return 'never';
+            const d = new Date(lastExtractionTs);
+            const diffDays = Math.floor((Date.now() - d.getTime()) / (24 * 60 * 60 * 1000));
+            const dateStr = d.toISOString().slice(0, 10);
+            return diffDays === 0 ? `${dateStr} (today)` : `${dateStr} (${diffDays} day${diffDays > 1 ? 's' : ''} ago)`;
+        })();
+        console.log('── Learning Loop Status ──');
+        console.log(`Rules:      ${activeRules.length} active (${rulesByScope.me} me, ${rulesByScope.session} session)`);
+        console.log(`Evidence:   ${evidenceCount} corrections (last 7 days: ${recentCount})`);
+        console.log(`Compound:   ${solutionCount} solutions`);
+        console.log(`Last extraction: ${lastExtractionLabel}`);
+        console.log('');
+        // ── Recent Corrections ──
+        const corrections = recentEvidence
+            .filter(e => e.type === 'explicit_correction')
+            .slice(0, 3);
+        if (corrections.length > 0) {
+            console.log('── Recent Corrections ──');
+            for (const ev of corrections) {
+                const kind = ev.raw_payload?.kind;
+                const axis = ev.axis_refs[0] ?? 'general';
+                const dateStr = ev.timestamp.slice(0, 10);
+                console.log(`• [${axis}] ${ev.summary} (${kind ?? 'correction'}, ${dateStr})`);
+            }
+            console.log('');
+        }
         return;
     }
     if (sub === 'rules') {

package/dist/core/spawn.d.ts

@@ -1,3 +1,8 @@
 import type { V1HarnessContext } from './harness.js';
-/** Claude Code를 하네스 환경으로 실행 */
-export declare function spawnClaude(args: string[], context: V1HarnessContext): Promise<void>;
+/** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
+export declare function spawnClaude(args: string[], context: V1HarnessContext): Promise<number>;
+/**
+ * 토큰 한도 도달 시 자동 재시작을 지원하는 claude 실행 래퍼.
+ * context-guard가 pending-resume.json 마커를 생성하면 쿨다운 후 재시작.
+ */
+export declare function spawnClaudeWithResume(args: string[], context: V1HarnessContext, contextFactory: () => Promise<V1HarnessContext>): Promise<void>;

package/dist/core/spawn.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from 'node:url';
 import { buildEnv } from './config-injector.js';
 import { loadGlobalConfig } from './global-config.js';
 import { createLogger } from './logger.js';
+import { STATE_DIR } from './paths.js';
 const log = createLogger('spawn');
 /** claude CLI 경로 탐색 */
 function findClaude() {
@@ -58,7 +59,7 @@ async function indexTranscriptToFTS(cwd, transcriptPath, sessionId) {
         log.debug('FTS5 인덱싱 실패 (session-store 미구현 시 정상)', e);
     }
 }
-/** Claude Code를 하네스 환경으로 실행 */
+/** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
 export async function spawnClaude(args, context) {
     const claudePath = findClaude();
     const env = buildEnv(context.cwd);
@@ -124,12 +125,49 @@ export async function spawnClaude(args, context) {
             catch (e) {
                 console.error('[forgen] 세션 종료 후 처리 실패:', e instanceof Error ? e.message : e);
             }
-            if (code === 0 || code === null) {
-                resolve();
-            }
-            else {
-                process.exit(code);
-            }
+            resolve(code ?? 0);
         });
     });
 }
+const RESUME_COOLDOWN_MS = 30_000;
+const MAX_RESUMES = 3;
+/**
+ * 토큰 한도 도달 시 자동 재시작을 지원하는 claude 실행 래퍼.
+ * context-guard가 pending-resume.json 마커를 생성하면 쿨다운 후 재시작.
+ */
+export async function spawnClaudeWithResume(args, context, contextFactory) {
+    let resumeCount = 0;
+    let currentContext = context;
+    while (true) {
+        const exitCode = await spawnClaude(args, currentContext);
+        const resumePath = path.join(STATE_DIR, 'pending-resume.json');
+        if (!fs.existsSync(resumePath)) {
+            if (exitCode !== 0)
+                process.exit(exitCode);
+            break;
+        }
+        try {
+            const marker = JSON.parse(fs.readFileSync(resumePath, 'utf-8'));
+            fs.unlinkSync(resumePath);
+            if (marker.reason !== 'token-limit') {
+                if (exitCode !== 0)
+                    process.exit(exitCode);
+                break;
+            }
+            if (resumeCount >= MAX_RESUMES) {
+                console.log(`[forgen] 최대 자동 재시작 횟수(${MAX_RESUMES}) 도달. 수동으로 다시 시작하세요.`);
+                break;
+            }
+            resumeCount++;
+            console.log(`[forgen] 토큰 한도 도달. ${RESUME_COOLDOWN_MS / 1000}초 후 자동 재시작합니다... (${resumeCount}/${MAX_RESUMES})`);
+            await new Promise(resolve => setTimeout(resolve, RESUME_COOLDOWN_MS));
+            console.log('[forgen] 세션 재시작 중...');
+            currentContext = await contextFactory();
+        }
+        catch {
+            if (exitCode !== 0)
+                process.exit(exitCode);
+            break;
+        }
+    }
+}

package/dist/core/v1-bootstrap.js

@@ -13,12 +13,13 @@
  * 5. Rule Renderer가 자연어 규칙 세트 생성
  */
 import * as fs from 'node:fs';
+import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import { FORGEN_HOME, V1_ME_DIR, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_STATE_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR } from './paths.js';
 import { checkLegacyProfile, runLegacyCutover } from './legacy-detector.js';
 import { detectRuntimeCapability } from './runtime-detector.js';
 import { loadProfile, profileExists } from '../store/profile-store.js';
-import { loadActiveRules } from '../store/rule-store.js';
+import { loadActiveRules, cleanupStaleSessionRules } from '../store/rule-store.js';
 import { composeSession } from '../preset/preset-manager.js';
 import { renderRules, DEFAULT_CONTEXT } from '../renderer/rule-renderer.js';
 import { saveSessionState, loadRecentSessions } from '../store/session-state-store.js';
@@ -60,8 +61,15 @@ export function bootstrapV1Session() {
     // 3. Runtime capability 감지
     const runtime = detectRuntimeCapability();
     // 4. Rules 로드 + Session 합성
-    const personalRules = loadActiveRules();
     const sessionId = crypto.randomUUID();
+    // 이전 세션의 scope:'session' 임시 규칙 정리
+    try {
+        cleanupStaleSessionRules(sessionId);
+    }
+    catch {
+        // 정리 실패는 세션 시작을 막지 않음
+    }
+    const personalRules = loadActiveRules();
     const session = composeSession({
         session_id: sessionId,
         profile,
@@ -116,7 +124,7 @@ export function bootstrapV1Session() {
     // 8. Raw Log 기록 + TTL sweep (7일)
     try {
         // 세션 시작 로그
-        const rawLogPath = require('node:path').join(V1_RAW_LOGS_DIR, `${sessionId}.jsonl`);
+        const rawLogPath = path.join(V1_RAW_LOGS_DIR, `${sessionId}.jsonl`);
         fs.appendFileSync(rawLogPath, JSON.stringify({
             event: 'session-started',
             session_id: sessionId,
@@ -131,7 +139,7 @@ export function bootstrapV1Session() {
         const TTL_MS = 7 * 24 * 60 * 60 * 1000;
         const now = Date.now();
         for (const file of fs.readdirSync(V1_RAW_LOGS_DIR)) {
-            const filePath = require('node:path').join(V1_RAW_LOGS_DIR, file);
+            const filePath = path.join(V1_RAW_LOGS_DIR, file);
             try {
                 const stat = fs.statSync(filePath);
                 if (now - stat.mtimeMs > TTL_MS) {

package/dist/engine/compound-extractor.js

@@ -636,6 +636,41 @@ function updateReExtractedCounter(tags) {
         return;
     }
 }
+/**
+ * Optional LLM enrichment for thin solution content.
+ * Uses execFileSync (synchronous) to keep callers synchronous.
+ * Completely fail-open: any error returns null and the regex-extracted content is kept.
+ * Budget: max 2 calls per extraction run, 15s timeout each.
+ */
+function enrichSolutionContent(solution, diffSnippet) {
+    try {
+        const prompt = [
+            '다음 코드 변경에서 감지된 패턴을 2-3문장으로 설명해주세요.',
+            '무엇이 바뀌었는지가 아니라, **왜 이 패턴이 유용한지**와 **언제 적용해야 하는지**를 설명하세요.',
+            '',
+            `패턴 이름: ${solution.name}`,
+            `감지된 컨텍스트: ${solution.context}`,
+            `태그: ${solution.tags.join(', ')}`,
+            '',
+            '코드 변경 (일부):',
+            diffSnippet.slice(0, 2000),
+        ].join('\n');
+        const result = execFileSync('claude', ['-p', prompt, '--model', 'haiku'], {
+            timeout: 15000,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const enriched = result.trim();
+        if (enriched.length > 30 && enriched.length < 1000) {
+            return enriched;
+        }
+        return null;
+    }
+    catch {
+        // fail-open: LLM enrichment failure should never block extraction
+        return null;
+    }
+}
 /** Main extraction function — called from SessionStart or CLI */
 function analyzeExtraction(cwd, options) {
     const state = loadLastExtraction();
@@ -732,6 +767,7 @@ function analyzeExtraction(cwd, options) {
         extracted,
         stats,
         persistStateWithoutSaving: false,
+        gitDiff,
     };
 }
 function evaluateExtractedSolution(sol) {
@@ -784,6 +820,19 @@ export async function runExtraction(cwd, sessionId) {
         return { ...result, reason: analysis.reason };
     }
     if (analysis.extracted.length > 0) {
+        // Enrich thin solutions with LLM context — max 2 per run, fail-open
+        let enrichCount = 0;
+        for (const sol of analysis.extracted) {
+            if (enrichCount >= 2)
+                break;
+            if (sol.content.length < 100 && analysis.state.extractionsToday < MAX_EXTRACTIONS_PER_DAY) {
+                const enriched = enrichSolutionContent(sol, analysis.gitDiff ?? '');
+                if (enriched) {
+                    sol.content = enriched;
+                    enrichCount++;
+                }
+            }
+        }
         const { saved, skipped } = processExtractionResults(JSON.stringify(analysis.extracted), sessionId);
         result.extracted = saved;
         result.skipped = skipped;

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.js

@@ -71,6 +71,16 @@ export async function main() {
             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;
             }

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

@@ -28,14 +28,6 @@ export interface HookEntry {
     /** compound 피드백 루프에 필수인 훅인지 */
     compoundCritical: boolean;
 }
-/**
- * 단일 소스 오브 트루스: hooks/hook-registry.json
- *
- * 순서가 중요함:
- *   - pre-tool-use는 db-guard/rate-limiter보다 앞에 위치
- *     (Code Reflection + permission hints 주입 타이밍)
- *   - 같은 이벤트 내 훅은 배열 순서대로 실행됨
- */
 export declare const HOOK_REGISTRY: HookEntry[];
 /** 티어별 훅 목록 조회 */
 export declare function getHooksByTier(tier: HookTier): HookEntry[];

package/dist/hooks/hook-registry.js

@@ -20,7 +20,8 @@ const require = createRequire(import.meta.url);
  *     (Code Reflection + permission hints 주입 타이밍)
  *   - 같은 이벤트 내 훅은 배열 순서대로 실행됨
  */
-export const HOOK_REGISTRY = require('../../hooks/hook-registry.json');
+import registryData from '../../hooks/hook-registry.json' with { type: 'json' };
+export const HOOK_REGISTRY = registryData;
 /** 티어별 훅 목록 조회 */
 export function getHooksByTier(tier) {
     return HOOK_REGISTRY.filter(h => h.tier === tier);

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

@@ -10,3 +10,5 @@
  */
 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

@@ -38,6 +38,16 @@ 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')) {
@@ -48,13 +58,14 @@ async function main() {
         console.log(approve());
         return;
     }
-    const intent = classifyIntent(input.prompt);
-    if (intent === 'general') {
+    const intents = classifyAllIntents(input.prompt);
+    if (intents.length === 1 && intents[0] === 'general') {
         console.log(approve());
         return;
     }
-    const hint = INTENT_HINTS[intent];
-    console.log(approveWithContext(`[intent: ${intent}] ${hint}`, 'UserPromptSubmit'));
+    const label = intents.join('+');
+    const hint = INTENT_HINTS[intents[0]];
+    console.log(approveWithContext(`[intent: ${label}] ${hint}`, 'UserPromptSubmit'));
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);

package/dist/hooks/keyword-detector.js

@@ -65,8 +65,9 @@ export const KEYWORD_PATTERNS = [
     { pattern: /\b(debug[- ]?detective|디버그\s*탐정|체계적\s*디버깅)\b/i, keyword: 'debug-detective', type: 'skill', skill: 'debug-detective' },
     { pattern: /\b(refactor|리팩토링|리팩터)\s*(?:mode|모드|해|해줘|시작|실행|진행)/i, keyword: 'refactor', type: 'skill', skill: 'refactor' },
 ];
-// ── 인젝션 메시지 ──
-const INJECT_MESSAGES = {
+// ── 인젝션 메시지 (폴백 전용) ──
+// commands/*.md 파일이 없을 때만 사용. commands/*.md가 단일 진실 공급원.
+const FALLBACK_INJECT_MESSAGES = {
     ultrathink: `<compound-think-mode>
 EXTENDED THINKING MODE ACTIVATED.
 Before responding, engage in deep, thorough reasoning. Consider multiple approaches,
@@ -226,10 +227,11 @@ export function detectKeyword(prompt) {
                 return { type: 'cancel', keyword: entry.keyword, message: '[Forgen] Mode cancelled.' };
             }
             if (entry.type === 'inject') {
+                const fileContent = loadSkillContent(entry.keyword);
                 return {
                     type: 'inject',
                     keyword: entry.keyword,
-                    message: INJECT_MESSAGES[entry.keyword] ?? '',
+                    message: fileContent ?? FALLBACK_INJECT_MESSAGES[entry.keyword] ?? '',
                 };
             }
             return {

package/dist/hooks/pre-compact.js

@@ -68,6 +68,35 @@ function saveCompactionSnapshot(sessionId) {
     fs.writeFileSync(snapshotPath, lines.join('\n'));
     return snapshotPath;
 }
+/** context-guard.json에서 현재 promptCount 읽기 */
+function readPromptCount() {
+    try {
+        const guardPath = path.join(STATE_DIR, 'context-guard.json');
+        if (fs.existsSync(guardPath)) {
+            const data = JSON.parse(fs.readFileSync(guardPath, 'utf-8'));
+            return typeof data.promptCount === 'number' ? data.promptCount : 0;
+        }
+    }
+    catch { /* fail-open */ }
+    return 0;
+}
+/**
+ * 백그라운드 compound 추출 트리거 (non-blocking).
+ * compound extract 서브커맨드가 없으므로 pending-compound.json 마커를 씀.
+ * session-recovery가 다음 세션 시작 시 이 마커를 읽고 추출을 트리거함.
+ */
+function triggerBackgroundExtraction(promptCount) {
+    try {
+        const pendingPath = path.join(STATE_DIR, 'pending-compound.json');
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(pendingPath, JSON.stringify({
+            reason: 'pre-compact',
+            promptCount,
+            detectedAt: new Date().toISOString(),
+        }, null, 2));
+    }
+    catch { /* fail-open */ }
+}
 /** 7일 이상 된 handoff 파일 정리 */
 function cleanOldHandoffs() {
     if (!fs.existsSync(HANDOFFS_DIR))
@@ -146,6 +175,12 @@ Rules:
 - Skip patterns that are trivially obvious ("uses TypeScript")
 - Each pattern must be specific enough to change Claude's behavior in future sessions${existingList}
 </forgen-compound-extract>`;
+    // promptCount >= 20이면 백그라운드 추출 마커 기록
+    const promptCount = readPromptCount();
+    if (promptCount >= 20) {
+        triggerBackgroundExtraction(promptCount);
+        log.debug(`Pre-compact: promptCount=${promptCount} >= 20, pending-compound.json 기록`);
+    }
     // 스냅샷 저장
     try {
         const snapshotPath = saveCompactionSnapshot(sessionId);

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;
+/** 훅별 에러 카운트를 STATE_DIR/hook-errors.json에 누적 */
+export declare function incrementHookErrorCount(hookName: string): void;
+/**
+ * fail-open + 에러 카운트 누적.
+ * 훅의 main().catch() 블록에서 명시적으로 호출.
+ */
+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 path from 'node:path';
+import { STATE_DIR } from '../../core/paths.js';
 /** 통과 응답 (컨텍스트 없음, 모든 이벤트 공통) */
 export function approve() {
     return JSON.stringify({ continue: true });
@@ -60,3 +63,31 @@ export function ask(reason) {
 export function failOpen() {
     return JSON.stringify({ continue: true });
 }
+/** 훅별 에러 카운트를 STATE_DIR/hook-errors.json에 누적 */
+export function incrementHookErrorCount(hookName) {
+    try {
+        const errorPath = path.join(STATE_DIR, 'hook-errors.json');
+        let errors = {};
+        try {
+            if (fs.existsSync(errorPath)) {
+                errors = JSON.parse(fs.readFileSync(errorPath, 'utf-8'));
+            }
+        }
+        catch { /* start fresh */ }
+        if (!errors[hookName])
+            errors[hookName] = { count: 0, lastAt: '' };
+        errors[hookName].count++;
+        errors[hookName].lastAt = new Date().toISOString();
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(errorPath, JSON.stringify(errors, null, 2));
+    }
+    catch { /* meta-error in error tracking — ignore */ }
+}
+/**
+ * fail-open + 에러 카운트 누적.
+ * 훅의 main().catch() 블록에서 명시적으로 호출.
+ */
+export function failOpenWithTracking(hookName) {
+    incrementHookErrorCount(hookName);
+    return JSON.stringify({ continue: true });
+}

package/dist/i18n/index.js

@@ -4,6 +4,9 @@
  * 내부 타입은 한글 유지 (QualityPack = '보수형' | ...).
  * 사용자 대면 출력만 로케일에 따라 전환.
  */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 // ── Pack Display Names ──
 const QUALITY_NAMES = {
     ko: { '보수형': '보수형', '균형형': '균형형', '속도형': '속도형' },
@@ -212,8 +215,10 @@ export function getLocale() { return _currentLocale; }
 /** GlobalConfig에서 locale을 읽어 설정. 없으면 'en' 기본값. */
 export function initLocaleFromConfig() {
     try {
-        const { loadGlobalConfig } = require('../core/global-config.js');
-        const config = loadGlobalConfig();
+        const configPath = path.join(os.homedir(), '.forgen', 'config.json');
+        if (!fs.existsSync(configPath))
+            return;
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
         if (config.locale === 'ko' || config.locale === 'en') {
             _currentLocale = config.locale;
         }

package/dist/mcp/tools.js

@@ -15,6 +15,8 @@
 import { z } from 'zod';
 import { searchSolutions, listSolutions, readSolution, getSolutionStats, defaultSolutionDirs, } from './solution-reader.js';
 import { processCorrection } from '../forge/evidence-processor.js';
+import { loadProfile } from '../store/profile-store.js';
+import { loadActiveRules } from '../store/rule-store.js';
 function getCwd() {
     return process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? undefined;
 }
@@ -299,4 +301,116 @@ export function registerTools(server) {
             };
         }
     });
+    // ── profile-read ──
+    server.registerTool('profile-read', {
+        description: 'Read current user personalization profile — packs, facet scores, trust policy. Use this to understand how you are configured before suggesting profile changes.',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const profile = loadProfile();
+        if (!profile) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No profile configured. Run forgen onboarding.',
+                    }],
+            };
+        }
+        const { base_packs, axes, trust_preferences, metadata } = profile;
+        const lines = [
+            `# Forgen Profile (user: ${profile.user_id})`,
+            '',
+            '## Packs',
+            `  quality:       ${base_packs.quality_pack}`,
+            `  autonomy:      ${base_packs.autonomy_pack}`,
+            `  judgment:      ${base_packs.judgment_pack}`,
+            `  communication: ${base_packs.communication_pack}`,
+            '',
+            '## Facets',
+            '  quality_safety:',
+            `    verification_depth:  ${axes.quality_safety.facets.verification_depth.toFixed(2)}`,
+            `    stop_threshold:      ${axes.quality_safety.facets.stop_threshold.toFixed(2)}`,
+            `    change_conservatism: ${axes.quality_safety.facets.change_conservatism.toFixed(2)}`,
+            `    (score: ${axes.quality_safety.score.toFixed(2)}, confidence: ${axes.quality_safety.confidence.toFixed(2)})`,
+            '  autonomy:',
+            `    confirmation_independence:   ${axes.autonomy.facets.confirmation_independence.toFixed(2)}`,
+            `    assumption_tolerance:        ${axes.autonomy.facets.assumption_tolerance.toFixed(2)}`,
+            `    scope_expansion_tolerance:   ${axes.autonomy.facets.scope_expansion_tolerance.toFixed(2)}`,
+            `    approval_threshold:          ${axes.autonomy.facets.approval_threshold.toFixed(2)}`,
+            `    (score: ${axes.autonomy.score.toFixed(2)}, confidence: ${axes.autonomy.confidence.toFixed(2)})`,
+            '  judgment_philosophy:',
+            `    minimal_change_bias:  ${axes.judgment_philosophy.facets.minimal_change_bias.toFixed(2)}`,
+            `    abstraction_bias:     ${axes.judgment_philosophy.facets.abstraction_bias.toFixed(2)}`,
+            `    evidence_first_bias:  ${axes.judgment_philosophy.facets.evidence_first_bias.toFixed(2)}`,
+            `    (score: ${axes.judgment_philosophy.score.toFixed(2)}, confidence: ${axes.judgment_philosophy.confidence.toFixed(2)})`,
+            '  communication_style:',
+            `    verbosity:      ${axes.communication_style.facets.verbosity.toFixed(2)}`,
+            `    structure:      ${axes.communication_style.facets.structure.toFixed(2)}`,
+            `    teaching_bias:  ${axes.communication_style.facets.teaching_bias.toFixed(2)}`,
+            `    (score: ${axes.communication_style.score.toFixed(2)}, confidence: ${axes.communication_style.confidence.toFixed(2)})`,
+            '',
+            '## Trust Policy',
+            `  ${trust_preferences.desired_policy} (source: ${trust_preferences.source})`,
+            '',
+            '## Metadata',
+            `  created:      ${metadata.created_at.slice(0, 10)}`,
+            `  last_updated: ${metadata.updated_at.slice(0, 10)}`,
+        ];
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n'),
+                }],
+        };
+    });
+    // ── rule-list ──
+    server.registerTool('rule-list', {
+        description: 'List active personalization rules grouped by category. Shows scope, strength, and source of each rule.',
+        inputSchema: {
+            category: z.enum(['quality', 'autonomy', 'workflow', 'all']).optional()
+                .describe('Filter by rule category (default: all)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ category }) => {
+        const rules = loadActiveRules();
+        if (rules.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No active rules found.',
+                    }],
+            };
+        }
+        const filtered = (category && category !== 'all')
+            ? rules.filter(r => r.category === category)
+            : rules;
+        if (filtered.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `No active rules found for category: ${category}.`,
+                    }],
+            };
+        }
+        // Group by category
+        const grouped = new Map();
+        for (const rule of filtered) {
+            const group = grouped.get(rule.category) ?? [];
+            group.push(rule);
+            grouped.set(rule.category, group);
+        }
+        const lines = [`Active rules (${filtered.length} total):`];
+        for (const [cat, catRules] of grouped) {
+            lines.push('', `## ${cat}`);
+            for (const rule of catRules) {
+                const refs = rule.evidence_refs.length > 0 ? ` (source: ${rule.evidence_refs.join(', ')})` : '';
+                lines.push(`  [${rule.scope}] [${rule.strength}] ${rule.policy}${refs}`);
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n'),
+                }],
+        };
+    });
 }

package/dist/store/evidence-store.d.ts

@@ -21,3 +21,11 @@ export declare function loadAllEvidence(): Evidence[];
 export declare function loadEvidenceBySession(sessionId: string): Evidence[];
 export declare function loadEvidenceByType(type: EvidenceType): Evidence[];
 export declare function loadRecentEvidence(limit?: number): Evidence[];
+/** prefer-from-now / avoid-this 교정 evidence를 모두 반환 (규칙 승격 후보) */
+export declare function loadPromotionCandidates(): Evidence[];
+/**
+ * 특정 세션의 promotion 후보를 scope:'me' 영구 규칙으로 승격.
+ * 동일 render_key를 가진 scope:'me' 규칙이 이미 있으면 건너뜀.
+ * @returns 승격된 규칙 수
+ */
+export declare function promoteSessionCandidates(sessionId: string): number;

package/dist/store/evidence-store.js

@@ -9,6 +9,7 @@ import * as path from 'node:path';
 import * as crypto from 'node:crypto';
 import { V1_EVIDENCE_DIR } from '../core/paths.js';
 import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+import { createRule, saveRule, loadActiveRules } from './rule-store.js';
 function evidencePath(evidenceId) {
     return path.join(V1_EVIDENCE_DIR, `${evidenceId}.json`);
 }
@@ -56,3 +57,53 @@ export function loadRecentEvidence(limit = 20) {
         .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
         .slice(0, limit);
 }
+/** prefer-from-now / avoid-this 교정 evidence를 모두 반환 (규칙 승격 후보) */
+export function loadPromotionCandidates() {
+    return loadAllEvidence().filter(e => {
+        if (e.type !== 'explicit_correction')
+            return false;
+        const kind = e.raw_payload?.kind;
+        return kind === 'prefer-from-now' || kind === 'avoid-this';
+    });
+}
+/**
+ * 특정 세션의 promotion 후보를 scope:'me' 영구 규칙으로 승격.
+ * 동일 render_key를 가진 scope:'me' 규칙이 이미 있으면 건너뜀.
+ * @returns 승격된 규칙 수
+ */
+export function promoteSessionCandidates(sessionId) {
+    const candidates = loadPromotionCandidates().filter(e => e.session_id === sessionId);
+    if (candidates.length === 0)
+        return 0;
+    const activeRules = loadActiveRules();
+    const existingRenderKeys = new Set(activeRules.filter(r => r.scope === 'me').map(r => r.render_key));
+    let promoted = 0;
+    for (const candidate of candidates) {
+        const payload = candidate.raw_payload;
+        const axisHint = payload?.axis_hint;
+        const target = payload?.target;
+        const kind = payload?.kind;
+        if (!target)
+            continue;
+        const renderKey = `${axisHint ?? 'workflow'}.${target.toLowerCase().replace(/\s+/g, '-').slice(0, 30)}`;
+        if (existingRenderKeys.has(renderKey))
+            continue;
+        const category = axisHint === 'quality_safety' ? 'quality'
+            : axisHint === 'autonomy' ? 'autonomy'
+                : 'workflow';
+        const rule = createRule({
+            category,
+            scope: 'me',
+            trigger: target,
+            policy: candidate.summary,
+            strength: kind === 'avoid-this' ? 'strong' : 'default',
+            source: 'explicit_correction',
+            evidence_refs: [candidate.evidence_id],
+            render_key: renderKey,
+        });
+        saveRule(rule);
+        existingRenderKeys.add(renderKey);
+        promoted++;
+    }
+    return promoted;
+}

package/dist/store/rule-store.d.ts

@@ -20,3 +20,8 @@ export declare function loadRule(ruleId: string): Rule | null;
 export declare function loadAllRules(): Rule[];
 export declare function loadActiveRules(): Rule[];
 export declare function updateRuleStatus(ruleId: string, status: RuleStatus): boolean;
+/**
+ * 현재 세션 ID와 다른 scope:'session' 규칙을 비활성화.
+ * 이전 세션의 임시 규칙이 새 세션에서 영향을 미치지 않도록 정리.
+ */
+export declare function cleanupStaleSessionRules(_currentSessionId: string): number;

package/dist/store/rule-store.js

@@ -60,3 +60,25 @@ export function updateRuleStatus(ruleId, status) {
     saveRule(rule);
     return true;
 }
+/**
+ * 현재 세션 ID와 다른 scope:'session' 규칙을 비활성화.
+ * 이전 세션의 임시 규칙이 새 세션에서 영향을 미치지 않도록 정리.
+ */
+export function cleanupStaleSessionRules(_currentSessionId) {
+    if (!fs.existsSync(V1_RULES_DIR))
+        return 0;
+    let cleaned = 0;
+    for (const file of fs.readdirSync(V1_RULES_DIR)) {
+        if (!file.endsWith('.json'))
+            continue;
+        const filePath = path.join(V1_RULES_DIR, file);
+        const rule = safeReadJSON(filePath, null);
+        if (rule && rule.scope === 'session' && rule.status === 'active') {
+            rule.status = 'suppressed';
+            rule.updated_at = new Date().toISOString();
+            atomicWriteJSON(filePath, rule, { pretty: true });
+            cleaned++;
+        }
+    }
+    return cleaned;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",
   "exports": {