@wooojin/forgen 0.4.1 → 0.4.3

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();

package/dist/core/host-detect.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Host detection — feat/codex-support Phase 1
+ *
+ * `forgen install` interactive 의 prerequisite — 사용자 환경에 어떤 host (Claude/Codex)
+ * 가 가용한지 탐지. spec §10 Phase 1 + interview R3.
+ *
+ * 탐지 신호 (각 host 별):
+ *   - binary 가 PATH 에 있음 (`which claude` / `which codex`)
+ *   - host 디렉토리 존재 (~/.claude/ / ~/.codex/)
+ *   - (Codex 만) `~/.codex/auth.json` 존재 (로그인 흔적)
+ *
+ * detect 결과는 *추론* 만. install 강제 안 함.
+ */
+import type { HostId } from './trust-layer-intent.js';
+export interface HostAvailability {
+    readonly host: HostId;
+    /** binary 가 PATH 에 있음. */
+    readonly binaryFound: boolean;
+    /** binary 절대경로 (없으면 null). */
+    readonly binaryPath: string | null;
+    /** host home 디렉토리 존재 (~/.claude/ 또는 ~/.codex/). */
+    readonly homeExists: boolean;
+    /** host home 절대경로. */
+    readonly homePath: string;
+    /** Codex 의 경우 auth.json 존재 (로그인 흔적). Claude 는 항상 null. */
+    readonly authPresent: boolean | null;
+    /**
+     * 종합 판단 — *install 후보로 적합한가*.
+     * - binaryFound 또는 homeExists 중 하나 이상이면 true.
+     * - 둘 다 없으면 false (사용자가 host 를 안 쓸 가능성 높음).
+     */
+    readonly available: boolean;
+}
+export interface HostDetectionResult {
+    readonly claude: HostAvailability;
+    readonly codex: HostAvailability;
+    /** 둘 다 사용 가능. */
+    readonly bothAvailable: boolean;
+    /** 하나도 사용 가능하지 않음 (warn). */
+    readonly noneAvailable: boolean;
+}
+export declare function detectAvailableHosts(): HostDetectionResult;

package/dist/core/host-detect.js

@@ -0,0 +1,68 @@
+/**
+ * Host detection — feat/codex-support Phase 1
+ *
+ * `forgen install` interactive 의 prerequisite — 사용자 환경에 어떤 host (Claude/Codex)
+ * 가 가용한지 탐지. spec §10 Phase 1 + interview R3.
+ *
+ * 탐지 신호 (각 host 별):
+ *   - binary 가 PATH 에 있음 (`which claude` / `which codex`)
+ *   - host 디렉토리 존재 (~/.claude/ / ~/.codex/)
+ *   - (Codex 만) `~/.codex/auth.json` 존재 (로그인 흔적)
+ *
+ * detect 결과는 *추론* 만. install 강제 안 함.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+function which(binary) {
+    try {
+        const out = execFileSync('which', [binary], { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] });
+        const trimmed = out.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectClaude() {
+    const binaryPath = which('claude');
+    const homePath = path.join(os.homedir(), '.claude');
+    const homeExists = fs.existsSync(homePath);
+    const binaryFound = binaryPath !== null;
+    return {
+        host: 'claude',
+        binaryFound,
+        binaryPath,
+        homeExists,
+        homePath,
+        authPresent: null, // Claude 는 별도 auth.json 패턴이 없음 (subscription 통합)
+        available: binaryFound || homeExists,
+    };
+}
+function detectCodex() {
+    const binaryPath = which('codex');
+    const codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+    const homeExists = fs.existsSync(codexHome);
+    const binaryFound = binaryPath !== null;
+    const authPresent = fs.existsSync(path.join(codexHome, 'auth.json'));
+    return {
+        host: 'codex',
+        binaryFound,
+        binaryPath,
+        homeExists,
+        homePath: codexHome,
+        authPresent,
+        available: binaryFound || homeExists,
+    };
+}
+export function detectAvailableHosts() {
+    const claude = detectClaude();
+    const codex = detectCodex();
+    return {
+        claude,
+        codex,
+        bothAvailable: claude.available && codex.available,
+        noneAvailable: !claude.available && !codex.available,
+    };
+}

package/dist/core/installer.js

@@ -111,7 +111,7 @@ export function installAgents(cwd, pkgRoot) {
     const targetDir = path.join(cwd, '.claude', 'agents');
     fs.mkdirSync(targetDir, { recursive: true });
     const hashes = loadAgentHashes();
-    const sourceDir = path.join(pkgRoot, 'agents');
+    const sourceDir = path.join(pkgRoot, 'assets', 'claude', 'agents');
     try {
         installAgentsFromDir(sourceDir, targetDir, 'ch-', hashes);
         cleanupStaleAgents(sourceDir, targetDir, 'ch-', hashes);
@@ -159,7 +159,7 @@ function cleanupStaleCommands(commandsDir, validFiles) {
 }
 /** 스킬을 Claude Code 슬래시 명령으로 설치 (패키지 내장만) */
 export function installSlashCommands(_cwd, pkgRoot) {
-    let skillsDir = path.join(pkgRoot, 'commands');
+    let skillsDir = path.join(pkgRoot, 'assets', 'claude', 'commands');
     if (!fs.existsSync(skillsDir)) {
         skillsDir = path.join(pkgRoot, 'skills');
     }

package/dist/core/migrate-cli.d.ts

@@ -6,5 +6,6 @@
  *   - implicit-feedback: TEST-5 category 필드 백필 (type → category inference).
  *     기본은 lazy (read 시점 백필) 이지만 집계/외부 도구가 raw jsonl 을 읽는
  *     경우 영구 재기록이 필요.
+ *   - evidence-host: ~/.forgen/me/behavior/*.json 에 host 필드가 없는 파일 백필.
  */
 export declare function handleMigrate(args: string[]): Promise<void>;

package/dist/core/migrate-cli.js

@@ -6,14 +6,19 @@
  *   - implicit-feedback: TEST-5 category 필드 백필 (type → category inference).
  *     기본은 lazy (read 시점 백필) 이지만 집계/외부 도구가 raw jsonl 을 읽는
  *     경우 영구 재기록이 필요.
+ *   - evidence-host: ~/.forgen/me/behavior/*.json 에 host 필드가 없는 파일 백필.
  */
 import { migrateImplicitFeedbackLog } from '../store/implicit-feedback-store.js';
+import { migrateEvidenceHost } from './migrate-evidence-host.js';
 const HELP = `
   forgen migrate — one-shot schema migrations
 
   Usage:
     forgen migrate implicit-feedback   category 필드가 없는 레거시 엔트리 백필 + 재기록
     forgen migrate all                 (현재는 implicit-feedback 과 동일)
+    forgen migrate evidence-host       behavior/*.json 에 host 필드 백필
+      --dry-run                          디스크 미수정, 카운트만 출력
+      --default-host <claude|codex>      host 기본값 (default: claude)
     forgen migrate --help              이 도움말
 `;
 export async function handleMigrate(args) {
@@ -28,6 +33,20 @@ export async function handleMigrate(args) {
         console.log(`[forgen migrate] 백필 ${migrated}건, 드롭 ${dropped}건 — 재기록 완료.`);
         return;
     }
+    if (sub === 'evidence-host') {
+        const dryRun = args.includes('--dry-run');
+        const hostFlagIdx = args.indexOf('--default-host');
+        const rawHost = hostFlagIdx !== -1 ? args[hostFlagIdx + 1] : 'claude';
+        if (rawHost !== 'claude' && rawHost !== 'codex') {
+            console.error(`[forgen migrate] --default-host 는 'claude' 또는 'codex' 여야 합니다. 받은 값: ${rawHost}`);
+            process.exit(1);
+        }
+        const defaultHost = rawHost;
+        const result = migrateEvidenceHost({ defaultHost, dryRun });
+        const label = dryRun ? ' (dry-run)' : '';
+        console.log(`[forgen] migrated: ${result.migrated} (skipped: ${result.skipped}, total: ${result.total})${label}`);
+        return;
+    }
     console.error(`[forgen migrate] unknown target: ${sub}`);
     console.error(HELP);
     process.exit(1);

package/dist/core/migrate-evidence-host.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Forgen — Evidence Host Backfill Migration
+ *
+ * spec §10 우선순위 5 + §4.2:
+ * 사용자가 명시적으로 디스크의 evidence 파일에 host 필드를 박제하고 싶을 때 사용.
+ * (마이그레이션 박제, audit 목적)
+ *
+ * loadEvidence 의 자동 backfill (evidence-store.ts::backfillHost) 과는 독립.
+ * 이 모듈은 디스크 파일을 직접 수정하는 명시적 경로.
+ */
+export interface MigrateEvidenceHostOptions {
+    /** backfill 할 host 값 (host 필드 없는 파일에만 적용) */
+    defaultHost: 'claude' | 'codex';
+    /**
+     * true 이면 디스크를 수정하지 않고 카운트만 반환.
+     * @default false
+     */
+    dryRun?: boolean;
+}
+export interface MigrateEvidenceHostResult {
+    /** host 필드를 새로 추가한 파일 수 */
+    migrated: number;
+    /** 처리 대상 전체 .json 파일 수 */
+    total: number;
+    /** 이미 host 필드가 있어 건너뛴 파일 수 */
+    skipped: number;
+}
+/**
+ * `~/.forgen/me/behavior/*.json` 을 순회하여 host 필드가 없는 파일에
+ * `defaultHost` 를 추가한다.
+ *
+ * - dryRun=true 이면 디스크 미수정, 카운트만 반환.
+ * - 이미 host 필드가 있는 파일은 건너뜀 (idempotent).
+ * - 파싱 실패 / host 필드가 아닌 값인 파일도 건너뜀 (안전).
+ */
+export declare function migrateEvidenceHost(options: MigrateEvidenceHostOptions): MigrateEvidenceHostResult;

package/dist/core/migrate-evidence-host.js

@@ -0,0 +1,49 @@
+/**
+ * Forgen — Evidence Host Backfill Migration
+ *
+ * spec §10 우선순위 5 + §4.2:
+ * 사용자가 명시적으로 디스크의 evidence 파일에 host 필드를 박제하고 싶을 때 사용.
+ * (마이그레이션 박제, audit 목적)
+ *
+ * loadEvidence 의 자동 backfill (evidence-store.ts::backfillHost) 과는 독립.
+ * 이 모듈은 디스크 파일을 직접 수정하는 명시적 경로.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_BEHAVIOR } from './paths.js';
+import { atomicWriteJSON, safeReadJSON } from '../hooks/shared/atomic-write.js';
+/**
+ * `~/.forgen/me/behavior/*.json` 을 순회하여 host 필드가 없는 파일에
+ * `defaultHost` 를 추가한다.
+ *
+ * - dryRun=true 이면 디스크 미수정, 카운트만 반환.
+ * - 이미 host 필드가 있는 파일은 건너뜀 (idempotent).
+ * - 파싱 실패 / host 필드가 아닌 값인 파일도 건너뜀 (안전).
+ */
+export function migrateEvidenceHost(options) {
+    const { defaultHost, dryRun = false } = options;
+    if (!fs.existsSync(ME_BEHAVIOR)) {
+        return { migrated: 0, total: 0, skipped: 0 };
+    }
+    const files = fs.readdirSync(ME_BEHAVIOR).filter((f) => f.endsWith('.json'));
+    let migrated = 0;
+    let skipped = 0;
+    for (const file of files) {
+        const filePath = path.join(ME_BEHAVIOR, file);
+        const data = safeReadJSON(filePath, null);
+        if (data === null || typeof data !== 'object') {
+            skipped++;
+            continue;
+        }
+        const host = data['host'];
+        if (host === 'claude' || host === 'codex') {
+            skipped++;
+            continue;
+        }
+        if (!dryRun) {
+            atomicWriteJSON(filePath, { ...data, host: defaultHost }, { pretty: true });
+        }
+        migrated++;
+    }
+    return { migrated, total: files.length, skipped };
+}

package/dist/core/settings-injector.js

@@ -7,6 +7,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { generateHooksJson } from '../hooks/hooks-generator.js';
+import { getHostRuntime } from '../host/host-runtime.js';
 import { ConfigError } from './errors.js';
 import { createLogger } from './logger.js';
 import { acquireLock, atomicWriteFileSync, CLAUDE_DIR, readSettingsSafely, releaseLock, rollbackSettings, SETTINGS_BACKUP_PATH, SETTINGS_PATH, } from './settings-lock.js';
@@ -74,7 +75,8 @@ function mergeHooksIntoSettings(settings, runtime, cwd, pkgRoot) {
             hooksConfig[event] = filtered;
     }
     try {
-        if (runtime === 'codex') {
+        const host = getHostRuntime(runtime);
+        if (host.hookInjectionStrategy === 'generate') {
             const generated = generateHooksJson({ cwd, runtime, pluginRoot: path.join(pkgRoot, 'dist') });
             for (const [event, handlers] of Object.entries(generated.hooks)) {
                 if (!hooksConfig[event])
@@ -83,7 +85,7 @@ function mergeHooksIntoSettings(settings, runtime, cwd, pkgRoot) {
             }
         }
         else {
-            // Read hooks.json and inject, replacing ${CLAUDE_PLUGIN_ROOT}
+            // 'pre-baked-file': pkgRoot/hooks/hooks.json 읽고 ${CLAUDE_PLUGIN_ROOT} 치환
             const hooksJsonPath = path.join(pkgRoot, 'hooks', 'hooks.json');
             if (fs.existsSync(hooksJsonPath)) {
                 const hooksJson = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf-8'));

package/dist/core/spawn.d.ts

@@ -1,5 +1,5 @@
 import type { V1HarnessContext } from './harness.js';
-import { type RuntimeHost } from './types.js';
+import type { RuntimeHost } from './types.js';
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
 export declare function spawnClaude(args: string[], context: V1HarnessContext, runtime?: RuntimeHost): Promise<number>;
 /**

package/dist/core/spawn.js

@@ -7,13 +7,11 @@ import { buildEnv } from './config-injector.js';
 import { loadGlobalConfig } from './global-config.js';
 import { createLogger } from './logger.js';
 import { STATE_DIR } from './paths.js';
+import { getHostRuntime } from '../host/host-runtime.js';
 const log = createLogger('spawn');
-/** claude CLI 경로 탐색 */
-function findClaude() {
-    return 'claude';
-}
+/** Phase 2: host-runtime 어댑터 위임. */
 function findRuntimeLauncher(runtime) {
-    return runtime === 'codex' ? 'codex' : findClaude();
+    return getHostRuntime(runtime).launcher;
 }
 function transcriptProjectDir(cwd) {
     // Claude Code는 cwd의 /를 -로 치환하고 선행 -를 유지
@@ -161,12 +159,7 @@ export async function spawnClaude(args, context, runtime = 'claude') {
         });
         child.on('error', (err) => {
             if (err.code === 'ENOENT') {
-                if (runtime === 'codex') {
-                    reject(new Error('Codex is not installed.'));
-                }
-                else {
-                    reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
-                }
+                reject(new Error(getHostRuntime(runtime).missingInstallMessage));
             }
             else {
                 reject(err);

package/dist/core/stats-cli.js

@@ -10,6 +10,7 @@ import * as path from 'node:path';
 import { loadAllRules } from '../store/rule-store.js';
 import { loadAllEvidence } from '../store/evidence-store.js';
 import { STATE_DIR, ME_DIR } from './paths.js';
+import { computeFixFeatRatio, formatFixRatio } from './git-stats.js';
 // v0.4.1 격리 fix: 이전에는 os.homedir() 직접 사용해서 FORGEN_HOME env 로
 // 홈 격리해도 이 파일의 경로는 여전히 실 홈 가리켰음. paths.ts 상수 import.
 const ENFORCEMENT_DIR = path.join(STATE_DIR, 'enforcement');
@@ -244,6 +245,17 @@ export function renderStats(s) {
         lines.push(`    Last reclass        ${s.philosophy.lastReclassification ?? 'never'}`);
         lines.push('');
     }
+    // P4 셀프 가드 — 최근 30커밋 fix:feat 비율로 회귀 패턴 자가 노출.
+    // 30% 초과 시 "이거 고치면 저거 버그난다" 패턴 의심 → forgen doctor 가 경고.
+    try {
+        const ratio = computeFixFeatRatio();
+        if (ratio.available) {
+            lines.push('  Repo health (last 30 commits)');
+            lines.push(`    ${formatFixRatio(ratio)}`);
+            lines.push('');
+        }
+    }
+    catch { /* fail-open: git 없거나 비-repo 환경 */ }
     lines.push(`  Last extraction: ${s.lastExtraction}`);
     lines.push('');
     return lines.join('\n');

package/dist/core/trust-layer-intent.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Trust Layer Intent — Multi-Host Core Design §9.0 산출물 #1
+ *
+ * forgen 이 host 위에서 보장하는 행동의 enum. spec §9.0 의 7 의도 매트릭스와 1:1.
+ * 각 host adapter 는 이 enum 의 모든 항목에 대해 CapabilityDeclaration 을 선언해야 하며,
+ * 미선언은 컴파일 타임(`Record<TrustLayerIntent, _>`) + 런타임(`assertCapabilitiesComplete`) 양쪽에서 fail.
+ *
+ * 1원칙: Claude semantics 가 reference. 본 enum 의 의미는 Claude Hook schema 의 행동을 그대로 사용한다.
+ */
+export declare const TRUST_LAYER_INTENTS: readonly ["block-completion", "block-tool-use", "inject-context", "observe-only", "secret-filter", "forge-loop-state-inject", "self-evidence-record"];
+export type TrustLayerIntent = (typeof TRUST_LAYER_INTENTS)[number];
+export type CapabilityStatus = 'supported' | 'partial' | 'unsupported';
+export interface CapabilityDeclaration {
+    readonly status: CapabilityStatus;
+    /** host 표면이 이 의도를 표현하는 hook/필드 (예: "Stop + decision:'block' + reason"). */
+    readonly expression: string;
+    /** partial/unsupported 시 등가성 보존을 위한 mitigation 핸들. supported 면 undefined. */
+    readonly mitigation?: string;
+    /** source-of-truth (spec 또는 외부 docs/source 인용). */
+    readonly source?: string;
+}
+export type HostId = 'claude' | 'codex';
+export interface HostCapabilities {
+    readonly hostId: HostId;
+    /**
+     * 모든 TrustLayerIntent 에 대한 선언. `Record<TrustLayerIntent, _>` 타입이
+     * 컴파일 타임에 누락을 차단한다.
+     */
+    readonly intents: Record<TrustLayerIntent, CapabilityDeclaration>;
+}
+/**
+ * 런타임 assertion — host adapter 가 새 의도 추가를 누락한 경우 fail.
+ * 컴파일 타임 가드를 우회하는 동적 생성 코드를 위한 안전망.
+ */
+export declare function assertCapabilitiesComplete(caps: HostCapabilities): void;

package/dist/core/trust-layer-intent.js

@@ -0,0 +1,30 @@
+/**
+ * Trust Layer Intent — Multi-Host Core Design §9.0 산출물 #1
+ *
+ * forgen 이 host 위에서 보장하는 행동의 enum. spec §9.0 의 7 의도 매트릭스와 1:1.
+ * 각 host adapter 는 이 enum 의 모든 항목에 대해 CapabilityDeclaration 을 선언해야 하며,
+ * 미선언은 컴파일 타임(`Record<TrustLayerIntent, _>`) + 런타임(`assertCapabilitiesComplete`) 양쪽에서 fail.
+ *
+ * 1원칙: Claude semantics 가 reference. 본 enum 의 의미는 Claude Hook schema 의 행동을 그대로 사용한다.
+ */
+export const TRUST_LAYER_INTENTS = [
+    'block-completion',
+    'block-tool-use',
+    'inject-context',
+    'observe-only',
+    'secret-filter',
+    'forge-loop-state-inject',
+    'self-evidence-record',
+];
+/**
+ * 런타임 assertion — host adapter 가 새 의도 추가를 누락한 경우 fail.
+ * 컴파일 타임 가드를 우회하는 동적 생성 코드를 위한 안전망.
+ */
+export function assertCapabilitiesComplete(caps) {
+    const declared = new Set(Object.keys(caps.intents));
+    const missing = TRUST_LAYER_INTENTS.filter((i) => !declared.has(i));
+    if (missing.length > 0) {
+        throw new Error(`HostCapabilities for "${caps.hostId}" missing intents: ${missing.join(', ')}. ` +
+            `All TrustLayerIntent values must be declared (spec §9.0).`);
+    }
+}

package/dist/core/types.d.ts

@@ -112,7 +112,7 @@ export type RuntimeHost = 'claude' | 'codex';
 export interface LaunchContext {
     runtime: RuntimeHost;
     args: string[];
-    runtimeSource: 'flag' | 'env' | 'default';
+    runtimeSource: 'flag' | 'env' | 'profile' | 'default';
 }
 /** 훅 입력 이벤트 스키마 (버전 간 상위 호환용 최소 스펙) */
 export interface HookEventInput {

package/dist/engine/compound-extractor.js

@@ -18,6 +18,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { execHost } from '../host/exec-host.js';
 import { serializeSolutionV3, DEFAULT_EVIDENCE, extractTags } from './solution-format.js';
 import { createLogger } from '../core/logger.js';
 const log = createLogger('compound-extractor');
@@ -655,15 +656,12 @@ function enrichSolutionContent(solution, diffSnippet) {
             '코드 변경 (일부):',
             diffSnippet.slice(0, 2000),
         ].join('\n');
-        const result = execFileSync('claude', ['-p', prompt, '--model', 'haiku'], {
-            timeout: 15000,
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        const enriched = result.trim();
-        if (enriched.length > 30 && enriched.length < 1000) {
-            return enriched;
-        }
+        // feat/codex-support P2-2 — host-aware exec via profile.default_host.
+        // Codex 메인 사용자도 자동 추출 enrichment 가능 (해당 host CLI 호출).
+        // fail-open 정책 유지 — LLM enrichment 실패는 추출 자체를 막지 않음.
+        const { message } = execHost({ prompt, model: 'haiku', timeout: 15000 });
+        if (message.length > 30 && message.length < 1000)
+            return message;
         return null;
     }
     catch {

package/dist/engine/learn-cli.js

@@ -147,10 +147,12 @@ function runEvolve(args) {
     const rollbackIdx = args.indexOf('--rollback');
     const promoteIdx = args.indexOf('--promote');
     if (rollbackIdx >= 0 && args[rollbackIdx + 1]) {
-        return runEvolveRollback(args[rollbackIdx + 1]);
+        runEvolveRollback(args[rollbackIdx + 1]);
+        return;
     }
     if (promoteIdx >= 0 && args[promoteIdx + 1]) {
-        return runEvolvePromote(args[promoteIdx + 1]);
+        runEvolvePromote(args[promoteIdx + 1]);
+        return;
     }
     // Default: generate + optionally save weakness report, print proposer
     // brief so the user can hand it to the ch-solution-evolver agent.

package/dist/engine/lifecycle/bypass-detector.d.ts

@@ -4,12 +4,17 @@
  * Rule.policy 자연어에서 "피해야 할 패턴" 을 추출하고, Write/Edit/Bash 도구
  * 출력에서 해당 패턴을 찾아 BypassEntry 후보로 반환한다.
  *
- * Heuristic:
+ * Heuristic priority (most explicit first):
+ *   0) Parenthesized examples (e.g., "(rm -rf, DROP, force-push)") → tokens inside
  *   1) "use X not Y" / "use X instead of Y" / "X over Y" → bypass = Y
  *   2) "avoid X" / "don't use X" / "never use X" / "do not use X" → bypass = X
  *   3) Korean: "X 말라" / "X 금지" / "X 하지 않" → bypass = X
  *   4) 그 외: 빈 배열 (탐지 불가).
  *
+ * Stop list filter: generic Korean verbs (실행/사용/선언/...) extracted by Korean
+ * heuristic are removed — they cause massive FP (RC5/E9: matched the word "실행"
+ * everywhere instead of "rm -rf"). 64 false-positive bypasses observed before fix.
+ *
  * 반환된 패턴은 escape 된 정규식 문자열 — caller 가 `new RegExp(p)` 로 사용.
  */
 import type { Rule } from '../../store/types.js';