@wooojin/forgen 0.4.1 → 0.4.3

package/dist/cli.js

@@ -112,8 +112,31 @@ const commands = [
                     await displayHookStatus(process.cwd());
                 }
             }
+            else if (sub === 'default-host') {
+                const value = args[1];
+                const valid = new Set(['claude', 'codex', 'ask']);
+                if (value === undefined) {
+                    const { getDefaultHost } = await import('./store/profile-store.js');
+                    const current = getDefaultHost();
+                    console.log(`  current default_host: ${current ?? '(unset → claude fallback)'}`);
+                    console.log('  Usage: forgen config default-host {claude|codex|ask}');
+                }
+                else if (!valid.has(value)) {
+                    console.log(`  Invalid value: ${value}. Use one of: claude, codex, ask`);
+                    process.exit(1);
+                }
+                else {
+                    const { setDefaultHost } = await import('./store/profile-store.js');
+                    const ok = setDefaultHost(value);
+                    if (!ok) {
+                        console.log('  ✗ Profile not found. Run `forgen onboarding` first.');
+                        process.exit(1);
+                    }
+                    console.log(`  ✓ default_host set to: ${value}`);
+                }
+            }
             else {
-                console.log('Usage: forgen config hooks [--regenerate]');
+                console.log('Usage:\n  forgen config hooks [--regenerate]\n  forgen config default-host [claude|codex|ask]');
             }
         },
     },
@@ -133,6 +156,53 @@ const commands = [
             await handleInit(args);
         },
     },
+    {
+        name: 'install',
+        description: 'Install forgen into a host. Usage: forgen install [claude|codex|both] [--dry-run] [--no-mcp]',
+        handler: async (args) => {
+            const knownSubs = new Set(['claude', 'codex', 'both']);
+            const target = args[0] && knownSubs.has(args[0]) ? args[0] : args[0]?.startsWith('--') ? undefined : args[0];
+            if (target !== undefined && !knownSubs.has(target)) {
+                console.log('Usage:\n  forgen install [claude|codex|both] [--dry-run] [--no-mcp]\n\n  No arg → interactive 3-choice (Claude/Codex/Both).');
+                return;
+            }
+            const dryRun = args.includes('--dry-run');
+            const registerMcp = !args.includes('--no-mcp');
+            const { runInstall, renderResult, resolvePkgRootFromBinary } = await import('./host/install-orchestrator.js');
+            const pkgRoot = resolvePkgRootFromBinary(import.meta.url);
+            const result = await runInstall({ target, pkgRoot, dryRun, registerMcp });
+            if (result === null) {
+                console.log('\n  [forgen] Install skipped.');
+                return;
+            }
+            console.log(renderResult(result, dryRun));
+        },
+    },
+    {
+        name: 'parity',
+        description: 'Run host parity checks. Usage: forgen parity codex [--dry-run]',
+        handler: async (args) => {
+            const sub = args[0];
+            if (sub !== 'codex') {
+                console.log('Usage:\n  forgen parity codex [--dry-run]\n\nNotes:\n  - source 체크아웃에서만 작동합니다 (tests/ 디렉토리 필요).\n  - npm install 로 설치된 패키지에서는 run-parity.sh 가 없습니다.');
+                return;
+            }
+            const here = path.dirname(new URL(import.meta.url).pathname);
+            const scriptPath = path.resolve(here, '..', 'tests', 'e2e', 'codex', 'run-parity.sh');
+            if (!fs.existsSync(scriptPath)) {
+                console.error('[forgen] run-parity.sh 는 source 체크아웃에서만 작동. 직접 git clone 후 실행하세요.');
+                console.error(`  expected: ${scriptPath}`);
+                process.exit(1);
+            }
+            const { spawnSync } = await import('node:child_process');
+            const dryRun = args.includes('--dry-run');
+            const spawnArgs = dryRun ? ['--dry-run'] : [];
+            const result = spawnSync('bash', [scriptPath, ...spawnArgs], { stdio: 'inherit' });
+            if (result.status !== 0) {
+                process.exit(result.status ?? 1);
+            }
+        },
+    },
     {
         name: 'notepad',
         description: 'Notepad (show|add|clear)',
@@ -151,7 +221,7 @@ const commands = [
     },
     {
         name: 'onboarding',
-        description: 'v1 2-question onboarding flow',
+        description: 'v1 4-question onboarding flow',
         handler: async (_args) => {
             const { runOnboarding } = await import('./forge/onboarding-cli.js');
             await runOnboarding();
@@ -407,7 +477,8 @@ async function main() {
   ${dim}Code, forged for you.${reset}
   ${dim}Scope: v1(${context.v1.session?.quality_pack ?? 'onboarding needed'})${reset}
 `);
-        const runtimeLabel = runtime === 'codex' ? 'Codex' : 'Claude';
+        const { getHostRuntime } = await import('./host/host-runtime.js');
+        const runtimeLabel = getHostRuntime(runtime).displayName;
         console.log(`[forgen] Starting ${runtimeLabel}...\n`);
         await spawnClaudeWithResume(args, context, () => prepareHarness(process.cwd(), { runtime }), runtime);
     }
@@ -441,7 +512,7 @@ function printHelp() {
 
   Commands:
     forgen forge                    Personalize your coding profile
-    forgen onboarding               Run 2-question onboarding
+    forgen onboarding               Run 4-question onboarding
     forgen inspect [profile|rules|corrections|session]
                                     Inspect v1 state (alias: evidence → corrections)
     forgen rule <list|suppress|activate|scan|health-scan|classify>
@@ -450,8 +521,9 @@ function printHelp() {
     forgen last-block               Show the most recent block event
     forgen recall [--limit N] [--show]
                                     최근 compound 주입 이력 (solution body preview)
-    forgen migrate [implicit-feedback|all]
-                                    One-shot schema migration (category backfill)
+    forgen migrate [implicit-feedback|evidence-host|all]
+                                    One-shot schema migration (category backfill / host backfill)
+    forgen parity codex [--dry-run] Run codex parity checks (source checkout only)
     forgen compound                 Manage accumulated knowledge
     forgen dashboard                Compound system dashboard
     forgen me                       Personal dashboard

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

@@ -12,38 +12,66 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
 import { containsPromptInjection, filterSolutionContent } from '../hooks/prompt-injection-filter.js';
 import { redactSecrets } from '../hooks/secret-filter.js';
 import { createEvidence, saveEvidence, promoteSessionCandidates } from '../store/evidence-store.js';
 import { loadProfile } from '../store/profile-store.js';
 import { FORGEN_HOME, ME_DIR } from './paths.js';
+import { classifyBehaviorKind, mapKindToAxisRefs } from './behavior-classifier.js';
 /** Auto-compound에 사용할 모델 — background 추출이므로 haiku로 충분 */
 const COMPOUND_MODEL = 'haiku';
-/** execFileSync wrapper: transient 에러(ETIMEDOUT 등) 시 1회 재시도 */
+/**
+ * Host-aware exec retry — feat/codex-support P2-3 (Phase 2 critic fix).
+ *
+ * 보안 회귀 방지: Claude 분기는 *args 그대로* execFileSync 호출 → P1-S1 의
+ * `--allowedTools Bash(forgen compound:*)` sandbox hardening 보존.
+ * Codex 분기에서만 -p prompt 추출 → execHost (codex 는 --allowedTools 모름).
+ *
+ * Codex retry 정책 fix: ETIMEDOUT 시 sleep 후 retry 는 *Claude only*. Codex 는
+ * 60-90s response 가 정상이라 timeout 누적 retry 가 무의미 (즉시 fail).
+ */
 function execClaudeRetry(args, opts) {
-    const TRANSIENT = /ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE/;
-    for (let attempt = 0; attempt < 2; attempt++) {
-        try {
-            return execFileSync('claude', args, opts);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            if (attempt === 0 && TRANSIENT.test(msg)) {
-                process.stderr.write(`[forgen-auto-compound] transient error, retrying in 3s...\n`);
-                // Blocking synchronous sleep: Atomics.wait on a zero-initialized
-                // SharedArrayBuffer is the Node.js idiom for blocking the event
-                // loop without spawning child processes. This file runs as a
-                // detached subprocess (`auto-compound-runner`) so blocking is
-                // both safe and intentional. The 3000ms matches the backoff
-                // before retry. Alternative setTimeout would require making this
-                // function async, which would ripple through the entire runner.
-                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 3000);
-                continue;
+    const mod = createRequire(import.meta.url)('../host/exec-host.js');
+    // profile.default_host 로 host 결정 (lazy load)
+    const profileMod = createRequire(import.meta.url)('../store/profile-store.js');
+    const resolved = profileMod.resolveDefaultHost();
+    const host = resolved === 'codex' ? 'codex' : 'claude';
+    if (host === 'claude') {
+        // Claude 측은 기존 보안 hardening 보존: --allowedTools 등 args 그대로 전달.
+        const TRANSIENT = /ETIMEDOUT|ECONNRESET|ECONNREFUSED|EPIPE/;
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                return execFileSync('claude', args, opts);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (attempt === 0 && TRANSIENT.test(msg)) {
+                    process.stderr.write(`[forgen-auto-compound] transient error, retrying in 3s...\n`);
+                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 3000);
+                    continue;
+                }
+                throw e;
             }
-            throw e;
         }
+        throw new Error('unreachable');
     }
-    throw new Error('unreachable');
+    // host === 'codex' — prompt 만 추출 (codex 는 --allowedTools 등 미인식).
+    const pIdx = args.indexOf('-p');
+    if (pIdx === -1 || !args[pIdx + 1]) {
+        throw new Error('execClaudeRetry: codex host requires -p prompt argument');
+    }
+    const prompt = args[pIdx + 1];
+    const modelIdx = args.indexOf('--model');
+    const model = modelIdx !== -1 ? args[modelIdx + 1] : undefined;
+    const r = mod.execHost({
+        prompt,
+        model,
+        host: 'codex',
+        timeout: typeof opts.timeout === 'number' ? opts.timeout : 60000,
+        cwd: typeof opts.cwd === 'string' ? opts.cwd : undefined,
+    });
+    return r.message;
 }
 const [, , cwd, transcriptPath, sessionId] = process.argv;
 if (!cwd || !transcriptPath || !sessionId) {
@@ -205,9 +233,7 @@ function mergeOrCreateBehavior(dir, newContent, kind, today) {
             fs.writeFileSync(filePath, updated);
             return true;
         }
-        catch {
-            continue;
-        }
+        catch { }
     }
     return false;
 }
@@ -308,14 +334,15 @@ ${sanitizedSummary.slice(0, 6000)}
 관찰된 패턴을 다음 형식으로 1~3개만 출력해주세요 (없으면 "관찰된 패턴 없음"):
 - [카테고리] 패턴 설명 (관찰 근거)
 
-카테고리: 커뮤니케이션/작업습관/기술선호/의사결정/워크플로우
+카테고리: 커뮤니케이션/작업습관/기술선호/의사결정/워크플로우/품질안전/자율성
 
-특히 "워크플로우" 카테고리에 주목하세요:
-- 사용자가 반복하는 작업 순서 패턴 (예: "항상 테스트 먼저 작성 → 구현 → 리팩토링 순서로 진행")
-- 특정 상황에서의 판단 규칙 (예: "PR 리뷰 시 보안 → 테스트 → 코드 품질 순서로 확인")
-- 조건부 접근법 (예: "버그 수정 시 재현 테스트부터 작성, 성능 이슈면 프로파일링부터")
+각 카테고리 가이드:
+- "워크플로우": 반복하는 작업 순서, 판단 규칙, 조건부 접근법 (예: "테스트 먼저 → 구현 → 리팩토링 순서")
+- "품질안전": 검증/테스트/안전성 관련 강한 선호 (예: "프로덕션 배포 전 Docker e2e 의무", "mock-only 검증 거부")
+- "자율성": 확인/독립 결정 관련 선호 (예: "사소한 변경은 묻지 않고 진행", "큰 결정은 반드시 확인")
 
 워크플로우 패턴이 감지되면 반드시 구체적인 순서를 포함하세요.
+품질안전/자율성 패턴은 4축 개인화의 입력이므로 quality/autonomy 신호가 명확하면 반드시 해당 라벨을 사용하세요 (커뮤니케이션/작업습관 으로 흡수 금지).
 
 기존 패턴과 중복이면 건너뛰세요.${existingBehaviorPatterns}
 
@@ -346,11 +373,11 @@ ${sanitizedSummary.slice(0, 4000)}
             fs.mkdirSync(BEHAVIOR_DIR, { recursive: true });
             const today = new Date().toISOString().split('T')[0];
             const trimmed = userResult.trim();
-            // 카테고리에 따라 kind 분류
-            const kind = trimmed.includes('[워크플로우]') || trimmed.includes('순서') || trimmed.includes('→')
-                ? 'workflow'
-                : trimmed.includes('[의사결정]') ? 'thinking'
-                    : 'preference';
+            // 카테고리에 따라 kind 분류 — D1'' (2026-04-27): quality/autonomy 라벨 추가.
+            // 이전 3분기(workflow/thinking/preference)는 quality_safety/autonomy 축으로
+            // 가는 자동 신호를 communication_style 로 흡수해 626건 중 자동 추출 0건이
+            // 이 두 축에 닿지 못했음. 5분기로 확장. (분류 로직은 behavior-classifier.ts)
+            const kind = classifyBehaviorKind(trimmed);
             // 기존 유사 패턴이 있으면 observedCount 누적
             const merged = mergeOrCreateBehavior(BEHAVIOR_DIR, trimmed, kind, today);
             if (!merged) {
@@ -367,10 +394,7 @@ ${sanitizedSummary.slice(0, 4000)}
                 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']
-                            : [],
+                axis_refs: mapKindToAxisRefs(kind),
                 confidence: 0.6,
                 raw_payload: { kind, observedCount: 1 },
             });

package/dist/core/behavior-classifier.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Behavior Classifier — D1'' (2026-04-27)
+ *
+ * LLM 이 추출한 사용자 패턴을 5개 kind 로 분류하고 4축 axis_refs 로 매핑한다.
+ *
+ * 결함 history:
+ *   v0.4.1 까지: kind 3분기(workflow/thinking/preference) → axis 2축
+ *     (judgment_philosophy / communication_style) 만 자동 추출 가능.
+ *     quality_safety / autonomy 축은 explicit_correction 16건 (Hooks 경로) 으로만
+ *     자라고, 자동 학습 600+ 건은 이 두 축에 0% 기여 — 측정 자기증거.
+ *
+ *   v0.4.2: 5분기 [품질안전] / [자율성] 추가 → 4축 모두 cover.
+ *     LLM prompt (auto-compound-runner) 에도 같은 라벨 가이드를 명시하여
+ *     형식 강제. 새 라벨이 안 나오면 기존 5분기로 fallback (호환).
+ */
+export type BehaviorKind = 'safety' | 'autonomy' | 'workflow' | 'thinking' | 'preference';
+/**
+ * LLM 출력 텍스트(`[카테고리] 설명` 형식)를 5개 kind 로 분류.
+ *
+ * 라벨 우선순위 (위에서 아래):
+ *   1. [품질안전] → safety
+ *   2. [자율성] → autonomy
+ *   3. [워크플로우] OR "순서"/"→" 토큰 → workflow
+ *   4. [의사결정] → thinking
+ *   5. 그 외 → preference (default)
+ */
+export declare function classifyBehaviorKind(text: string): BehaviorKind;
+export declare function mapKindToAxisRefs(kind: BehaviorKind): string[];

package/dist/core/behavior-classifier.js

@@ -0,0 +1,46 @@
+/**
+ * Behavior Classifier — D1'' (2026-04-27)
+ *
+ * LLM 이 추출한 사용자 패턴을 5개 kind 로 분류하고 4축 axis_refs 로 매핑한다.
+ *
+ * 결함 history:
+ *   v0.4.1 까지: kind 3분기(workflow/thinking/preference) → axis 2축
+ *     (judgment_philosophy / communication_style) 만 자동 추출 가능.
+ *     quality_safety / autonomy 축은 explicit_correction 16건 (Hooks 경로) 으로만
+ *     자라고, 자동 학습 600+ 건은 이 두 축에 0% 기여 — 측정 자기증거.
+ *
+ *   v0.4.2: 5분기 [품질안전] / [자율성] 추가 → 4축 모두 cover.
+ *     LLM prompt (auto-compound-runner) 에도 같은 라벨 가이드를 명시하여
+ *     형식 강제. 새 라벨이 안 나오면 기존 5분기로 fallback (호환).
+ */
+const AXIS_REFS_BY_KIND = {
+    safety: ['quality_safety'],
+    autonomy: ['autonomy'],
+    workflow: ['judgment_philosophy'],
+    thinking: ['judgment_philosophy'],
+    preference: ['communication_style'],
+};
+/**
+ * LLM 출력 텍스트(`[카테고리] 설명` 형식)를 5개 kind 로 분류.
+ *
+ * 라벨 우선순위 (위에서 아래):
+ *   1. [품질안전] → safety
+ *   2. [자율성] → autonomy
+ *   3. [워크플로우] OR "순서"/"→" 토큰 → workflow
+ *   4. [의사결정] → thinking
+ *   5. 그 외 → preference (default)
+ */
+export function classifyBehaviorKind(text) {
+    if (text.includes('[품질안전]'))
+        return 'safety';
+    if (text.includes('[자율성]'))
+        return 'autonomy';
+    if (text.includes('[워크플로우]') || text.includes('순서') || text.includes('→'))
+        return 'workflow';
+    if (text.includes('[의사결정]'))
+        return 'thinking';
+    return 'preference';
+}
+export function mapKindToAxisRefs(kind) {
+    return [...AXIS_REFS_BY_KIND[kind]];
+}

package/dist/core/dashboard.d.ts

@@ -86,6 +86,13 @@ export declare function collectLifecycleActivity(): LifecycleActivity;
 export declare function collectSessionHistory(): SessionHistory;
 /** Collect hook error data. */
 export declare function collectHookHealth(): HookHealth;
+export interface MultiHostData {
+    claude: number;
+    codex: number;
+    total: number;
+}
+/** Collect multi-host evidence distribution from host-mismatch store. */
+export declare function collectMultiHostData(): MultiHostData;
 export interface LearningCurve {
     correctionsLast7d: number;
     correctionsPrev7d: number;

package/dist/core/dashboard.js

@@ -23,6 +23,7 @@ const require = createRequire(import.meta.url);
 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';
+import { summarizeAllByHost } from '../store/host-mismatch.js';
 // ── ANSI color helpers ──
 const BOLD = '\x1b[1m';
 const DIM = '\x1b[2m';
@@ -356,6 +357,34 @@ function renderHookHealth(data) {
     lines.push(tableSep(widths, false, true));
     return lines.join('\n');
 }
+/** Collect multi-host evidence distribution from host-mismatch store. */
+export function collectMultiHostData() {
+    try {
+        return summarizeAllByHost();
+    }
+    catch {
+        return { claude: 0, codex: 0, total: 0 };
+    }
+}
+function renderMultiHost(data) {
+    const lines = [];
+    lines.push(`  ${bold(cyan('Multi-Host Evidence'))}`);
+    lines.push('');
+    if (data.total === 0) {
+        lines.push(`  ${dim('No evidence recorded yet.')}`);
+        return lines.join('\n');
+    }
+    const claudePct = Math.round((data.claude / data.total) * 100);
+    const codexPct = Math.round((data.codex / data.total) * 100);
+    lines.push(`  Hosts        claude:${data.claude} (${claudePct}%)  codex:${data.codex} (${codexPct}%)  total:${data.total}`);
+    // skew 경고: 80%+ 집중
+    const maxShare = Math.max(claudePct, codexPct);
+    if (data.total >= 5 && maxShare >= 80) {
+        const dominant = data.claude >= data.codex ? 'claude' : 'codex';
+        lines.push(`  ${yellow(`⚠ ${dominant} 에 ${maxShare}% 집중 — 다른 host 데이터 부족`)}`);
+    }
+    return lines.join('\n');
+}
 /**
  * Learning Curve 수집.
  * evidence 파일(교정 기록)과 compound 활용률을 교차 분석하여 "쓸수록 나아진다"를 정량화.
@@ -523,6 +552,7 @@ export function renderDashboard() {
     const session = collectSessionHistory();
     const hookHealth = collectHookHealth();
     const learning = collectLearningCurve();
+    const multiHost = collectMultiHostData();
     const divider = `  ${dim('─'.repeat(50))}`;
     const sections = [
         '',
@@ -538,6 +568,8 @@ export function renderDashboard() {
         divider,
         renderInjectionActivity(injection),
         divider,
+        renderMultiHost(multiHost),
+        divider,
         renderReflectionData(reflection),
         divider,
         renderLifecycleActivity(lifecycle),

package/dist/core/doctor.js

@@ -5,6 +5,7 @@ import { execFileSync } from 'node:child_process';
 import { FORGEN_HOME, LAB_DIR, ME_BEHAVIOR, ME_DIR, ME_SOLUTIONS, ME_RULES, ME_SKILLS, PACKS_DIR, SESSIONS_DIR, STATE_DIR } from './paths.js';
 import { getTimingStats } from '../hooks/shared/hook-timing.js';
 import { countSessionScopedFiles, pruneState } from './state-gc.js';
+import { summarizeAllByHost } from '../store/host-mismatch.js';
 /** ~/.claude/projects/ — Claude Code 세션 저장 경로 */
 const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 let currentSection = '';
@@ -34,6 +35,58 @@ function commandExists(cmd) {
         return false;
     }
 }
+/** parity-result.json 내용에서 경과 시간을 사람이 읽기 좋은 문자열로 변환 */
+function relativeTime(isoString) {
+    const diffMs = Date.now() - new Date(isoString).getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    if (diffDays === 0) {
+        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+        if (diffHours === 0) {
+            const diffMins = Math.floor(diffMs / (1000 * 60));
+            return `${diffMins}m ago`;
+        }
+        return `${diffHours}h ago`;
+    }
+    return `${diffDays}d ago`;
+}
+/** [Codex Parity] 섹션 렌더링 — ~/.forgen/state/parity-result.json 신선도 검사 */
+function renderCodexParity() {
+    console.log('  [Codex Parity]');
+    const parityPath = path.join(STATE_DIR, 'parity-result.json');
+    if (!fs.existsSync(parityPath)) {
+        console.log('  △ Codex parity 미실행 — tests/e2e/codex/run-parity.sh 또는 forgen parity codex');
+        return;
+    }
+    let data;
+    try {
+        data = JSON.parse(fs.readFileSync(parityPath, 'utf-8'));
+    }
+    catch {
+        console.log('  ✗ Codex parity — parity-result.json 파싱 실패');
+        return;
+    }
+    if (data.passed === null || data.passed === undefined) {
+        console.log('  △ Codex parity dry-run only — 실 실행 필요');
+        return;
+    }
+    if (!data.passed) {
+        const timeStr = data.at ? relativeTime(data.at) : 'unknown';
+        const detail = data.result ?? data.note ?? 'no detail';
+        console.log(`  ✗ Codex parity FAILED (at: ${timeStr}, detail: ${detail})`);
+        return;
+    }
+    // passed === true
+    const timeStr = data.at ? relativeTime(data.at) : 'unknown';
+    const version = data.version ? ` version ${data.version}` : '';
+    const diffMs = data.at ? Date.now() - new Date(data.at).getTime() : Infinity;
+    const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+    if (diffMs > sevenDaysMs) {
+        console.log(`  △ Codex parity green but stale (last run: ${timeStr}) — 재실행 권장`);
+    }
+    else {
+        console.log(`  ✓ Codex parity green (last run: ${timeStr},${version})`);
+    }
+}
 export async function runDoctor(opts = {}) {
     failedChecks = [];
     console.log('\n  Forgen — Diagnostics\n');
@@ -386,6 +439,45 @@ export async function runDoctor(opts = {}) {
         // git 저장소가 아니거나 origin이 없으면 표시하지 않음
         console.log('  git remote: (none)');
     }
+    // P4 셀프 가드: fix:feat 비율 30% 초과 시 회귀 패턴 의심 경고.
+    try {
+        const { computeFixFeatRatio, formatFixRatio } = await import('./git-stats.js');
+        const ratio = computeFixFeatRatio();
+        if (ratio.available) {
+            console.log(`  ${formatFixRatio(ratio)}`);
+            if (ratio.exceedsThreshold) {
+                console.log('  ⚠ fix:feat 비율이 임계값을 초과했습니다. "이거 고치면 저거 버그난다" 패턴 의심 — 검증 레이어 invariant 점검 권장.');
+            }
+        }
+    }
+    catch { /* fail-open */ }
+    console.log();
+    // [Multi-Host] — host 별 evidence 분포
+    console.log('  [Multi-Host]');
+    try {
+        const hostStats = summarizeAllByHost();
+        if (hostStats.total === 0) {
+            console.log('  No evidence recorded yet.');
+        }
+        else {
+            const claudePct = hostStats.total > 0 ? Math.round((hostStats.claude / hostStats.total) * 100) : 0;
+            const codexPct = hostStats.total > 0 ? Math.round((hostStats.codex / hostStats.total) * 100) : 0;
+            console.log(`  Registered hosts: claude, codex`);
+            console.log(`  Evidence by host: claude:${hostStats.claude} (${claudePct}%)  codex:${hostStats.codex} (${codexPct}%)  total:${hostStats.total}`);
+            // 한 host 가 80% 이상이면 skew 경고
+            const maxShare = Math.max(claudePct, codexPct);
+            if (hostStats.total >= 5 && maxShare >= 80) {
+                const dominant = claudePct >= codexPct ? 'claude' : 'codex';
+                console.log(`  ⚠ evidence 가 ${dominant} 에 ${maxShare}% 집중됨 — 다른 host 에서 학습 데이터 부족 가능`);
+            }
+        }
+    }
+    catch {
+        console.log('  Unable to read host evidence data.');
+    }
+    console.log();
+    // [Codex Parity] — parity-result.json 신선도 검사 (v0.4.2 패턴 확장)
+    renderCodexParity();
     console.log();
     // [Summary] — 최종 상태 요약과 복구 액션을 한눈에 보이게
     console.log('  [Summary]');

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

@@ -0,0 +1,36 @@
+/**
+ * Git Stats — P4 셀프 가드 (2026-04-27)
+ *
+ * 최근 N커밋의 conventional commit 분포를 측정해 fix:feat 비율을 계산.
+ * 정상 OSS 권장은 fix < 20%. 36% 초과 시 회귀 패턴 의심 — forgen 의 자기 메타 가드.
+ *
+ * 이번 세션 측정값: v0.4.1 시점 fix 비율 36% (정상의 약 2배). 이 코드가 다음 릴리즈
+ * 시 같은 비율을 자동 노출하여 사용자가 회귀 패턴을 빠르게 인지하게 한다.
+ */
+export interface FixRatioStats {
+    windowSize: number;
+    fixCount: number;
+    featCount: number;
+    /** fix / (fix + feat), 0~1. fix+feat=0 이면 0. */
+    ratio: number;
+    threshold: number;
+    exceedsThreshold: boolean;
+    /** git 명령이 성공했는지 (저장소 외부 또는 git 미설치 시 false). */
+    available: boolean;
+}
+/**
+ * git log --no-merges -N 결과에서 conventional commit 형식의 fix/feat 만 카운트.
+ *
+ * 분류:
+ *   - `feat: ...` / `feat(scope): ...` → feat
+ *   - `fix: ...` / `fix(scope): ...` → fix (단, scope ∈ {test, tests, docs, doc} 제외)
+ *   - 그 외 (chore, refactor, docs, style, test, hash 없는 라인) → 무시
+ *
+ * fix(test):, fix(docs): 가 제외되는 이유: 사소한 노이즈 fix 가 회귀 신호를
+ * 흐리지 않도록. 진짜 위험은 fix(core), fix(hook), fix(api) 같은 logic fix.
+ */
+export declare function computeFixFeatRatio(cwd?: string, windowSize?: number, threshold?: number): FixRatioStats;
+/** 테스트용 — git log 출력 텍스트를 직접 파싱. */
+export declare function parseGitLog(rawLog: string, windowSize?: number, threshold?: number): FixRatioStats;
+/** 사람용 한 줄 라벨. */
+export declare function formatFixRatio(s: FixRatioStats): string;

package/dist/core/git-stats.js

@@ -0,0 +1,79 @@
+/**
+ * Git Stats — P4 셀프 가드 (2026-04-27)
+ *
+ * 최근 N커밋의 conventional commit 분포를 측정해 fix:feat 비율을 계산.
+ * 정상 OSS 권장은 fix < 20%. 36% 초과 시 회귀 패턴 의심 — forgen 의 자기 메타 가드.
+ *
+ * 이번 세션 측정값: v0.4.1 시점 fix 비율 36% (정상의 약 2배). 이 코드가 다음 릴리즈
+ * 시 같은 비율을 자동 노출하여 사용자가 회귀 패턴을 빠르게 인지하게 한다.
+ */
+import { execFileSync } from 'node:child_process';
+const DEFAULT_THRESHOLD = 0.30;
+const DEFAULT_WINDOW = 30;
+const SCOPE_EXCLUSIONS = new Set(['test', 'tests', 'docs', 'doc']);
+/**
+ * git log --no-merges -N 결과에서 conventional commit 형식의 fix/feat 만 카운트.
+ *
+ * 분류:
+ *   - `feat: ...` / `feat(scope): ...` → feat
+ *   - `fix: ...` / `fix(scope): ...` → fix (단, scope ∈ {test, tests, docs, doc} 제외)
+ *   - 그 외 (chore, refactor, docs, style, test, hash 없는 라인) → 무시
+ *
+ * fix(test):, fix(docs): 가 제외되는 이유: 사소한 노이즈 fix 가 회귀 신호를
+ * 흐리지 않도록. 진짜 위험은 fix(core), fix(hook), fix(api) 같은 logic fix.
+ */
+export function computeFixFeatRatio(cwd = process.cwd(), windowSize = DEFAULT_WINDOW, threshold = DEFAULT_THRESHOLD) {
+    try {
+        const out = execFileSync('git', ['log', '--no-merges', '--oneline', `-${windowSize}`], { cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        return parseGitLog(out, windowSize, threshold);
+    }
+    catch {
+        return makeUnavailable(windowSize, threshold);
+    }
+}
+/** 테스트용 — git log 출력 텍스트를 직접 파싱. */
+export function parseGitLog(rawLog, windowSize = DEFAULT_WINDOW, threshold = DEFAULT_THRESHOLD) {
+    const lines = rawLog.trim().split('\n').filter(Boolean);
+    let fix = 0;
+    let feat = 0;
+    for (const line of lines) {
+        const msg = line.replace(/^[a-f0-9]{4,40}\s+/, '');
+        const m = msg.match(/^(fix|feat)(?:\(([^)]+)\))?:/);
+        if (!m)
+            continue;
+        const type = m[1];
+        const scope = (m[2] ?? '').toLowerCase().trim();
+        if (type === 'fix' && SCOPE_EXCLUSIONS.has(scope))
+            continue;
+        if (type === 'fix')
+            fix++;
+        else
+            feat++;
+    }
+    const total = fix + feat;
+    const ratio = total === 0 ? 0 : fix / total;
+    return {
+        windowSize,
+        fixCount: fix,
+        featCount: feat,
+        ratio,
+        threshold,
+        exceedsThreshold: ratio > threshold,
+        available: true,
+    };
+}
+function makeUnavailable(windowSize, threshold) {
+    return {
+        windowSize, fixCount: 0, featCount: 0, ratio: 0,
+        threshold, exceedsThreshold: false, available: false,
+    };
+}
+/** 사람용 한 줄 라벨. */
+export function formatFixRatio(s) {
+    if (!s.available)
+        return 'fix:feat ratio    n/a    (git unavailable)';
+    const pct = (s.ratio * 100).toFixed(0);
+    const thresholdPct = (s.threshold * 100).toFixed(0);
+    const flag = s.exceedsThreshold ? `  ⚠ over ${thresholdPct}%` : '';
+    return `fix:feat ratio    ${pct}%   (${s.fixCount}/${s.fixCount + s.featCount} in last ${s.windowSize})${flag}`;
+}