@wooojin/forgen 0.4.0 → 0.4.3

package/dist/checks/self-score-deflation.js

@@ -0,0 +1,108 @@
+/**
+ * Forgen v0.4.1 — TEST-2: 자가 점수 인플레이션 가드
+ *
+ * Claude 가 자신의 작업 품질/확신도/완성도를 **숫자**로 상향 선언하면서 해당
+ * 턴(또는 세션)에 측정 도구 호출이 0 건이면 block. TEST-1 (사실 vs 합의) 보다
+ * 강한 신호 — 구체적 숫자 인플레이션은 합의-기반 자기-아부(sycophancy)의
+ * 가장 또렷한 표식.
+ *
+ * 배경 (RC2): v0.4.0 self-interview 에서 "8/10", "신뢰도 90%", "0.85 → 0.95"
+ *   같은 자가 점수가 턴마다 올라갔지만 `npm test` / `curl` / `Read` 등 실제
+ *   측정 호출은 0건. TEST-1 이 서술체 사실 주장을 잡았다면, TEST-2 는 **숫자**
+ *   점수의 인플레이션에 초점을 맞춘다.
+ *
+ * 순수 함수 — Stop hook block 경로에 붙는다.
+ */
+/**
+ * 측정성 도구 — **숫자 점수**를 뒷받침할 수 있는 실 **실행** 범주.
+ *
+ * v0.4.1 coverage fix (2026-04-24 buyer-day1 R4 관찰): 이전에는 Read/Edit/Write/
+ * Grep/Glob 도 측정으로 간주했으나, 파일 "읽기/수정" 은 "신뢰도 95/100" 같은
+ * 수치 판정을 뒷받침 못 함. Read 1회면 minMeasurements=1 충족되어 block 회피.
+ * 실제 구매자 시나리오: Claude 가 자가평가 전에 대상 파일 한 번 Read 하면
+ * TEST-2 무력화 — 가드의 본 의도 훼손.
+ *
+ * 새 기준: **실행 결과** 만 측정 — `Bash` (npm test / curl / node --check 등)
+ * 와 `NotebookEdit` (cell 실행). 읽기 전용 도구는 수치 점수의 근거가 될 수 없음.
+ */
+const MEASUREMENT_TOOLS = new Set([
+    'Bash',
+    'NotebookEdit',
+]);
+/**
+ * "자가 점수" 신호 — 숫자 + 품질/완성도/확신도 컨텍스트.
+ *  - "신뢰도 90%", "품질 점수 85/100", "확신도 0.9", "8/10", "90점"
+ *  - "0.7 → 0.9" 같은 증감 표기
+ *
+ * 이 regex 들은 *숫자 그 자체* 만 매칭하지 않고 품질-관련 명사와 같이 나타날 때만
+ * 매칭하도록 좁힘 (false positive 방지).
+ */
+const SELF_SCORE_PATTERNS = [
+    // "신뢰도 90%" / "quality 85%" / "확신도 0.9"
+    /(신뢰도|확신도|완성도|품질|자신감|confidence|quality|completeness)[\s:：]*(\d+(?:\.\d+)?)\s*(%|점|\/\s*\d+|\/100|\/10)?/gi,
+    // "0.85 → 0.95" / "7 -> 9" score delta
+    /(\d+(?:\.\d+)?)\s*(?:→|->|–>|~>)\s*(\d+(?:\.\d+)?)/g,
+    // "8/10", "85/100" — 단독 분수 점수 (앞뒤 품질 컨텍스트 확인은 하지 않지만 보수적 매칭)
+    /\b(\d+(?:\.\d+)?)\s*\/\s*(10|100)\b/g,
+    // 별 점수 "⭐⭐⭐⭐" 4개 이상
+    /⭐{4,}/g,
+];
+function extractDeltas(text) {
+    const re = /(\d+(?:\.\d+)?)\s*(?:→|->|–>|~>)\s*(\d+(?:\.\d+)?)/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const from = Number(m[1]);
+        const to = Number(m[2]);
+        if (Number.isFinite(from) && Number.isFinite(to))
+            out.push({ from, to });
+    }
+    return out;
+}
+function findScoreSignals(text, max = 3) {
+    const out = [];
+    for (const p of SELF_SCORE_PATTERNS) {
+        if (out.length >= max)
+            break;
+        // 각 호출마다 lastIndex 초기화를 위해 새 RegExp 생성
+        const re = new RegExp(p.source, p.flags);
+        let m;
+        while ((m = re.exec(text)) !== null && out.length < max) {
+            out.push(m[0]);
+        }
+    }
+    return out;
+}
+export function checkSelfScoreInflation(input) {
+    const minDelta = input.minDelta ?? 0;
+    const minMeasurements = input.minMeasurements ?? 1;
+    const scoreSignals = findScoreSignals(input.text);
+    const allDeltas = extractDeltas(input.text);
+    const positiveDeltas = allDeltas.filter((d) => d.to - d.from > minDelta);
+    const measurementCount = input.recentTools.filter((t) => MEASUREMENT_TOOLS.has(t)).length;
+    const measurementMissing = measurementCount < minMeasurements;
+    // 인플레이션 신호가 하나라도 있고 측정이 없으면 block
+    const hasInflationSignal = scoreSignals.length > 0 || positiveDeltas.length > 0;
+    const block = hasInflationSignal && measurementMissing;
+    let reason = '';
+    if (block) {
+        const parts = [];
+        if (positiveDeltas.length > 0) {
+            const sample = positiveDeltas.slice(0, 2).map((d) => `${d.from}→${d.to}`).join(', ');
+            parts.push(`자가 점수 상승 선언 ${positiveDeltas.length}건 (${sample})`);
+        }
+        if (scoreSignals.length > 0) {
+            parts.push(`점수 표현 ${scoreSignals.length}건 ("${scoreSignals[0]}")`);
+        }
+        parts.push(`측정 도구 호출 ${measurementCount}회 (< ${minMeasurements}) — 숫자 변동을 뒷받침할 실행/확인 증거 없음`);
+        parts.push('block: 테스트/빌드/curl 실행 결과를 턴에 포함하여 재응답');
+        reason = parts.join('. ');
+    }
+    return {
+        block,
+        scoreSignals,
+        deltas: positiveDeltas,
+        measurementCount,
+        reason,
+    };
+}

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();
@@ -226,6 +296,22 @@ const commands = [
             await handleInspect(['violations', '--last', '1']);
         },
     },
+    {
+        name: 'recall',
+        description: 'Show recent compound recalls (matched solutions) with optional body preview.',
+        handler: async (args) => {
+            const { handleRecall } = await import('./core/recall-cli.js');
+            await handleRecall(args);
+        },
+    },
+    {
+        name: 'migrate',
+        description: 'One-shot schema migrations (implicit-feedback category backfill).',
+        handler: async (args) => {
+            const { handleMigrate } = await import('./core/migrate-cli.js');
+            await handleMigrate(args);
+        },
+    },
     {
         name: 'suppress-rule',
         description: '[alias: rule suppress] Disable a rule by id/prefix. Hard rules refused.',
@@ -391,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);
     }
@@ -425,17 +512,22 @@ 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>
                                     Rule management (see: forgen rule help)
-    forgen stats                    One-screen trust-layer dashboard
+    forgen stats                    One-screen trust-layer dashboard (+ philosophy)
     forgen last-block               Show the most recent block event
+    forgen recall [--limit N] [--show]
+                                    최근 compound 주입 이력 (solution body preview)
+    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
-    forgen init                     Initialize project
+    forgen init                     Initialize project (+ starter-pack solutions)
     forgen config hooks             Hook management
     forgen mcp                      MCP server management
     forgen skill promote|list       Skill management

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

@@ -11,47 +11,74 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 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) {
     process.exit(1);
 }
-const FORGEN_HOME = path.join(os.homedir(), '.forgen');
-const SOLUTIONS_DIR = path.join(FORGEN_HOME, 'me', 'solutions');
-const BEHAVIOR_DIR = path.join(FORGEN_HOME, 'me', 'behavior');
+const SOLUTIONS_DIR = path.join(ME_DIR, 'solutions');
+const BEHAVIOR_DIR = path.join(ME_DIR, 'behavior');
 /** Lightweight quality gate for auto-extracted solution files */
 /** Toxicity patterns — code-context only to avoid false positives on prose */
 const SOLUTION_TOXICITY_PATTERNS = [/@ts-ignore/i, /:\s*any\b/, /\/\/\s*TODO\b/];
@@ -206,9 +233,7 @@ function mergeOrCreateBehavior(dir, newContent, kind, today) {
             fs.writeFileSync(filePath, updated);
             return true;
         }
-        catch {
-            continue;
-        }
+        catch { }
     }
     return false;
 }
@@ -309,14 +334,15 @@ ${sanitizedSummary.slice(0, 6000)}
 관찰된 패턴을 다음 형식으로 1~3개만 출력해주세요 (없으면 "관찰된 패턴 없음"):
 - [카테고리] 패턴 설명 (관찰 근거)
 
-카테고리: 커뮤니케이션/작업습관/기술선호/의사결정/워크플로우
+카테고리: 커뮤니케이션/작업습관/기술선호/의사결정/워크플로우/품질안전/자율성
 
-특히 "워크플로우" 카테고리에 주목하세요:
-- 사용자가 반복하는 작업 순서 패턴 (예: "항상 테스트 먼저 작성 → 구현 → 리팩토링 순서로 진행")
-- 특정 상황에서의 판단 규칙 (예: "PR 리뷰 시 보안 → 테스트 → 코드 품질 순서로 확인")
-- 조건부 접근법 (예: "버그 수정 시 재현 테스트부터 작성, 성능 이슈면 프로파일링부터")
+각 카테고리 가이드:
+- "워크플로우": 반복하는 작업 순서, 판단 규칙, 조건부 접근법 (예: "테스트 먼저 → 구현 → 리팩토링 순서")
+- "품질안전": 검증/테스트/안전성 관련 강한 선호 (예: "프로덕션 배포 전 Docker e2e 의무", "mock-only 검증 거부")
+- "자율성": 확인/독립 결정 관련 선호 (예: "사소한 변경은 묻지 않고 진행", "큰 결정은 반드시 확인")
 
 워크플로우 패턴이 감지되면 반드시 구체적인 순서를 포함하세요.
+품질안전/자율성 패턴은 4축 개인화의 입력이므로 quality/autonomy 신호가 명확하면 반드시 해당 라벨을 사용하세요 (커뮤니케이션/작업습관 으로 흡수 금지).
 
 기존 패턴과 중복이면 건너뛰세요.${existingBehaviorPatterns}
 
@@ -347,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) {
@@ -368,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 },
             });
@@ -383,10 +406,8 @@ ${sanitizedSummary.slice(0, 4000)}
     }
     // 3단계: 세션 학습 요약 (SessionLearningSummary) 생성
     try {
-        const FORGEN_HOME = path.join(os.homedir(), '.forgen');
-        const V1_ME_DIR = path.join(FORGEN_HOME, 'me');
-        const V1_PROFILE = path.join(V1_ME_DIR, 'forge-profile.json');
-        const V1_EVIDENCE_DIR = path.join(V1_ME_DIR, 'behavior');
+        const V1_PROFILE = path.join(ME_DIR, 'forge-profile.json');
+        const V1_EVIDENCE_DIR = path.join(ME_DIR, 'behavior');
         if (fs.existsSync(V1_PROFILE)) {
             const currentProfile = loadProfile();
             let profileContext = '';
@@ -485,8 +506,9 @@ ${sanitizedSummary.slice(0, 4000)}
         process.stderr.write(`[forgen-auto-compound] session learning: ${e instanceof Error ? e.message : String(e)}\n`);
     }
     // Step 4: prefer-from-now / avoid-this 교정 → scope:'me' 영구 규칙 승격
+    let promotedCount = 0;
     try {
-        const promotedCount = promoteSessionCandidates(sessionId);
+        promotedCount = promoteSessionCandidates(sessionId);
         if (promotedCount > 0) {
             process.stderr.write(`[forgen-auto-compound] promoted ${promotedCount} correction(s) to permanent rules\n`);
         }
@@ -494,6 +516,21 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-auto-compound] rule promotion: ${e instanceof Error ? e.message : String(e)}\n`);
     }
+    // H2: count newly extracted solutions (post-quality-gate) for Stop hook 알림.
+    // solutionsBefore 스냅샷 vs 현재 디스크 상태 차분 → "N개 패턴 학습됨" 1줄.
+    let extractedSolutionsCount = 0;
+    try {
+        if (fs.existsSync(SOLUTIONS_DIR)) {
+            const current = fs.readdirSync(SOLUTIONS_DIR).filter((f) => f.endsWith('.md'));
+            for (const f of current) {
+                if (!solutionsBefore.has(f))
+                    extractedSolutionsCount++;
+            }
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-auto-compound] solution count failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
     // Step 5: meta-learning (HyperAgents-inspired self-tuning)
     try {
         const { runMetaLearning } = await import('../engine/meta-learning/runner.js');
@@ -508,10 +545,61 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-meta] ${e instanceof Error ? e.message : String(e)}\n`);
     }
-    // 완료 기록
+    // Step 5.5 (v0.4.1): state hygiene — 세션 스코프 ephemeral 파일 7일 retention
+    // 자동 정리. 이전에는 `forgen doctor --prune-state` 수동만 있어서 injection-cache
+    // 2343 / modified-files 431 처럼 수천 파일 누적. 몇 달 사용하면 10만+ 파일 → stat
+    // 호출 느려지고 디스크 낭비. auto-compound 마다 호출되면 자연스레 정돈.
+    try {
+        const { pruneState } = await import('./state-gc.js');
+        const report = pruneState({ dryRun: false });
+        if (report.pruned > 0) {
+            const mb = (report.bytesFreed / 1024 / 1024).toFixed(2);
+            process.stderr.write(`[forgen-gc] pruned ${report.pruned} stale state files (${mb} MB freed)\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-gc] state prune failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
+    // Step 6 (v0.4.1): rule lifecycle 자동 실행 — rule 의 violations/bypass/drift
+    // 신호에 따른 자동 강등/승격. 이전에는 CLI (`forgen rule scan --apply`) 수동
+    // 호출만 있어서 구매자가 몇 주 써도 rule 정비 안 됨 → 쓸모없는 rule 이 계속
+    // active. 판매 관점 심각한 "자동 학습 단절". auto-compound-runner 끝에 자동
+    // 실행해 세션마다 rule 품질 유지.
+    try {
+        const { handleLifecycleScan } = await import('../engine/lifecycle/lifecycle-cli.js');
+        // silent mode 로 돌리기 위해 stdout 을 임시 리다이렉트 (내부가 console.log 씀)
+        const origLog = console.log;
+        let applied = 0;
+        console.log = (...args) => {
+            const msg = args.join(' ');
+            const match = msg.match(/apply(?:ied)?\s+(\d+)/i);
+            if (match)
+                applied = Number(match[1]);
+        };
+        try {
+            await handleLifecycleScan(['--apply']);
+        }
+        finally {
+            console.log = origLog;
+        }
+        if (applied > 0) {
+            process.stderr.write(`[forgen-meta] rule lifecycle: ${applied} event(s) applied\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-meta] lifecycle scan failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
+    // 완료 기록 — H2: Stop hook 알림용으로 extractedSolutions / promotedRules 포함.
+    // noticeShown=false 로 시작해서 Stop hook 가 최초 1회만 surface.
     const statePath = path.join(FORGEN_HOME, 'state', 'last-auto-compound.json');
     fs.mkdirSync(path.dirname(statePath), { recursive: true });
-    fs.writeFileSync(statePath, JSON.stringify({ sessionId, completedAt: new Date().toISOString() }));
+    fs.writeFileSync(statePath, JSON.stringify({
+        sessionId,
+        completedAt: new Date().toISOString(),
+        extractedSolutions: extractedSolutionsCount,
+        promotedRules: promotedCount,
+        noticeShown: false,
+    }));
 }
 catch (e) {
     process.stderr.write(`[forgen-auto-compound] ${e instanceof Error ? e.message : String(e)}\n`);

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;