@wooojin/forgen 0.4.1 → 0.4.4

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

@@ -12,38 +12,71 @@
 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/;
+        const MAX_ATTEMPTS = 2;
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                return execFileSync('claude', args, opts);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                const match = msg.match(TRANSIENT);
+                if (attempt < MAX_ATTEMPTS && match) {
+                    process.stderr.write(`[forgen-auto-compound] ${match[0]} on attempt ${attempt}/${MAX_ATTEMPTS}, retrying in 3s (auto-recovery)...\n`);
+                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 3000);
+                    continue;
+                }
+                if (match) {
+                    process.stderr.write(`[forgen-auto-compound] ${match[0]} after ${attempt}/${MAX_ATTEMPTS} attempts — giving up (fail-open)\n`);
+                }
+                throw e;
             }
-            throw e;
         }
+        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');
     }
-    throw new Error('unreachable');
+    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 +238,7 @@ function mergeOrCreateBehavior(dir, newContent, kind, today) {
             fs.writeFileSync(filePath, updated);
             return true;
         }
-        catch {
-            continue;
-        }
+        catch { }
     }
     return false;
 }
@@ -308,14 +339,15 @@ ${sanitizedSummary.slice(0, 6000)}
 관찰된 패턴을 다음 형식으로 1~3개만 출력해주세요 (없으면 "관찰된 패턴 없음"):
 - [카테고리] 패턴 설명 (관찰 근거)
 
-카테고리: 커뮤니케이션/작업습관/기술선호/의사결정/워크플로우
+카테고리: 커뮤니케이션/작업습관/기술선호/의사결정/워크플로우/품질안전/자율성
 
-특히 "워크플로우" 카테고리에 주목하세요:
-- 사용자가 반복하는 작업 순서 패턴 (예: "항상 테스트 먼저 작성 → 구현 → 리팩토링 순서로 진행")
-- 특정 상황에서의 판단 규칙 (예: "PR 리뷰 시 보안 → 테스트 → 코드 품질 순서로 확인")
-- 조건부 접근법 (예: "버그 수정 시 재현 테스트부터 작성, 성능 이슈면 프로파일링부터")
+각 카테고리 가이드:
+- "워크플로우": 반복하는 작업 순서, 판단 규칙, 조건부 접근법 (예: "테스트 먼저 → 구현 → 리팩토링 순서")
+- "품질안전": 검증/테스트/안전성 관련 강한 선호 (예: "프로덕션 배포 전 Docker e2e 의무", "mock-only 검증 거부")
+- "자율성": 확인/독립 결정 관련 선호 (예: "사소한 변경은 묻지 않고 진행", "큰 결정은 반드시 확인")
 
 워크플로우 패턴이 감지되면 반드시 구체적인 순서를 포함하세요.
+품질안전/자율성 패턴은 4축 개인화의 입력이므로 quality/autonomy 신호가 명확하면 반드시 해당 라벨을 사용하세요 (커뮤니케이션/작업습관 으로 흡수 금지).
 
 기존 패턴과 중복이면 건너뛰세요.${existingBehaviorPatterns}
 
@@ -346,11 +378,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 +399,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 },
             });
@@ -401,7 +430,9 @@ ${profileContext}
   "pack_direction": null 또는 "opposite_quality" 또는 "opposite_autonomy",
   "profile_delta": {
     "quality_safety": { "verification_depth": 0.0, "stop_threshold": 0.0, "change_conservatism": 0.0 },
-    "autonomy": { "confirmation_independence": 0.0, "assumption_tolerance": 0.0, "scope_expansion_tolerance": 0.0, "approval_threshold": 0.0 }
+    "autonomy": { "confirmation_independence": 0.0, "assumption_tolerance": 0.0, "scope_expansion_tolerance": 0.0, "approval_threshold": 0.0 },
+    "judgment_philosophy": { "minimal_change_bias": 0.0, "abstraction_bias": 0.0, "evidence_first_bias": 0.0 },
+    "communication_style": { "verbosity": 0.0, "structure": 0.0, "teaching_bias": 0.0 }
   }
 }
 
@@ -469,6 +500,26 @@ ${sanitizedSummary.slice(0, 4000)}
                             }
                         }
                     }
+                    if (parsed.profile_delta.judgment_philosophy) {
+                        const d = parsed.profile_delta.judgment_philosophy;
+                        const f = profile.axes.judgment_philosophy.facets;
+                        for (const [k, v] of Object.entries(d)) {
+                            if (typeof v === 'number' && Math.abs(v) > 0.001 && k in f) {
+                                f[k] = clamp(f[k] + v);
+                                changed = true;
+                            }
+                        }
+                    }
+                    if (parsed.profile_delta.communication_style) {
+                        const d = parsed.profile_delta.communication_style;
+                        const f = profile.axes.communication_style.facets;
+                        for (const [k, v] of Object.entries(d)) {
+                            if (typeof v === 'number' && Math.abs(v) > 0.001 && k in f) {
+                                f[k] = clamp(f[k] + v);
+                                changed = true;
+                            }
+                        }
+                    }
                     if (changed) {
                         profile.metadata.updated_at = new Date().toISOString();
                         fs.writeFileSync(V1_PROFILE, JSON.stringify(profile, null, 2));

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}`;
+}

package/dist/core/harness.d.ts

@@ -9,7 +9,7 @@
  * - Lines 50-120: Rule file injection, gitignore, compound memory
  * - Lines 120+: prepareHarness — main orchestration
  */
-import { type RuntimeHost } from './types.js';
+import type { RuntimeHost } from './types.js';
 import { rollbackSettings } from './settings-lock.js';
 import { type V1BootstrapResult } from './v1-bootstrap.js';
 export interface V1HarnessContext {

package/dist/core/harness.js

@@ -326,32 +326,39 @@ export async function prepareHarness(cwd, options = {}) {
         }
         // 3. 환경 확인
         const inTmux = !!process.env.TMUX;
-        // 4. Claude Code 설정 주입 (환경변수 + trust 기반 permissions).
+        // 4-7. Claude artifact 작업 (settings.json + agents + rules + slash commands).
         //
-        // Audit fix #1 (2026-04-21): acquireLock에서 live holder 감지 시
-        // SettingsLockError가 throw될 수 있다. 사용자 작업 자체를 실패시키지
-        // 않도록 warn 후 계속 진행 (이번 실행에서 settings는 기존 값 유지).
+        // feat/codex-support P1-7 (2026-04-27): runtime === 'codex' 시 *.claude/* 계열
+        // 작업은 *no-op*. Codex 측 동치 prep 은 Phase 3 (install-codex.ts 의 prompts +
+        // AGENTS.md inject) 에서 처리. 본 분기는 *Claude artifact 가 Codex 환경을
+        // 오염시키지 않도록* 보호하는 비대칭 게이트.
         const pkgRoot = getPackageRoot();
         const env = buildEnv(cwd, v1Result.session?.session_id, runtime);
-        try {
-            injectSettings(env, v1Result, runtime, cwd, pkgRoot);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            if (msg.includes('settings.json lock') || msg.includes('SettingsLockError')) {
-                console.error(`[forgen] ${msg} — settings 갱신 스킵, 이전 값 유지`);
+        if (runtime === 'claude') {
+            // 4. settings.json 인젝션
+            try {
+                injectSettings(env, v1Result, runtime, cwd, pkgRoot);
             }
-            else {
-                throw e;
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                if (msg.includes('settings.json lock') || msg.includes('SettingsLockError')) {
+                    console.error(`[forgen] ${msg} — settings 갱신 스킵, 이전 값 유지`);
+                }
+                else {
+                    throw e;
+                }
             }
+            // 5. 에이전트 설치
+            installAgents(cwd, pkgRoot);
+            // 6. 규칙 파일 생성 + 주입
+            const ruleFiles = generateClaudeRuleFiles(cwd, v1Result.renderedRules);
+            injectClaudeRuleFiles(cwd, ruleFiles);
+            // 7. 슬래시 명령 설치
+            installSlashCommands(cwd, pkgRoot);
+        }
+        else {
+            log.debug(`prepareHarness: runtime=${runtime} — Claude artifact prep skipped (Phase 3 handles Codex prep)`);
         }
-        // 5. 에이전트 설치
-        installAgents(cwd, pkgRoot);
-        // 6. 규칙 파일 생성 및 주입 (v1 부트스트랩 결과의 renderedRules를 직접 전달)
-        const ruleFiles = generateClaudeRuleFiles(cwd, v1Result.renderedRules);
-        injectClaudeRuleFiles(cwd, ruleFiles);
-        // 7. 슬래시 명령 설치
-        installSlashCommands(cwd, pkgRoot);
         // 8. tmux 바인딩 등록
         if (inTmux) {
             await registerTmuxBindings();