@wooojin/forgen 0.2.0 → 0.2.1

package/dist/core/dashboard.js

@@ -0,0 +1,385 @@
+/**
+ * Forgen — Compound Dashboard
+ *
+ * Provides a rich terminal overview of the compound knowledge system:
+ * knowledge inventory, injection activity, lifecycle transitions,
+ * session history, and hook health.
+ *
+ * Data is collected from:
+ *   - ME_SOLUTIONS, ME_RULES, ME_BEHAVIOR (knowledge files)
+ *   - MATCH_EVAL_LOG_PATH (injection/matching decisions)
+ *   - STATE_DIR (hook-errors.json, last-extraction.json)
+ *   - Solution frontmatter (lifecycle evidence fields)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS, ME_RULES, ME_BEHAVIOR, STATE_DIR, } from './paths.js';
+import { parseFrontmatterOnly } from '../engine/solution-format.js';
+import { readMatchEvalLog } from '../engine/match-eval-log.js';
+// ── ANSI color helpers ──
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+const RESET = '\x1b[0m';
+function bold(s) { return `${BOLD}${s}${RESET}`; }
+function green(s) { return `${GREEN}${s}${RESET}`; }
+function yellow(s) { return `${YELLOW}${s}${RESET}`; }
+function red(s) { return `${RED}${s}${RESET}`; }
+function dim(s) { return `${DIM}${s}${RESET}`; }
+function cyan(s) { return `${CYAN}${s}${RESET}`; }
+// ── Box-drawing table helpers ──
+function tableRow(cols, widths) {
+    return '  │ ' + cols.map((c, i) => c.padEnd(widths[i])).join(' │ ') + ' │';
+}
+function tableSep(widths, top = false, bottom = false) {
+    const left = top ? '┌' : bottom ? '└' : '├';
+    const mid = top ? '┬' : bottom ? '┴' : '┼';
+    const right = top ? '┐' : bottom ? '┘' : '┤';
+    return '  ' + left + widths.map(w => '─'.repeat(w + 2)).join(mid) + right;
+}
+// ── Data Collection Functions ──
+/** Read all .md files in a directory and return their frontmatter. */
+function readFrontmatters(dir) {
+    const results = [];
+    try {
+        if (!fs.existsSync(dir))
+            return results;
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(dir, file), 'utf-8');
+                const fm = parseFrontmatterOnly(content);
+                if (fm)
+                    results.push(fm);
+            }
+            catch { /* skip unreadable files */ }
+        }
+    }
+    catch { /* skip unreadable directories */ }
+    return results;
+}
+/** Count files in a directory (non-recursive). */
+function countDirFiles(dir, ext) {
+    try {
+        if (!fs.existsSync(dir))
+            return 0;
+        const files = fs.readdirSync(dir);
+        return ext ? files.filter(f => f.endsWith(ext)).length : files.length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Collect knowledge overview data. */
+export function collectKnowledgeOverview() {
+    const solutionFms = readFrontmatters(ME_SOLUTIONS);
+    const ruleFms = readFrontmatters(ME_RULES);
+    const byStatus = {
+        experiment: 0, candidate: 0, verified: 0, mature: 0, retired: 0,
+    };
+    for (const fm of solutionFms) {
+        if (fm.status in byStatus)
+            byStatus[fm.status]++;
+    }
+    // Rules categorized by type
+    const ruleCategories = {};
+    for (const fm of ruleFms) {
+        const key = fm.type ?? 'unknown';
+        ruleCategories[key] = (ruleCategories[key] ?? 0) + 1;
+    }
+    // Behavior file count
+    const behaviorCount = countDirFiles(ME_BEHAVIOR, '.md') + countDirFiles(ME_BEHAVIOR, '.json');
+    // Date range across all frontmatters
+    const allFms = [...solutionFms, ...ruleFms];
+    let oldest = null;
+    let newest = null;
+    for (const fm of allFms) {
+        if (!oldest || fm.created < oldest)
+            oldest = fm.created;
+        if (!newest || fm.updated > newest)
+            newest = fm.updated;
+    }
+    return {
+        solutions: { total: solutionFms.length, byStatus },
+        rules: { total: ruleFms.length, categories: ruleCategories },
+        behavior: { total: behaviorCount },
+        dateRange: { oldest, newest },
+    };
+}
+/** Collect injection activity from match-eval-log. */
+export function collectInjectionActivity() {
+    const records = readMatchEvalLog();
+    // Recent injections (last 10)
+    const sorted = [...records].sort((a, b) => b.ts.localeCompare(a.ts));
+    const recentInjections = sorted.slice(0, 10).flatMap(r => r.rankedTopN.map(name => ({ name, ts: r.ts, source: r.source }))).slice(0, 10);
+    // Top 5 most frequently injected solutions
+    const freq = new Map();
+    for (const r of records) {
+        for (const name of r.rankedTopN) {
+            freq.set(name, (freq.get(name) ?? 0) + 1);
+        }
+    }
+    const topSolutions = [...freq.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([name, count]) => ({ name, count }));
+    const hookCount = records.filter(r => r.source === 'hook').length;
+    const mcpCount = records.filter(r => r.source === 'mcp').length;
+    return {
+        totalRecords: records.length,
+        recentInjections,
+        topSolutions,
+        hookCount,
+        mcpCount,
+    };
+}
+/** Collect code reflection data from solution evidence. */
+export function collectReflectionData() {
+    const fms = readFrontmatters(ME_SOLUTIONS);
+    const reflected = fms.filter(fm => fm.evidence.reflected > 0).length;
+    const unreflected = fms.filter(fm => fm.evidence.reflected === 0 && fm.status !== 'retired').length;
+    const activeFms = fms.filter(fm => fm.status !== 'retired');
+    const rate = activeFms.length > 0 ? (reflected / activeFms.length) * 100 : 0;
+    return {
+        totalSolutions: fms.length,
+        reflectedCount: reflected,
+        unreflectedCount: unreflected,
+        reflectionRate: rate,
+    };
+}
+/** Collect lifecycle activity data. */
+export function collectLifecycleActivity() {
+    const fms = readFrontmatters(ME_SOLUTIONS);
+    const statusDistribution = {
+        experiment: 0, candidate: 0, verified: 0, mature: 0, retired: 0,
+    };
+    for (const fm of fms) {
+        if (fm.status in statusDistribution)
+            statusDistribution[fm.status]++;
+    }
+    // Solutions approaching promotion (high evidence, not yet promoted)
+    const candidates = fms
+        .filter(fm => fm.status !== 'retired' && fm.status !== 'mature')
+        .map(fm => ({
+        name: fm.name,
+        status: fm.status,
+        evidence: {
+            reflected: fm.evidence.reflected,
+            sessions: fm.evidence.sessions,
+            negative: fm.evidence.negative,
+        },
+    }))
+        .sort((a, b) => b.evidence.reflected - a.evidence.reflected)
+        .slice(0, 5);
+    return { recentPromotionCandidates: candidates, statusDistribution };
+}
+/** Collect session extraction history. */
+export function collectSessionHistory() {
+    const lastExtractionPath = path.join(STATE_DIR, 'last-extraction.json');
+    try {
+        if (fs.existsSync(lastExtractionPath)) {
+            const data = JSON.parse(fs.readFileSync(lastExtractionPath, 'utf-8'));
+            return {
+                lastExtraction: {
+                    date: data.lastExtractedAt ?? 'unknown',
+                    extractionsToday: data.extractionsToday ?? 0,
+                },
+            };
+        }
+    }
+    catch { /* skip */ }
+    return { lastExtraction: null };
+}
+/** Collect hook error data. */
+export function collectHookHealth() {
+    const errorPath = path.join(STATE_DIR, 'hook-errors.json');
+    try {
+        if (fs.existsSync(errorPath)) {
+            const data = JSON.parse(fs.readFileSync(errorPath, 'utf-8'));
+            const errors = Object.entries(data).map(([hookName, info]) => ({
+                hookName,
+                count: info.count,
+                lastAt: info.lastAt,
+            }));
+            return { errors };
+        }
+    }
+    catch { /* skip */ }
+    return { errors: [] };
+}
+// ── Rendering ──
+function renderKnowledgeOverview(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Knowledge Overview'))}`);
+    lines.push('');
+    // Solutions table
+    const statusWidths = [14, 6];
+    lines.push(tableSep(statusWidths, true));
+    lines.push(tableRow(['Status', 'Count'], statusWidths));
+    lines.push(tableSep(statusWidths));
+    for (const [status, count] of Object.entries(data.solutions.byStatus)) {
+        if (count === 0 && status === 'retired')
+            continue;
+        const colorFn = status === 'mature' ? green
+            : status === 'verified' ? green
+                : status === 'experiment' ? yellow
+                    : status === 'retired' ? red
+                        : (s) => s;
+        lines.push(tableRow([colorFn(status), String(count)], statusWidths));
+    }
+    lines.push(tableSep(statusWidths, false, true));
+    lines.push(`  Solutions: ${bold(String(data.solutions.total))}  Rules: ${bold(String(data.rules.total))}  Behavior: ${bold(String(data.behavior.total))}`);
+    if (data.dateRange.oldest && data.dateRange.newest) {
+        lines.push(`  Date range: ${dim(data.dateRange.oldest)} → ${dim(data.dateRange.newest)}`);
+    }
+    return lines.join('\n');
+}
+function renderInjectionActivity(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Injection Activity'))}`);
+    lines.push('');
+    if (data.totalRecords === 0) {
+        lines.push(`  ${dim('No injection records found.')}`);
+        return lines.join('\n');
+    }
+    lines.push(`  Total decisions: ${bold(String(data.totalRecords))}  (hook: ${data.hookCount}, mcp: ${data.mcpCount})`);
+    lines.push('');
+    if (data.topSolutions.length > 0) {
+        lines.push(`  ${bold('Top injected solutions:')}`);
+        for (const s of data.topSolutions) {
+            const bar = '█'.repeat(Math.min(s.count, 30));
+            lines.push(`    ${s.name.padEnd(35)} ${green(bar)} ${s.count}`);
+        }
+    }
+    if (data.recentInjections.length > 0) {
+        lines.push('');
+        lines.push(`  ${bold('Recent injections:')}`);
+        for (const inj of data.recentInjections.slice(0, 5)) {
+            const date = inj.ts.slice(0, 16).replace('T', ' ');
+            lines.push(`    ${dim(date)} [${inj.source}] ${inj.name}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderReflectionData(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Code Reflection'))}`);
+    lines.push('');
+    if (data.totalSolutions === 0) {
+        lines.push(`  ${dim('No solutions to analyze.')}`);
+        return lines.join('\n');
+    }
+    const rateColor = data.reflectionRate >= 50 ? green
+        : data.reflectionRate >= 20 ? yellow
+            : red;
+    lines.push(`  Reflection rate: ${rateColor(`${data.reflectionRate.toFixed(1)}%`)}`);
+    lines.push(`  Reflected in code: ${green(String(data.reflectedCount))}  Not reflected: ${data.unreflectedCount > 0 ? yellow(String(data.unreflectedCount)) : String(data.unreflectedCount)}`);
+    return lines.join('\n');
+}
+function renderLifecycleActivity(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Lifecycle Activity'))}`);
+    lines.push('');
+    // Status distribution bar
+    const total = Object.values(data.statusDistribution).reduce((a, b) => a + b, 0);
+    if (total > 0) {
+        const barWidth = 30;
+        const segments = [];
+        for (const [status, count] of Object.entries(data.statusDistribution)) {
+            if (count === 0)
+                continue;
+            const width = Math.max(1, Math.round((count / total) * barWidth));
+            const char = status === 'mature' ? `${GREEN}${'█'.repeat(width)}${RESET}`
+                : status === 'verified' ? `${GREEN}${'▓'.repeat(width)}${RESET}`
+                    : status === 'candidate' ? `${CYAN}${'▒'.repeat(width)}${RESET}`
+                        : status === 'experiment' ? `${YELLOW}${'░'.repeat(width)}${RESET}`
+                            : `${RED}${'·'.repeat(width)}${RESET}`;
+            segments.push(char);
+        }
+        lines.push(`  ${segments.join('')}`);
+        lines.push(`  ${dim('█ mature  ▓ verified  ▒ candidate  ░ experiment  · retired')}`);
+    }
+    if (data.recentPromotionCandidates.length > 0) {
+        lines.push('');
+        lines.push(`  ${bold('Approaching promotion:')}`);
+        for (const c of data.recentPromotionCandidates) {
+            const ev = c.evidence;
+            const negStr = ev.negative > 0 ? red(` neg:${ev.negative}`) : '';
+            lines.push(`    ${c.name.padEnd(35)} [${c.status}] ref:${ev.reflected} sess:${ev.sessions}${negStr}`);
+        }
+    }
+    return lines.join('\n');
+}
+function renderSessionHistory(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Session History'))}`);
+    lines.push('');
+    if (!data.lastExtraction) {
+        lines.push(`  ${dim('No extraction history found.')}`);
+        return lines.join('\n');
+    }
+    const ext = data.lastExtraction;
+    lines.push(`  Last extraction: ${dim(ext.date)}`);
+    lines.push(`  Extractions today: ${bold(String(ext.extractionsToday))}`);
+    return lines.join('\n');
+}
+function renderHookHealth(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Hook Health'))}`);
+    lines.push('');
+    if (data.errors.length === 0) {
+        lines.push(`  ${green('All hooks healthy — no errors recorded.')}`);
+        return lines.join('\n');
+    }
+    const widths = [25, 6, 20];
+    lines.push(tableSep(widths, true));
+    lines.push(tableRow(['Hook', 'Errors', 'Last Error'], widths));
+    lines.push(tableSep(widths));
+    for (const err of data.errors.sort((a, b) => b.count - a.count)) {
+        const lastDate = err.lastAt.slice(0, 16).replace('T', ' ');
+        lines.push(tableRow([
+            err.hookName,
+            red(String(err.count)),
+            dim(lastDate),
+        ], widths));
+    }
+    lines.push(tableSep(widths, false, true));
+    return lines.join('\n');
+}
+// ── Main Dashboard Renderer ──
+export function renderDashboard() {
+    const knowledge = collectKnowledgeOverview();
+    const injection = collectInjectionActivity();
+    const reflection = collectReflectionData();
+    const lifecycle = collectLifecycleActivity();
+    const session = collectSessionHistory();
+    const hookHealth = collectHookHealth();
+    const divider = `  ${dim('─'.repeat(50))}`;
+    const sections = [
+        '',
+        `  ${BOLD}${CYAN}╔══════════════════════════════════════════════╗${RESET}`,
+        `  ${BOLD}${CYAN}║         Forgen Compound Dashboard            ║${RESET}`,
+        `  ${BOLD}${CYAN}╚══════════════════════════════════════════════╝${RESET}`,
+        '',
+        renderKnowledgeOverview(knowledge),
+        divider,
+        renderInjectionActivity(injection),
+        divider,
+        renderReflectionData(reflection),
+        divider,
+        renderLifecycleActivity(lifecycle),
+        divider,
+        renderSessionHistory(session),
+        divider,
+        renderHookHealth(hookHealth),
+        '',
+    ];
+    return sections.join('\n');
+}
+/** CLI handler: forgen dashboard */
+export async function handleDashboard() {
+    console.log(renderDashboard());
+}

package/dist/core/doctor.js

@@ -2,7 +2,8 @@ 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, STATE_DIR } from './paths.js';
+import { FORGEN_HOME, LAB_DIR, ME_BEHAVIOR, ME_DIR, ME_PHILOSOPHY, ME_SOLUTIONS, ME_RULES, ME_SKILLS, PACKS_DIR, SESSIONS_DIR, STATE_DIR } from './paths.js';
+import { getTimingStats } from '../hooks/shared/hook-timing.js';
 /** ~/.claude/projects/ — Claude Code 세션 저장 경로 */
 const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 function check(label, condition, hint) {
@@ -104,6 +105,60 @@ export async function runDoctor() {
     }
     console.log(`  Claude Code sessions: ${CLAUDE_PROJECTS_DIR}`);
     console.log();
+    // Hook Health: recent error tracking
+    console.log('  [Hook Health]');
+    try {
+        const hookErrorsPath = path.join(STATE_DIR, 'hook-errors.jsonl');
+        if (exists(hookErrorsPath)) {
+            const content = fs.readFileSync(hookErrorsPath, 'utf-8');
+            const entries = content.trim().split('\n')
+                .map(line => { try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            } })
+                .filter(Boolean);
+            const byHook = new Map();
+            for (const e of entries) {
+                byHook.set(e.hook, (byHook.get(e.hook) ?? 0) + 1);
+            }
+            if (byHook.size === 0) {
+                console.log('  No hook errors recorded.');
+            }
+            else {
+                for (const [hook, count] of [...byHook.entries()].sort((a, b) => b[1] - a[1])) {
+                    console.log(`  ${hook}: ${count} error(s)`);
+                }
+            }
+        }
+        else {
+            console.log('  No hook errors recorded.');
+        }
+    }
+    catch {
+        console.log('  Unable to read hook error log.');
+    }
+    console.log();
+    // Hook Timing: performance stats
+    console.log('  [Hook Timing]');
+    const timingStats = getTimingStats();
+    if (timingStats.length === 0) {
+        console.log('  No timing data collected yet.');
+    }
+    else {
+        console.log('  Hook                  Count   p50ms   p95ms   max ms');
+        console.log('  ' + '-'.repeat(56));
+        for (const s of timingStats) {
+            const hook = s.hook.padEnd(22);
+            const count = String(s.count).padStart(5);
+            const p50 = String(s.p50).padStart(7);
+            const p95 = String(s.p95).padStart(7);
+            const max = String(s.max).padStart(8);
+            console.log(`  ${hook}${count}${p50}${p95}${max}`);
+        }
+    }
+    console.log();
     console.log();
     // v1: 팀 팩 시스템 제거. 개인 모드만 지원.
     console.log('  [Pack Connections]');
@@ -149,32 +204,107 @@ 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})` : ''}`);
+    // Harness Maturity section
+    console.log('  [Harness Maturity]');
+    const cwd = process.cwd();
+    // 1. Preparation
+    const hasClaude = fs.existsSync(path.join(cwd, 'CLAUDE.md'));
+    let rulesCount = 0;
+    try {
+        const rulesDir = path.join(cwd, '.claude', 'rules');
+        if (fs.existsSync(rulesDir)) {
+            rulesCount = fs.readdirSync(rulesDir).filter(f => f.endsWith('.md')).length;
+        }
+    }
+    catch { /* fail-open */ }
+    let hooksActive = 0;
+    try {
+        const hooksJsonPath = path.join(cwd, 'hooks', 'hooks.json');
+        if (fs.existsSync(hooksJsonPath)) {
+            const hooksData = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf-8'));
+            if (hooksData.hooks && typeof hooksData.hooks === 'object') {
+                for (const eventHooks of Object.values(hooksData.hooks)) {
+                    if (Array.isArray(eventHooks)) {
+                        for (const group of eventHooks) {
+                            if (Array.isArray(group.hooks)) {
+                                hooksActive += (group.hooks).length;
+                            }
+                        }
+                    }
                 }
             }
         }
-        catch {
-            console.log('  (hook-errors.json read failed)');
-        }
     }
-    else {
-        console.log('  No hook errors recorded');
+    catch { /* fail-open */ }
+    const prepL = hasClaude && rulesCount >= 3 && hooksActive > 0 ? 'L3' : hasClaude && hooksActive > 0 ? 'L2' : hasClaude ? 'L1' : 'L0';
+    // 2. Context
+    let solutionsCount = 0;
+    try {
+        if (exists(ME_SOLUTIONS))
+            solutionsCount = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md')).length;
+    }
+    catch { /* fail-open */ }
+    let behaviorCount = 0;
+    try {
+        if (exists(ME_BEHAVIOR))
+            behaviorCount = fs.readdirSync(ME_BEHAVIOR).filter(f => f.endsWith('.md')).length;
     }
+    catch { /* fail-open */ }
+    const ctxL = solutionsCount >= 5 && behaviorCount >= 3 ? 'L3' : solutionsCount >= 3 || behaviorCount >= 1 ? 'L2' : solutionsCount > 0 || behaviorCount > 0 ? 'L1' : 'L0';
+    // 3. Execution
+    const hasSkills = exists(ME_SKILLS);
+    const execL = hasSkills ? 'L2' : 'L1';
+    // 4. Validation
+    const hasTests = fs.existsSync(path.join(cwd, 'tests'));
+    const hasCI = fs.existsSync(path.join(cwd, '.github', 'workflows'));
+    const validL = hasTests && hasCI ? 'L3' : hasTests ? 'L2' : 'L1';
+    // 5. Improvement: reflection rate from solutions
+    let reflectionRate = 0;
+    try {
+        if (exists(ME_SOLUTIONS)) {
+            const solFiles = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+            if (solFiles.length > 0) {
+                let reflected = 0;
+                for (const f of solFiles) {
+                    try {
+                        const content = fs.readFileSync(path.join(ME_SOLUTIONS, f), 'utf-8');
+                        const match = content.match(/reflected:\s*(\d+)/);
+                        if (match && parseInt(match[1], 10) > 0)
+                            reflected++;
+                    }
+                    catch { /* skip */ }
+                }
+                reflectionRate = Math.round((reflected / solFiles.length) * 100);
+            }
+        }
+    }
+    catch { /* fail-open */ }
+    const improvL = reflectionRate > 0 ? 'L3' : solutionsCount > 0 ? 'L2' : 'L1';
+    const levelIcon = (l) => l === 'L3' ? '✓' : l === 'L2' ? '✓' : l === 'L1' ? '✗' : '✗';
+    console.log(`  Axis               Level  Detail`);
+    console.log(`  ${'─'.repeat(55)}`);
+    console.log(`  ${levelIcon(prepL)} Preparation        ${prepL}     CLAUDE.md:${hasClaude ? 'yes' : 'no'}, rules:${rulesCount}, hooks:${hooksActive}`);
+    console.log(`  ${levelIcon(ctxL)} Context            ${ctxL}     solutions:${solutionsCount}, behavior:${behaviorCount}`);
+    console.log(`  ${levelIcon(execL)} Execution          ${execL}     skills:${hasSkills ? 'yes' : 'no'}`);
+    console.log(`  ${levelIcon(validL)} Validation         ${validL}     tests:${hasTests ? 'yes' : 'no'}, CI:${hasCI ? 'yes' : 'no'}`);
+    console.log(`  ${levelIcon(improvL)} Improvement        ${improvL}     reflection:${reflectionRate}%`);
     console.log();
+    // Quick wins: suggest for lowest scoring axes
+    const axes = [
+        { name: 'Preparation', level: prepL, hint: 'Add CLAUDE.md + .claude/rules/ files' },
+        { name: 'Context', level: ctxL, hint: 'Run /compound to accumulate solutions' },
+        { name: 'Execution', level: execL, hint: 'Promote solutions to skills' },
+        { name: 'Validation', level: validL, hint: 'Add tests/ dir and .github/workflows' },
+        { name: 'Improvement', level: improvL, hint: 'Reflect on existing solutions' },
+    ];
+    const quickWins = axes.filter(a => a.level === 'L0' || a.level === 'L1').slice(0, 3);
+    if (quickWins.length > 0) {
+        console.log('  Quick Wins (Top 3):');
+        for (const win of quickWins) {
+            console.log(`  → ${win.name}: ${win.hint}`);
+        }
+        console.log();
+    }
     // 현재 디렉토리 git 정보
     console.log('  [Git]');
     try {

package/dist/core/drift-score.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Forgen — Drift Score (Session Drift Detection)
+ *
+ * 세션 내 수정 패턴을 추적하여 drift(산만/반복 수정)를 감지.
+ * EWMA(Exponentially Weighted Moving Average) 기반 이동평균으로
+ * 최근 수정 강도를 측정하고, 임계값 초과 시 경고.
+ *
+ * Codex 합의: DriftState + evaluateDrift 2개만. 최소 인터페이스.
+ */
+/** Drift 상태 (세션 단위, STATE_DIR에 저장) */
+export interface DriftState {
+    sessionId: string;
+    totalEdits: number;
+    totalReverts: number;
+    /** EWMA edit rate (0~1, 높을수록 최근 수정 빈도 높음) */
+    ewmaEditRate: number;
+    /** EWMA revert rate (0~1) */
+    ewmaRevertRate: number;
+    /** 최근 경고 timestamp (쿨다운용) */
+    lastWarningAt: number;
+    lastCriticalAt: number;
+    hardCapReached: boolean;
+}
+export interface DriftResult {
+    level: 'normal' | 'warning' | 'critical' | 'hardcap';
+    score: number;
+    message: string | null;
+}
+export interface DriftThresholds {
+    alpha?: number;
+    warningEdits?: number;
+    criticalEdits?: number;
+    criticalReverts?: number;
+    hardCapEdits?: number;
+    warningCooldownMs?: number;
+    criticalCooldownMs?: number;
+}
+/** EWMA 업데이트 (순수 함수) */
+export declare function updateEwma(prev: number, sample: number, alpha: number): number;
+/** 새 DriftState 생성 */
+export declare function createDriftState(sessionId: string): DriftState;
+/**
+ * 도구 호출 이벤트로 drift 상태를 갱신하고 평가 결과를 반환.
+ * @param state 현재 상태 (mutate됨)
+ * @param isEdit Write/Edit 도구 호출 여부
+ * @param isRevert revert 감지 여부
+ * @param thresholds 커스텀 임계치 (hook-config에서 로드)
+ */
+export declare function evaluateDrift(state: DriftState, isEdit: boolean, isRevert: boolean, thresholds?: DriftThresholds): DriftResult;