@wooojin/forgen 0.4.8 → 0.4.10

package/dist/core/dashboard-cli.js

@@ -0,0 +1,226 @@
+/**
+ * Forgen — Dashboard CLI (P3)
+ *
+ * `fgx status [--watch] [--json] [--interval N]`
+ * ANSI box-drawing 기반 상태 대시보드. TUI 라이브러리 없음.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getUsageStats } from './usage-telemetry.js';
+import { classifySolutions } from './lifecycle-classifier.js';
+import { STATE_DIR } from './paths.js';
+import { FORGEN_HOME } from './paths.js';
+// ── ANSI ──────────────────────────────────────────────────────────────────────
+const isTTY = process.stdout.isTTY;
+const C = {
+    reset: isTTY ? '\x1b[0m' : '',
+    bold: isTTY ? '\x1b[1m' : '',
+    dim: isTTY ? '\x1b[2m' : '',
+    cyan: isTTY ? '\x1b[36m' : '',
+    yellow: isTTY ? '\x1b[33m' : '',
+    green: isTTY ? '\x1b[32m' : '',
+    red: isTTY ? '\x1b[31m' : '',
+};
+const BOX_WIDTH = 66;
+function bar(pct, width = 10) {
+    const filled = Math.round(pct * width);
+    const empty = width - filled;
+    return '█'.repeat(Math.max(0, filled)) + '░'.repeat(Math.max(0, empty));
+}
+// 런타임에 정규식 구성 — biome 의 noControlCharactersInRegex 우회.
+// ESC (0x1B) 는 ANSI escape 의 시작이지만 literal regex 에는 못 박힘.
+const ANSI_STRIP_RE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, 'g');
+function boxLine(content) {
+    const plain = content.replace(ANSI_STRIP_RE, '');
+    const padding = BOX_WIDTH - 2 - plain.length;
+    return `│ ${content}${' '.repeat(Math.max(0, padding))} │`;
+}
+function boxEmpty() {
+    return `│${' '.repeat(BOX_WIDTH - 2)}│`;
+}
+function boxTop() {
+    return `┌─ ${C.bold}${C.cyan}forgen status${C.reset}` +
+        ' ' + '─'.repeat(BOX_WIDTH - 17) + '┐';
+}
+function boxBottom() {
+    return `└${'─'.repeat(BOX_WIDTH - 2)}┘`;
+}
+function collectData() {
+    const now = new Date();
+    // usage
+    const usage = (() => {
+        try {
+            return getUsageStats();
+        }
+        catch {
+            return { hour5: { claude: 0, codex: 0, total: 0 }, week: { claude: 0, codex: 0, total: 0 } };
+        }
+    })();
+    // today extracted: me/solutions/*.md mtime이 오늘인 것 (또는 last-extraction.json)
+    const todayExtracted = (() => {
+        try {
+            const lastExtPath = path.join(STATE_DIR, 'last-extraction.json');
+            if (fs.existsSync(lastExtPath)) {
+                const data = JSON.parse(fs.readFileSync(lastExtPath, 'utf-8'));
+                const ts = data.ts ?? 0;
+                const isToday = new Date(ts).toDateString() === now.toDateString();
+                if (isToday && typeof data.count === 'number')
+                    return data.count;
+            }
+        }
+        catch { /* ignore */ }
+        // fallback: count solutions modified today
+        try {
+            const solutionsDir = path.join(FORGEN_HOME, 'me', 'solutions');
+            if (!fs.existsSync(solutionsDir))
+                return 0;
+            const files = fs.readdirSync(solutionsDir).filter(f => f.endsWith('.md'));
+            const todayStr = now.toDateString();
+            return files.filter(f => {
+                try {
+                    const stat = fs.statSync(path.join(solutionsDir, f));
+                    return new Date(stat.mtimeMs).toDateString() === todayStr;
+                }
+                catch {
+                    return false;
+                }
+            }).length;
+        }
+        catch {
+            return 0;
+        }
+    })();
+    // lifecycle
+    const classified = (() => {
+        try {
+            return classifySolutions();
+        }
+        catch {
+            return [];
+        }
+    })();
+    const counts = { hot: 0, warm: 0, cold: 0, dead: 0, new: 0 };
+    for (const c of classified)
+        counts[c.lifecycle]++;
+    const topHot = classified
+        .filter(c => c.lifecycle === 'hot')
+        .sort((a, b) => b.acted_90d - a.acted_90d)
+        .slice(0, 5)
+        .map(c => ({
+        id: c.solutionId,
+        surfaced: c.surfaced_90d,
+        acted: c.acted_90d,
+        rate: c.hitRate ?? 0,
+    }));
+    // rate-limit misses (7d)
+    const rateLimitMisses7d = (() => {
+        try {
+            const missPath = path.join(STATE_DIR, 'rate-limit-misses.jsonl');
+            if (!fs.existsSync(missPath))
+                return 0;
+            const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+            const lines = fs.readFileSync(missPath, 'utf-8').split('\n').filter(Boolean);
+            return lines.filter(l => {
+                try {
+                    const obj = JSON.parse(l);
+                    return typeof obj.ts === 'number' && obj.ts >= cutoff;
+                }
+                catch {
+                    return false;
+                }
+            }).length;
+        }
+        catch {
+            return 0;
+        }
+    })();
+    return {
+        timestamp: now.toISOString(),
+        usage,
+        todayExtracted,
+        solutions: {
+            total: classified.length,
+            ...counts,
+            topHot,
+            classified,
+        },
+        rateLimitMisses7d,
+    };
+}
+// ── Render ─────────────────────────────────────────────────────────────────────
+function renderTTY(data) {
+    const lines = [];
+    lines.push(boxTop());
+    lines.push(boxEmpty());
+    // Usage
+    lines.push(boxLine(`${C.bold}Usage${C.reset}`));
+    const h5total = data.usage.hour5.total;
+    const h5pct = Math.min(1, h5total / Math.max(h5total + 10, 50));
+    const h5bar = bar(h5pct);
+    lines.push(boxLine(`  5h window:    ${C.yellow}${h5bar}${C.reset}  (${h5total} tool calls)`));
+    const wktotal = data.usage.week.total;
+    const wkpct = Math.min(1, wktotal / Math.max(wktotal + 10, 100));
+    const wkbar = bar(wkpct);
+    lines.push(boxLine(`  weekly:       ${C.yellow}${wkbar}${C.reset}  (${wktotal} tool calls)`));
+    lines.push(boxEmpty());
+    // Today compound
+    lines.push(boxLine(`${C.bold}Today's compound${C.reset}`));
+    lines.push(boxLine(`  extracted:    ${data.todayExtracted} solutions`));
+    lines.push(boxEmpty());
+    // Solutions
+    lines.push(boxLine(`${C.bold}Solutions${C.reset} (${data.solutions.total} total)`));
+    const lifecycleLine = `  ${C.red}🔥 hot:${C.reset}  ${data.solutions.hot}` +
+        `   ${C.yellow}🟡 warm:${C.reset} ${data.solutions.warm}` +
+        `   ${C.cyan}🥶 cold:${C.reset} ${data.solutions.cold}` +
+        `   ${C.dim}💀 dead:${C.reset} ${data.solutions.dead}` +
+        `   ${C.green}🌱 new:${C.reset}  ${data.solutions.new}`;
+    lines.push(boxLine(lifecycleLine));
+    lines.push(boxEmpty());
+    // Top 5 hot
+    if (data.solutions.topHot.length > 0) {
+        lines.push(boxLine(`${C.bold}Top ${data.solutions.topHot.length} hot (90d)${C.reset}`));
+        for (const h of data.solutions.topHot) {
+            const pctStr = `${Math.round(h.rate * 100)}%`;
+            const idShort = h.id.length > 36 ? h.id.slice(0, 33) + '...' : h.id;
+            lines.push(boxLine(`  · ${C.yellow}${idShort}${C.reset}  surf=${h.surfaced} acted=${h.acted} (${pctStr})`));
+        }
+        lines.push(boxEmpty());
+    }
+    // Rate-limit
+    lines.push(boxLine(`${C.bold}Rate-limit${C.reset}`));
+    lines.push(boxLine(`  misses (7d):  ${data.rateLimitMisses7d}`));
+    lines.push(boxEmpty());
+    // Last update
+    lines.push(boxLine(`${C.dim}Last update:    ${data.timestamp}${C.reset}`));
+    lines.push(boxBottom());
+    return lines.join('\n');
+}
+// ── Public API ────────────────────────────────────────────────────────────────
+export async function runDashboard(opts) {
+    const intervalSec = opts.intervalSec ?? 5;
+    const render = () => {
+        const data = collectData();
+        if (opts.json) {
+            // Strip classified array (verbose) from JSON output for cleaner schema
+            const { solutions: { classified: _c, ...solutionStats }, ...rest } = data;
+            process.stdout.write(JSON.stringify({ ...rest, solutions: solutionStats }, null, 2) + '\n');
+            return;
+        }
+        const output = renderTTY(data);
+        if (opts.watch) {
+            process.stdout.write('\x1b[2J\x1b[H'); // clear screen
+        }
+        process.stdout.write(output + '\n');
+    };
+    render();
+    if (opts.watch) {
+        const interval = setInterval(render, intervalSec * 1000);
+        process.on('SIGINT', () => {
+            clearInterval(interval);
+            process.stdout.write('\n');
+            process.exit(0);
+        });
+        // Keep process alive
+        await new Promise(() => { });
+    }
+}

package/dist/core/dev-guide-injector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * dev-guide-injector — fgx init 시 dev-guide principles 를
+ * Claude (.claude/rules/dev-guide-principles.md) + Codex (AGENTS.md managed block)
+ * 양쪽에 stack-aware 자동 inject.
+ */
+export interface DetectedStack {
+    side: 'fe' | 'be';
+    stack: 'react' | 'vue' | 'node' | 'go';
+    principlesFiles: string[];
+}
+export interface InjectResult {
+    stack: DetectedStack | null;
+    claudeRulePath: string;
+    claudeRuleWritten: boolean;
+    agentsMdPath: string;
+    agentsMdInjected: boolean;
+    bytesWritten: number;
+}
+export interface InjectOptions {
+    cwd: string;
+    pkgRoot: string;
+    dryRun?: boolean;
+}
+export declare function detectStack(cwd: string): DetectedStack | null;
+export declare function readPrinciples(pkgRoot: string, side: 'fe' | 'be', stack: string): string;
+export declare function injectDevGuidePrinciples(opts: InjectOptions): InjectResult;

package/dist/core/dev-guide-injector.js

@@ -0,0 +1,137 @@
+/**
+ * dev-guide-injector — fgx init 시 dev-guide principles 를
+ * Claude (.claude/rules/dev-guide-principles.md) + Codex (AGENTS.md managed block)
+ * 양쪽에 stack-aware 자동 inject.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ── 상수 ──────────────────────────────────────────────────────────────────────
+const AGENTS_MD_BEGIN = '<!-- >>> forgen-managed-rules -->';
+const AGENTS_MD_END = '<!-- <<< forgen-managed-rules -->';
+// ── detectStack ───────────────────────────────────────────────────────────────
+export function detectStack(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+            if ('react' in deps || 'next' in deps) {
+                return { side: 'fe', stack: 'react', principlesFiles: ['common.md', 'react.md'] };
+            }
+            if ('vue' in deps || 'nuxt' in deps) {
+                return { side: 'fe', stack: 'vue', principlesFiles: ['common.md', 'vue.md'] };
+            }
+            return { side: 'be', stack: 'node', principlesFiles: ['common.md', 'node.md'] };
+        }
+        catch {
+            // JSON parse 실패 — fall through to go.mod check
+        }
+    }
+    if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+        return { side: 'be', stack: 'go', principlesFiles: ['common.md', 'go.md'] };
+    }
+    return null;
+}
+// ── readPrinciples ────────────────────────────────────────────────────────────
+export function readPrinciples(pkgRoot, side, stack) {
+    const principlesDir = path.join(pkgRoot, 'assets', 'dev-guide', side, 'principles');
+    const commonContent = fs.readFileSync(path.join(principlesDir, 'common.md'), 'utf-8');
+    const stackContent = fs.readFileSync(path.join(principlesDir, `${stack}.md`), 'utf-8');
+    return [
+        `<!-- forgen dev-guide principles (auto-generated, do not edit) -->`,
+        `<!-- source: assets/dev-guide/${side}/principles/common.md + ${stack}.md -->`,
+        ``,
+        `# common (${side})`,
+        commonContent.trimEnd(),
+        ``,
+        `---`,
+        ``,
+        `# ${stack}`,
+        stackContent.trimEnd(),
+        ``,
+    ].join('\n');
+}
+// ── injectDevGuidePrinciples ──────────────────────────────────────────────────
+export function injectDevGuidePrinciples(opts) {
+    const { cwd, pkgRoot, dryRun = false } = opts;
+    const claudeRulePath = path.join(cwd, '.claude', 'rules', 'dev-guide-principles.md');
+    const agentsMdPath = path.join(cwd, 'AGENTS.md');
+    const emptyResult = {
+        stack: null,
+        claudeRulePath,
+        claudeRuleWritten: false,
+        agentsMdPath,
+        agentsMdInjected: false,
+        bytesWritten: 0,
+    };
+    const detected = detectStack(cwd);
+    if (!detected)
+        return emptyResult;
+    const body = readPrinciples(pkgRoot, detected.side, detected.stack);
+    // ── Claude side ──
+    const claudeRuleWritten = writeClaudeRule({ claudeRulePath, body, dryRun });
+    // ── Codex side ──
+    const agentsMdInjected = upsertAgentsMd({ agentsMdPath, body, dryRun });
+    return {
+        stack: detected,
+        claudeRulePath,
+        claudeRuleWritten,
+        agentsMdPath,
+        agentsMdInjected,
+        bytesWritten: dryRun ? 0 : body.length,
+    };
+}
+// ── helpers ───────────────────────────────────────────────────────────────────
+function writeClaudeRule(opts) {
+    const { claudeRulePath, body, dryRun } = opts;
+    const existing = fs.existsSync(claudeRulePath)
+        ? fs.readFileSync(claudeRulePath, 'utf-8')
+        : null;
+    if (existing === body)
+        return false;
+    if (!dryRun) {
+        fs.mkdirSync(path.dirname(claudeRulePath), { recursive: true });
+        fs.writeFileSync(claudeRulePath, body, 'utf-8');
+    }
+    return true;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function buildDevGuideBlock(body) {
+    return [AGENTS_MD_BEGIN, body.trimEnd(), AGENTS_MD_END].join('\n');
+}
+function upsertAgentsMd(opts) {
+    const { agentsMdPath, body, dryRun } = opts;
+    const block = buildDevGuideBlock(body);
+    const current = fs.existsSync(agentsMdPath) ? fs.readFileSync(agentsMdPath, 'utf-8') : '';
+    const reMarker = new RegExp(`${escapeRegex(AGENTS_MD_BEGIN)}[\\s\\S]*?${escapeRegex(AGENTS_MD_END)}`);
+    const hasBlock = reMarker.test(current);
+    let newContent;
+    if (hasBlock) {
+        newContent = current.replace(reMarker, block);
+    }
+    else {
+        const beginIdx = current.indexOf(AGENTS_MD_BEGIN);
+        const endIdx = current.indexOf(AGENTS_MD_END);
+        if (beginIdx !== -1 && endIdx === -1) {
+            // self-heal: begin 만 있고 end 손상
+            newContent = `${current.slice(0, beginIdx).replace(/\s+$/, '')}\n\n${block}\n`;
+        }
+        else if (current.length === 0) {
+            // 신규 파일
+            newContent = `# Agent Instructions (forgen-managed)\n\n${block}\n`;
+        }
+        else {
+            // 기존 파일에 append
+            newContent = `${current.replace(/\s+$/, '')}\n\n${block}\n`;
+        }
+    }
+    if (newContent === current)
+        return false;
+    if (!dryRun) {
+        fs.mkdirSync(path.dirname(agentsMdPath), { recursive: true });
+        fs.writeFileSync(agentsMdPath, newContent, 'utf-8');
+    }
+    return true;
+}

package/dist/core/doctor.js

@@ -491,12 +491,18 @@ export async function runDoctor(opts = {}) {
     }
     // P4 셀프 가드: fix:feat 비율 30% 초과 시 회귀 패턴 의심 경고.
     try {
-        const { computeFixFeatRatio, formatFixRatio } = await import('./git-stats.js');
+        const { computeFixFeatRatio, formatFixRatio, computeRegressMap } = await import('./git-stats.js');
         const ratio = computeFixFeatRatio();
         if (ratio.available) {
             console.log(`  ${formatFixRatio(ratio)}`);
             if (ratio.exceedsThreshold) {
                 console.log('  ⚠ fix:feat 비율이 임계값을 초과했습니다. "이거 고치면 저거 버그난다" 패턴 의심 — 검증 레이어 invariant 점검 권장.');
+                const map = computeRegressMap(process.cwd(), 30, 3);
+                if (map.available && map.hotspots.length > 0) {
+                    const top = map.hotspots.map((h) => `${h.path} (${h.fixHits})`).join(', ');
+                    console.log(`  → 진앙 후보 top 3: ${top}`);
+                    console.log('  → 전체 보기: forgen regress-map');
+                }
             }
         }
     }
@@ -529,6 +535,36 @@ export async function runDoctor(opts = {}) {
     // [Codex Parity] — parity-result.json 신선도 검사 (v0.4.2 패턴 확장)
     renderCodexParity();
     console.log();
+    // [ψ-long] — within-conversation compound 효과 측정 (v0.4.10)
+    // 측정 시간이 길어 ship-gate 는 advisory. 신선도(<= 14d) + psiLong > 0 만 확인.
+    console.log('  [ψ-long compound]');
+    try {
+        const psiLongPath = path.join(STATE_DIR, 'psi-long-result.json');
+        if (!fs.existsSync(psiLongPath)) {
+            console.log('  ○ no measurement yet — `pnpm --filter @wooojin/forgen-eval psi:long` 권장');
+        }
+        else {
+            const raw = fs.readFileSync(psiLongPath, 'utf-8');
+            const data = JSON.parse(raw);
+            const ageMs = data.at ? Date.now() - new Date(data.at).getTime() : Number.POSITIVE_INFINITY;
+            const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+            const psiLong = data.psiLong ?? 0;
+            const passed = !!data.passed;
+            const freshTag = ageDays <= 14 ? 'fresh' : `${ageDays}d stale`;
+            const gateLabel = passed ? '✓ PASS' : '✗ FAIL';
+            console.log(`  ${gateLabel}  ψ_long=${psiLong.toFixed(3)}  N=${data.N ?? '?'}  (${freshTag})`);
+            if (!passed) {
+                console.log('  ⚠ within-session compound 효과 미관측 — correction injection / rule trigger 경로 점검');
+            }
+            else if (ageDays > 14) {
+                console.log('  △ 측정 14일 초과 — 재측정 권장 (`pnpm --filter @wooojin/forgen-eval psi:long`)');
+            }
+        }
+    }
+    catch (e) {
+        console.log(`  Unable to read psi-long state: ${e instanceof Error ? e.message : 'unknown'}`);
+    }
+    console.log();
     // [Summary] — 최종 상태 요약과 복구 액션을 한눈에 보이게
     console.log('  [Summary]');
     if (failedChecks.length === 0) {

package/dist/core/git-stats.d.ts

@@ -34,3 +34,26 @@ export declare function computeFixFeatRatio(cwd?: string, windowSize?: number, t
 export declare function parseGitLog(rawLog: string, windowSize?: number, threshold?: number): FixRatioStats;
 /** 사람용 한 줄 라벨. */
 export declare function formatFixRatio(s: FixRatioStats): string;
+export interface RegressHotspot {
+    path: string;
+    fixHits: number;
+    lastFixSha: string;
+    lastFixDate: string;
+}
+export interface RegressMap {
+    windowDays: number;
+    fixCommits: number;
+    hotspots: RegressHotspot[];
+    available: boolean;
+}
+/**
+ * 지난 N일 동안 fix 커밋이 닿은 파일 hot-list.
+ *
+ * doctor 가 fix:feat 비율로 "회귀 패턴 의심" 시그널은 주지만, 진앙은 안 보여준다.
+ * regress-map 은 fix 커밋의 changed-files 를 카운트해 top-N hotspot 을 추출 →
+ * "이거 고치면 저거 깨진다" 의 *저거* 후보를 한 화면에 노출.
+ *
+ * 제외 scope (fix:feat 와 동일): fix(test|tests|docs|doc) — 노이즈.
+ */
+export declare function computeRegressMap(cwd?: string, windowDays?: number, topN?: number): RegressMap;
+export declare function parseRegressLog(raw: string, windowDays: number, topN: number): RegressMap;

package/dist/core/git-stats.js

@@ -77,3 +77,53 @@ export function formatFixRatio(s) {
     const flag = s.exceedsThreshold ? `  ⚠ over ${thresholdPct}%` : '';
     return `fix:feat ratio    ${pct}%   (${s.fixCount}/${s.fixCount + s.featCount} in last ${s.windowSize})${flag}`;
 }
+/**
+ * 지난 N일 동안 fix 커밋이 닿은 파일 hot-list.
+ *
+ * doctor 가 fix:feat 비율로 "회귀 패턴 의심" 시그널은 주지만, 진앙은 안 보여준다.
+ * regress-map 은 fix 커밋의 changed-files 를 카운트해 top-N hotspot 을 추출 →
+ * "이거 고치면 저거 깨진다" 의 *저거* 후보를 한 화면에 노출.
+ *
+ * 제외 scope (fix:feat 와 동일): fix(test|tests|docs|doc) — 노이즈.
+ */
+export function computeRegressMap(cwd = process.cwd(), windowDays = 30, topN = 10) {
+    try {
+        const since = `--since=${windowDays}.days.ago`;
+        const out = execFileSync('git', ['log', '--no-merges', since, '--name-only', '--pretty=format:%x1fCOMMIT%x1f%h%x1f%cs%x1f%s'], { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 32 * 1024 * 1024 });
+        return parseRegressLog(out, windowDays, topN);
+    }
+    catch {
+        return { windowDays, fixCommits: 0, hotspots: [], available: false };
+    }
+}
+export function parseRegressLog(raw, windowDays, topN) {
+    const blocks = raw.split('\x1fCOMMIT\x1f').slice(1);
+    const counter = new Map();
+    let fixCommits = 0;
+    for (const block of blocks) {
+        const [sha, date, rest = ''] = block.split('\x1f');
+        const nl = rest.indexOf('\n');
+        const subject = nl === -1 ? rest : rest.slice(0, nl);
+        const files = nl === -1 ? [] : rest.slice(nl + 1).split('\n').map((s) => s.trim()).filter(Boolean);
+        const m = subject.match(/^(fix|feat)(?:\(([^)]+)\))?:/);
+        if (!m || m[1] !== 'fix')
+            continue;
+        const scope = (m[2] ?? '').toLowerCase().trim();
+        if (SCOPE_EXCLUSIONS.has(scope))
+            continue;
+        fixCommits++;
+        for (const f of files) {
+            const existing = counter.get(f);
+            if (existing) {
+                existing.fixHits++;
+            }
+            else {
+                counter.set(f, { path: f, fixHits: 1, lastFixSha: sha, lastFixDate: date });
+            }
+        }
+    }
+    const hotspots = Array.from(counter.values())
+        .sort((a, b) => b.fixHits - a.fixHits || a.path.localeCompare(b.path))
+        .slice(0, topN);
+    return { windowDays, fixCommits, hotspots, available: true };
+}

package/dist/core/init.js

@@ -9,6 +9,7 @@ import * as path from 'node:path';
 import { profileExists } from '../store/profile-store.js';
 import { ensureV1Directories } from './v1-bootstrap.js';
 import { initializeForgenHome } from './init-cli.js';
+import { injectDevGuidePrinciples } from './dev-guide-injector.js';
 // ── CLI 핸들러 ──
 export async function handleInit(_args) {
     const cwd = process.cwd();
@@ -19,6 +20,21 @@ export async function handleInit(_args) {
     // 프로젝트 .claude/rules 디렉토리 생성
     const rulesDir = path.join(cwd, '.claude', 'rules');
     fs.mkdirSync(rulesDir, { recursive: true });
+    // dev-guide principles 자동 inject — profile 존재 여부와 무관한 stateless 작업.
+    // profileExists() early-return / onboarding 흐름 어디든 동일하게 통과해야 하므로
+    // 두 분기 앞쪽에 배치 (기존 위치는 unreachable 경로였음).
+    const pkgRoot = path.resolve(import.meta.dirname ?? __dirname, '..', '..');
+    const injectResult = injectDevGuidePrinciples({ cwd, pkgRoot });
+    if (injectResult.stack) {
+        const { side, stack } = injectResult.stack;
+        const stackLabel = side === 'fe'
+            ? (stack === 'react' ? 'React/Next' : 'Vue/Nuxt')
+            : (stack === 'go' ? 'Go' : 'Node.js');
+        console.log(`  💡 ${stackLabel} 프로젝트 감지됨. dev-guide principles 자동 inject:`);
+        console.log(`     ${injectResult.claudeRulePath} (Claude)`);
+        console.log(`     ${injectResult.agentsMdPath} (Codex, managed block)`);
+        suggestStackSkills(cwd);
+    }
     // v0.4.1 (2026-04-24): starter-pack 프로비저닝 — 격리 홈 / 신규 FORGEN_HOME
     // 에서 "신규 사용자 첫날 가치" 가 0이 되는 결함 해소. npm install-g 시의
     // postinstall 이 하던 starter 배포를 런타임에서도 보장.
@@ -52,3 +68,40 @@ export async function handleInit(_args) {
     console.log('    forgen inspect profile     View your profile');
     console.log('    forgen doctor              Check system health\n');
 }
+// 감지된 스택을 알리고, fgx 번들에 포함된 dev-guide 스킬을 안내.
+// 실제 설치는 install-claude.ts 가 ~/.claude/skills/ 에 처리.
+function suggestStackSkills(cwd) {
+    const pkgPath = path.join(cwd, 'package.json');
+    const goModPath = path.join(cwd, 'go.mod');
+    let stack = null;
+    let skills = [];
+    if (fs.existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+            if ('react' in deps || 'next' in deps) {
+                stack = 'React/Next';
+                skills = ['fe-build-react', 'fe-review-react', 'fe-perf-react'];
+            }
+            else if ('vue' in deps || 'nuxt' in deps) {
+                stack = 'Vue/Nuxt';
+                skills = ['fe-build-vue', 'fe-review-vue', 'fe-perf-vue'];
+            }
+            else {
+                stack = 'Node.js';
+                skills = ['be-build-node', 'be-review-node', 'be-perf-node', 'be-security-node'];
+            }
+        }
+        catch { /* ignore */ }
+    }
+    else if (fs.existsSync(goModPath)) {
+        stack = 'Go';
+        skills = ['be-build-go', 'be-review-go', 'be-perf-go', 'be-security-go'];
+    }
+    if (!stack)
+        return;
+    console.log(`  💡 ${stack} 프로젝트로 감지됨. fgx 번들 dev-guide 스킬 사용 가능:`);
+    for (const s of skills)
+        console.log(`     /${s}`);
+    console.log('');
+}

package/dist/core/inspect-cli.js

@@ -8,7 +8,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { loadProfile } from '../store/profile-store.js';
 import { loadAllRules, loadActiveRules } from '../store/rule-store.js';
-import { loadRecentEvidence } from '../store/evidence-store.js';
+import { loadRecentEvidence, loadAllEvidence } 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';
@@ -71,6 +71,10 @@ export async function handleInspect(args) {
             }
             console.log('');
         }
+        // ── Receipts: correction → rule → inject ── (v0.4.10)
+        // "내가 forgen 으로 무엇을 얻었나" 한 화면. correction 이 만들어낸 rule 의 lifecycle 을
+        // 묶어 표시 — 주입(inject_count), 마지막 주입 시각, host 분포.
+        await renderReceipts();
         return;
     }
     if (sub === 'rules') {
@@ -157,3 +161,58 @@ export async function handleInspect(args) {
     forgen inspect bypass     [--last N] — 사용자 우회 기록
     forgen inspect drift      [--last N] — stuck-loop force-approve 기록`);
 }
+/**
+ * v0.4.10 Receipts: correction → rule → inject 트리플.
+ *
+ * 사용자 가치 명제("the more you use, the better it knows") 의 receipt.
+ * 1) Top-injected rules (실제로 Claude 에 주입된 룰 N회)
+ * 2) Recent rule births (correction → 새 룰 생성된 이력)
+ * 3) Host 균형 (claude vs codex)
+ */
+async function renderReceipts() {
+    const rules = loadAllRules();
+    const evidence = loadAllEvidence();
+    const injected = rules
+        .filter((r) => r.lifecycle && (r.lifecycle.inject_count ?? 0) > 0)
+        .sort((a, b) => (b.lifecycle?.inject_count ?? 0) - (a.lifecycle?.inject_count ?? 0))
+        .slice(0, 5);
+    console.log('── Receipts (correction → rule → inject) ──');
+    if (injected.length === 0) {
+        console.log('  No injected rules yet. Trigger a session to start the loop.');
+    }
+    else {
+        console.log('  Top injected rules:');
+        for (const r of injected) {
+            const count = r.lifecycle?.inject_count ?? 0;
+            const last = (r.lifecycle?.last_inject_at ?? '').slice(0, 10) || 'never';
+            const trigger = (r.trigger ?? '').slice(0, 48);
+            console.log(`    ${String(count).padStart(3)}×  [${r.category}] ${trigger} (last ${last})`);
+        }
+    }
+    // Recent rule births: 마지막 7일 내 created_at 인 룰 (T = correction → rule)
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const recentRules = rules
+        .filter((r) => new Date(r.created_at).getTime() >= sevenDaysAgo)
+        .sort((a, b) => b.created_at.localeCompare(a.created_at))
+        .slice(0, 3);
+    if (recentRules.length > 0) {
+        console.log('  New rules (last 7 days):');
+        for (const r of recentRules) {
+            const dateStr = r.created_at.slice(0, 10);
+            console.log(`    + [${r.category}/${r.strength}] ${(r.trigger ?? '').slice(0, 48)}  (${dateStr})`);
+        }
+    }
+    // Host 균형 — multi-host 가치 명제의 receipt
+    const hostCount = { claude: 0, codex: 0 };
+    for (const e of evidence) {
+        const h = (e.host ?? 'claude');
+        hostCount[h] = (hostCount[h] ?? 0) + 1;
+    }
+    const total = hostCount.claude + hostCount.codex;
+    if (total > 0) {
+        const cpct = Math.round((hostCount.claude / total) * 100);
+        const xpct = 100 - cpct;
+        console.log(`  Host balance: claude ${cpct}% · codex ${xpct}% (n=${total})`);
+    }
+    console.log('');
+}