@wooojin/forgen 0.4.0 → 0.4.3

package/dist/host/capabilities-claude.js

@@ -0,0 +1,46 @@
+/**
+ * Claude HostCapabilities — Multi-Host Core Design §9.0
+ *
+ * Claude 는 reference host. 모든 TrustLayerIntent 가 supported (identity binding).
+ * 본 선언은 *spec 정의 그 자체* 의 코드 표현 — 변경 시 spec §9.0 도 같이 갱신해야 한다.
+ */
+export const claudeCapabilities = {
+    hostId: 'claude',
+    intents: {
+        'block-completion': {
+            status: 'supported',
+            expression: 'Stop hook + `decision:"block"` + `reason`',
+            source: 'forgen v0.4.0 stop-guard, src/hooks/stop-guard.ts',
+        },
+        'block-tool-use': {
+            status: 'supported',
+            expression: 'PreToolUse + `hookSpecificOutput.permissionDecision:"deny"` + `permissionDecisionReason`',
+            source: 'forgen v0.4.0 pre-tool-use, src/hooks/pre-tool-use.ts',
+        },
+        'inject-context': {
+            status: 'supported',
+            expression: 'SessionStart/UserPromptSubmit + `hookSpecificOutput.additionalContext`',
+            source: 'forgen v0.4.2 M1, src/hooks/session-recovery.ts + forge-loop-progress.ts',
+        },
+        'observe-only': {
+            status: 'supported',
+            expression: 'non-allowlist hook approve + observer log (denyOrObserve)',
+            source: 'forgen v0.4.2 P3\', src/hooks/shared/blocking-allowlist.ts + hook-response.ts',
+        },
+        'secret-filter': {
+            status: 'supported',
+            expression: 'PreToolUse 가드 + (선택) PostToolUse 차단/redact',
+            source: 'forgen v0.4.0 secret-filter, src/hooks/secret-filter.ts',
+        },
+        'forge-loop-state-inject': {
+            status: 'supported',
+            expression: 'SessionStart/UserPromptSubmit + `<forge-loop-state>` ≤1KB additionalContext',
+            source: 'forgen v0.4.2 M1, src/hooks/shared/forge-loop-state.ts',
+        },
+        'self-evidence-record': {
+            status: 'supported',
+            expression: 'hook 결과 → ~/.forgen/state/*.json (host 무관)',
+            source: 'forgen v0.4.2, ~/.forgen/state/e2e-result.json 외',
+        },
+    },
+};

package/dist/host/capabilities-codex.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Codex HostCapabilities — Multi-Host Core Design §9.0 + §18 (source-level verified)
+ *
+ * Codex 는 1원칙 (Claude reference) 의 등가 확장 host. schema-level 에서 7/7 supported.
+ * 단, secret-filter 는 PostToolUse `hookSpecificOutput.updatedMCPToolOutput` 이 MCP tool 한정이므로
+ * partial. 일반 shell/edit tool 의 결과 redact 는 미보장 — PreToolUse 가드 유지로 mitigation.
+ *
+ * source-of-truth: codex-rs/hooks/schema/generated/* (Apache-2.0). spec §17/§18 이 박제한 검증 결과.
+ */
+import type { HostCapabilities } from '../core/trust-layer-intent.js';
+export declare const codexCapabilities: HostCapabilities;

package/dist/host/capabilities-codex.js

@@ -0,0 +1,50 @@
+/**
+ * Codex HostCapabilities — Multi-Host Core Design §9.0 + §18 (source-level verified)
+ *
+ * Codex 는 1원칙 (Claude reference) 의 등가 확장 host. schema-level 에서 7/7 supported.
+ * 단, secret-filter 는 PostToolUse `hookSpecificOutput.updatedMCPToolOutput` 이 MCP tool 한정이므로
+ * partial. 일반 shell/edit tool 의 결과 redact 는 미보장 — PreToolUse 가드 유지로 mitigation.
+ *
+ * source-of-truth: codex-rs/hooks/schema/generated/* (Apache-2.0). spec §17/§18 이 박제한 검증 결과.
+ */
+export const codexCapabilities = {
+    hostId: 'codex',
+    intents: {
+        'block-completion': {
+            status: 'supported',
+            expression: 'Stop + `decision:"block"` + `reason` (Codex 가 reason 을 다음 turn prompt 로 자동 주입)',
+            source: 'codex-rs/hooks/schema/generated/stop.command.output.schema.json — description 에 "Claude requires `reason` when `decision` is `block`" 명시',
+        },
+        'block-tool-use': {
+            status: 'supported',
+            expression: 'PreToolUse + `hookSpecificOutput.permissionDecision:"deny"` + `permissionDecisionReason`',
+            source: 'codex-rs/hooks/schema/generated/pre-tool-use.command.output.schema.json — PreToolUsePermissionDecisionWire enum ["allow","deny","ask"]',
+        },
+        'inject-context': {
+            status: 'supported',
+            expression: 'SessionStart/UserPromptSubmit + `hookSpecificOutput.additionalContext`',
+            source: 'codex-rs/hooks/schema/generated/{session-start,user-prompt-submit}.command.output.schema.json — additionalContext: string',
+        },
+        'observe-only': {
+            status: 'supported',
+            expression: 'non-allowlist hook approve + observer log (denyOrObserve 그대로)',
+            source: 'forgen denyOrObserve 가 stdout JSON 만 다루므로 host 무관 — spec §17.2 확인',
+        },
+        'secret-filter': {
+            status: 'partial',
+            expression: 'MCP tool 한정: PostToolUse + `hookSpecificOutput.updatedMCPToolOutput`. 일반 shell/edit tool 결과 redact 계약 부재.',
+            mitigation: '1차는 PreToolUse 단계의 secret-filter 가드 유지 (Claude 와 동일 경로). 일반 tool 결과 redact 는 향후 PostToolUse 도입 시 MCP tool 에 한해 강화.',
+            source: 'codex-rs/hooks/schema/generated/post-tool-use.command.output.schema.json — updatedMCPToolOutput 만 정의',
+        },
+        'forge-loop-state-inject': {
+            status: 'supported',
+            expression: 'SessionStart/UserPromptSubmit + `<forge-loop-state>` ≤1KB additionalContext',
+            source: 'spec §9.0 row 6 — schema 가 Claude 와 동치하므로 1KB cap 정책 그대로 적용',
+        },
+        'self-evidence-record': {
+            status: 'supported',
+            expression: 'hook 결과 → ~/.forgen/state/*.json (host 무관). evidence 에 host:"codex" 태그 추가만 필요.',
+            source: 'spec §4.2 host-tagged evidence',
+        },
+    },
+};

package/dist/host/capabilities-registry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Host Capabilities Registry — Multi-Host Core Design §10 우선순위 1
+ *
+ * 등록된 모든 host 의 HostCapabilities 를 모듈 로드 시점에 검증한다.
+ * 새 TrustLayerIntent 추가 시 두 host 어댑터가 모두 선언을 추가하지 않으면 컴파일 fail.
+ * (TypeScript `Record<TrustLayerIntent, _>` 타입 + 이 모듈의 runtime assert 이중 가드.)
+ */
+import { type HostCapabilities, type HostId, type TrustLayerIntent } from '../core/trust-layer-intent.js';
+export declare function getHostCapabilities(host: HostId): HostCapabilities;
+export declare function listRegisteredHosts(): readonly HostId[];
+export declare function intentSupported(host: HostId, intent: TrustLayerIntent): boolean;

package/dist/host/capabilities-registry.js

@@ -0,0 +1,30 @@
+/**
+ * Host Capabilities Registry — Multi-Host Core Design §10 우선순위 1
+ *
+ * 등록된 모든 host 의 HostCapabilities 를 모듈 로드 시점에 검증한다.
+ * 새 TrustLayerIntent 추가 시 두 host 어댑터가 모두 선언을 추가하지 않으면 컴파일 fail.
+ * (TypeScript `Record<TrustLayerIntent, _>` 타입 + 이 모듈의 runtime assert 이중 가드.)
+ */
+import { assertCapabilitiesComplete, } from '../core/trust-layer-intent.js';
+import { claudeCapabilities } from './capabilities-claude.js';
+import { codexCapabilities } from './capabilities-codex.js';
+const REGISTRY = new Map([
+    [claudeCapabilities.hostId, claudeCapabilities],
+    [codexCapabilities.hostId, codexCapabilities],
+]);
+// 모듈 로드 시점 자기 검증 — 하나라도 미선언이면 즉시 throw.
+for (const caps of REGISTRY.values()) {
+    assertCapabilitiesComplete(caps);
+}
+export function getHostCapabilities(host) {
+    const caps = REGISTRY.get(host);
+    if (!caps)
+        throw new Error(`Unknown host: ${host}`);
+    return caps;
+}
+export function listRegisteredHosts() {
+    return Array.from(REGISTRY.keys());
+}
+export function intentSupported(host, intent) {
+    return getHostCapabilities(host).intents[intent].status === 'supported';
+}

package/dist/host/codex-adapter.d.ts

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 /**
- * Codex 훅 어댑터
+ * Codex 훅 어댑터 — Multi-Host Core Design §10 우선순위 2 (승격)
  *
- * 목적:
- * - codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema로 정규화
- * - continue 누락 또는 codex 특화 판정 필드(approved/decision) 대응
- * - 파싱 실패/실행 실패 시 fail-open(continue: true)
+ * 본 binary 는 codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema 로
+ * 사영(projection)한다. 사영 로직은 정식 계약 `ProjectToClaudeEvent` (src/host/projection.ts)
+ * 에서 제공하며, 본 파일은 그 계약의 *binary 진입점* 역할만 수행한다.
+ *
+ * - 입력: 사용자 hook 스크립트(stdin JSON, argv 의 첫 인자가 delegate path)
+ * - 출력: Claude HookEventOutput 동치 JSON (stdout 1줄)
+ * - 실패 정책: parse/실행 실패 → fail-open (`{ continue: true }`)
  */
 export {};

package/dist/host/codex-adapter.js

@@ -1,49 +1,17 @@
 #!/usr/bin/env node
 /**
- * Codex 훅 어댑터
+ * Codex 훅 어댑터 — Multi-Host Core Design §10 우선순위 2 (승격)
  *
- * 목적:
- * - codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema로 정규화
- * - continue 누락 또는 codex 특화 판정 필드(approved/decision) 대응
- * - 파싱 실패/실행 실패 시 fail-open(continue: true)
+ * 본 binary 는 codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema 로
+ * 사영(projection)한다. 사영 로직은 정식 계약 `ProjectToClaudeEvent` (src/host/projection.ts)
+ * 에서 제공하며, 본 파일은 그 계약의 *binary 진입점* 역할만 수행한다.
+ *
+ * - 입력: 사용자 hook 스크립트(stdin JSON, argv 의 첫 인자가 delegate path)
+ * - 출력: Claude HookEventOutput 동치 JSON (stdout 1줄)
+ * - 실패 정책: parse/실행 실패 → fail-open (`{ continue: true }`)
  */
 import { spawnSync } from 'node:child_process';
-function parseDecision(raw) {
-    if (typeof raw === 'boolean') {
-        return { continueFlag: raw };
-    }
-    if (typeof raw === 'string') {
-        const normalized = raw.toLowerCase();
-        if (normalized === 'continue')
-            return { continueFlag: true };
-        if (normalized === 'stop' || normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
-            return { continueFlag: false, permissionDecision: normalized };
-        }
-        return { continueFlag: true };
-    }
-    if (typeof raw !== 'object' || raw === null)
-        return { continueFlag: true };
-    const value = raw.decision;
-    if (typeof value === 'string') {
-        const normalized = value.toLowerCase();
-        if (normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
-            return { continueFlag: false, permissionDecision: normalized };
-        }
-        if (normalized === 'ask' || normalized === 'prompt' || normalized === 'confirm') {
-            return { continueFlag: true, permissionDecision: normalized };
-        }
-    }
-    if (typeof raw.approved === 'boolean') {
-        const approved = raw.approved;
-        return approved
-            ? { continueFlag: true, permissionDecision: raw.decision || 'approve' }
-            : { continueFlag: false, permissionDecision: 'deny' };
-    }
-    if (typeof raw.continue === 'boolean') {
-        return { continueFlag: raw.continue };
-    }
-    return { continueFlag: true };
-}
+import { projectCodexToClaude } from './projection.js';
 function lastJSONObjectFromText(raw) {
     const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
     for (let i = lines.length - 1; i >= 0; i -= 1) {
@@ -61,46 +29,6 @@ function lastJSONObjectFromText(raw) {
         return null;
     }
 }
-function normalizeOutput(raw, input) {
-    const result = { continue: true };
-    const decision = parseDecision(raw);
-    result.continue = decision.continueFlag;
-    if (typeof raw === 'object' && raw !== null) {
-        const payload = raw;
-        if (typeof payload.continue === 'boolean')
-            result.continue = payload.continue;
-        if (typeof payload.systemMessage === 'string')
-            result.systemMessage = payload.systemMessage;
-        if (typeof payload.suppressOutput === 'boolean')
-            result.suppressOutput = payload.suppressOutput;
-        if (typeof payload.hookSpecificOutput === 'object' && payload.hookSpecificOutput !== null) {
-            result.hookSpecificOutput = { ...payload.hookSpecificOutput };
-        }
-        if (typeof payload.decision === 'string') {
-            result.hookSpecificOutput = {
-                ...(result.hookSpecificOutput ?? {}),
-                permissionDecision: payload.decision,
-            };
-        }
-    }
-    const eventName = result.hookSpecificOutput?.hookEventName ?? input.hookEventName ?? input.event;
-    if (eventName) {
-        result.hookSpecificOutput = {
-            hookEventName: eventName,
-            ...(result.hookSpecificOutput ?? {}),
-        };
-    }
-    if (!result.continue && !result.hookSpecificOutput?.permissionDecision) {
-        if (decision.permissionDecision)
-            result.hookSpecificOutput = {
-                ...(result.hookSpecificOutput ?? {}),
-                permissionDecision: decision.permissionDecision,
-            };
-        else
-            result.hookSpecificOutput = { ...(result.hookSpecificOutput ?? {}), permissionDecision: 'deny' };
-    }
-    return result;
-}
 async function main() {
     const [delegatePath, ...restArgs] = process.argv.slice(2);
     if (!delegatePath) {
@@ -142,7 +70,7 @@ async function main() {
             console.log(JSON.stringify({ continue: true }));
             return;
         }
-        const output = normalizeOutput(parsed, input);
+        const output = projectCodexToClaude(parsed, input);
         console.log(JSON.stringify(output));
     }
     catch {

package/dist/host/codex-output-parser.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Codex exec --json 출력 파서 — feat/codex-support Phase 2 (P2-1)
+ *
+ * codex exec --json 의 stdout 은 JSONL — 한 줄에 하나씩 이벤트.
+ * 본 파서는 agent_message 만 추출하여 문자열로 반환.
+ *
+ * 출력 형식 (실측 2026-04-27, Codex 0.125.0):
+ *   {"type":"thread.started","thread_id":"..."}
+ *   {"type":"turn.started"}
+ *   {"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"..."}}
+ *   {"type":"turn.completed","usage":{...}}
+ *
+ * spec §10 P2-1 산출물 — Phase 2 의 compound-extractor 가 host-aware 분기 시 사용.
+ */
+export interface CodexUsage {
+    input_tokens?: number;
+    cached_input_tokens?: number;
+    output_tokens?: number;
+    reasoning_output_tokens?: number;
+}
+export interface CodexExecResult {
+    /** 모든 agent_message text 를 join. 보통 1개. */
+    readonly message: string;
+    /** 모든 agent_message segment (디버깅/multi-turn 용). */
+    readonly segments: ReadonlyArray<string>;
+    /** turn.completed 의 usage (없으면 null). */
+    readonly usage: CodexUsage | null;
+    /** thread.started 의 thread_id. */
+    readonly threadId: string | null;
+    /** parse 실패한 line 수 (의미 있는 신호 — 0 이 아니면 형식 변경 신호). */
+    readonly parseFailures: number;
+}
+/**
+ * codex exec --json 의 stdout 을 받아 agent message + 메타 추출.
+ * stderr 의 hook 발화 noise 는 *별도* — 본 함수는 stdout 만 처리.
+ *
+ * fail-open: parse 실패 line 은 무시하되 카운터로 보고.
+ */
+export declare function parseCodexJsonlOutput(stdout: string): CodexExecResult;

package/dist/host/codex-output-parser.js

@@ -0,0 +1,75 @@
+/**
+ * Codex exec --json 출력 파서 — feat/codex-support Phase 2 (P2-1)
+ *
+ * codex exec --json 의 stdout 은 JSONL — 한 줄에 하나씩 이벤트.
+ * 본 파서는 agent_message 만 추출하여 문자열로 반환.
+ *
+ * 출력 형식 (실측 2026-04-27, Codex 0.125.0):
+ *   {"type":"thread.started","thread_id":"..."}
+ *   {"type":"turn.started"}
+ *   {"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"..."}}
+ *   {"type":"turn.completed","usage":{...}}
+ *
+ * spec §10 P2-1 산출물 — Phase 2 의 compound-extractor 가 host-aware 분기 시 사용.
+ */
+/**
+ * codex exec --json 의 stdout 을 받아 agent message + 메타 추출.
+ * stderr 의 hook 발화 noise 는 *별도* — 본 함수는 stdout 만 처리.
+ *
+ * fail-open: parse 실패 line 은 무시하되 카운터로 보고.
+ */
+export function parseCodexJsonlOutput(stdout) {
+    const segments = [];
+    let usage = null;
+    let threadId = null;
+    let parseFailures = 0;
+    for (const line of stdout.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (!trimmed.startsWith('{'))
+            continue; // ANSI / status line skip
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            parseFailures += 1;
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null)
+            continue;
+        const event = parsed;
+        const type = event.type;
+        if (type === 'thread.started') {
+            const tid = event.thread_id;
+            if (typeof tid === 'string')
+                threadId = tid;
+        }
+        else if (type === 'item.completed') {
+            const item = event.item;
+            if (item?.type === 'agent_message') {
+                // Phase 2 critic fix: text 가 string 아니면 schema drift 신호 → parseFailures 증가.
+                // (Codex 가 향후 array/object content 형식 도입 시 silent miss 방지)
+                if (typeof item.text === 'string') {
+                    segments.push(item.text);
+                }
+                else {
+                    parseFailures += 1;
+                }
+            }
+        }
+        else if (type === 'turn.completed') {
+            const u = event.usage;
+            if (u && typeof u === 'object')
+                usage = u;
+        }
+    }
+    return {
+        message: segments.join('\n'),
+        segments,
+        usage,
+        threadId,
+        parseFailures,
+    };
+}

package/dist/host/exec-host.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Host-aware exec — feat/codex-support Phase 2 (P2-2/P2-3 공통)
+ *
+ * compound-extractor + auto-compound-runner 가 *어느 host CLI 로 LLM 호출* 할지
+ * 결정. profile.default_host 우선 + override 가능.
+ *
+ * 출력은 단일 string (agent message) 으로 통일 — caller 가 stdout 파싱 안 해도 됨.
+ *
+ * 호환성: 기존 'claude -p prompt --model haiku' 호출은 default_host 가 'claude' 인
+ * 경우 동일 동작. Codex 메인 사용자는 자동으로 codex exec --json 호출.
+ */
+export interface ExecHostOptions {
+    /** prompt — `-p`/`exec` 의 본문 */
+    prompt: string;
+    /** model 힌트 (claude: --model haiku, codex: 무시 — codex CLI 가 default 사용) */
+    model?: string;
+    /** child process timeout (ms). 미지정 시 host 별 기본값: claude 30s, codex 90s. */
+    timeout?: number;
+    /** working directory */
+    cwd?: string;
+    /** explicit host override (default: profile.default_host). */
+    host?: 'claude' | 'codex';
+    /** ENV vars 추가 (기존 process.env 위에 머지) */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Host 별 기본 timeout. Phase 3 deferred fix:
+ *   - claude -p 는 보통 1~5s 응답이라 30s 충분.
+ *   - codex exec --json 은 cold start + reasoning 모드로 60~90s 정상이라
+ *     30s default 가 false-positive ETIMEDOUT 발생. 90s 마진 필요.
+ *   - 명시 timeout 옵션은 그대로 우선.
+ */
+export declare const DEFAULT_TIMEOUT_BY_HOST: Record<'claude' | 'codex', number>;
+export interface ExecHostResult {
+    message: string;
+    host: 'claude' | 'codex';
+    /** 토큰 사용량 (codex 만 노출. claude 는 null). */
+    usage: {
+        input_tokens?: number;
+        output_tokens?: number;
+    } | null;
+}
+/**
+ * 실 host CLI 를 호출하여 prompt 응답 받기.
+ * - claude: `claude -p <prompt> --model <model>`
+ * - codex:  `codex exec --json -s read-only -c approval_policy="never" --ephemeral --skip-git-repo-check <prompt>`
+ *
+ * Codex 호출은 sandbox read-only + approval never + ephemeral 로 *자동 추출 안전성*
+ * 보장 (사용자 환경 미오염). compound-extractor / auto-compound-runner 같은
+ * 백그라운드 학습 호출에 적합.
+ */
+export declare function execHost(opts: ExecHostOptions): ExecHostResult;
+/** 1회 retry — transient 에러(ETIMEDOUT 등) 대응. */
+export declare function execHostRetry(opts: ExecHostOptions): ExecHostResult;

package/dist/host/exec-host.js

@@ -0,0 +1,92 @@
+/**
+ * Host-aware exec — feat/codex-support Phase 2 (P2-2/P2-3 공통)
+ *
+ * compound-extractor + auto-compound-runner 가 *어느 host CLI 로 LLM 호출* 할지
+ * 결정. profile.default_host 우선 + override 가능.
+ *
+ * 출력은 단일 string (agent message) 으로 통일 — caller 가 stdout 파싱 안 해도 됨.
+ *
+ * 호환성: 기존 'claude -p prompt --model haiku' 호출은 default_host 가 'claude' 인
+ * 경우 동일 동작. Codex 메인 사용자는 자동으로 codex exec --json 호출.
+ */
+import { execFileSync } from 'node:child_process';
+import { resolveDefaultHost } from '../store/profile-store.js';
+import { parseCodexJsonlOutput } from './codex-output-parser.js';
+/**
+ * Host 별 기본 timeout. Phase 3 deferred fix:
+ *   - claude -p 는 보통 1~5s 응답이라 30s 충분.
+ *   - codex exec --json 은 cold start + reasoning 모드로 60~90s 정상이라
+ *     30s default 가 false-positive ETIMEDOUT 발생. 90s 마진 필요.
+ *   - 명시 timeout 옵션은 그대로 우선.
+ */
+export const DEFAULT_TIMEOUT_BY_HOST = {
+    claude: 30_000,
+    codex: 90_000,
+};
+/**
+ * 실 host CLI 를 호출하여 prompt 응답 받기.
+ * - claude: `claude -p <prompt> --model <model>`
+ * - codex:  `codex exec --json -s read-only -c approval_policy="never" --ephemeral --skip-git-repo-check <prompt>`
+ *
+ * Codex 호출은 sandbox read-only + approval never + ephemeral 로 *자동 추출 안전성*
+ * 보장 (사용자 환경 미오염). compound-extractor / auto-compound-runner 같은
+ * 백그라운드 학습 호출에 적합.
+ */
+export function execHost(opts) {
+    const resolved = resolveDefaultHost(opts.host);
+    // 'ask' 는 자동 호출 컨텍스트라 명시 fallback. 그러나 Codex-only 사용자가 'ask'
+    // 설정 후 claude 가 PATH 에 없으면 ENOENT 발생 → 명시 안내. (Phase 2 critic fix)
+    const host = resolved === 'codex' ? 'codex' : 'claude';
+    if (resolved === 'ask' && opts.host === undefined) {
+        // 자동 호출에서 'ask' 도달 — caller 가 명시 host 안 줬으므로 default fallback 안내.
+        process.stderr.write('[forgen exec-host] default_host="ask" — auto-call falling back to claude. ' +
+            'If claude CLI is missing, set: forgen config default-host {claude|codex}\n');
+    }
+    const timeout = opts.timeout ?? DEFAULT_TIMEOUT_BY_HOST[host];
+    const baseOpts = {
+        encoding: 'utf-8',
+        timeout,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: opts.cwd,
+        env: { ...process.env, ...(opts.env ?? {}) },
+    };
+    if (host === 'claude') {
+        const args = ['-p', opts.prompt];
+        if (opts.model)
+            args.push('--model', opts.model);
+        const stdout = execFileSync('claude', args, baseOpts);
+        return { message: stdout.toString().trim(), host: 'claude', usage: null };
+    }
+    // host === 'codex'
+    // Phase 2 critic fix: -c approval_policy="never" 의 인용부호는 shell 처리 없이
+    // execFileSync 인자라 codex 가 literal `"never"` 로 받을 위험. quote 제거 + 실측 검증.
+    const args = [
+        'exec',
+        '--json',
+        '-s', 'read-only',
+        '-c', 'approval_policy=never',
+        '--ephemeral',
+        '--skip-git-repo-check',
+        opts.prompt,
+    ];
+    const stdout = execFileSync('codex', args, baseOpts);
+    const parsed = parseCodexJsonlOutput(stdout.toString());
+    return {
+        message: parsed.message,
+        host: 'codex',
+        usage: parsed.usage ? { input_tokens: parsed.usage.input_tokens, output_tokens: parsed.usage.output_tokens } : null,
+    };
+}
+/** 1회 retry — transient 에러(ETIMEDOUT 등) 대응. */
+export function execHostRetry(opts) {
+    try {
+        return execHost(opts);
+    }
+    catch (e) {
+        const code = e?.code;
+        if (code === 'ETIMEDOUT' || code === 'ECONNRESET') {
+            return execHost(opts);
+        }
+        throw e;
+    }
+}

package/dist/host/host-runtime.d.ts

@@ -0,0 +1,37 @@
+/**
+ * HostRuntime — Multi-Host Core Design Phase 2
+ *
+ * `runtime === 'codex'` 분기를 core 에서 제거하기 위한 host-specific 표면 모듈.
+ * spec §3.3 / §5.3 의 비대칭 경계: core 는 Claude semantics 알아도 됨, Codex 표면만 모름.
+ *
+ * 본 모듈이 노출하는 host-specific 표면:
+ *   - launcher binary 이름 (codex / claude)
+ *   - 사용자 표시 라벨 (Codex / Claude)
+ *   - hook command wrapping (Codex 는 codex-adapter 경유)
+ *   - 미설치 시 에러 메시지 (host 별 안내)
+ *
+ * core 측 코드는 본 모듈의 `getHostRuntime(runtime)` 만 호출하여 동작 분기를 위임.
+ */
+import type { RuntimeHost } from '../core/types.js';
+export interface HostRuntime {
+    readonly id: RuntimeHost;
+    /** 사용자에게 노출되는 표시명 (UI 라벨, 로그). */
+    readonly displayName: string;
+    /** 실 실행 binary 이름 또는 절대경로. PATH 에서 찾으면 됨. */
+    readonly launcher: string;
+    /** 미설치 ENOENT 시 사용자에게 노출할 안내. */
+    readonly missingInstallMessage: string;
+    /**
+     * Hook command 래핑.
+     * Claude: `node "${pluginRoot}/${script}" ${args}`
+     * Codex: `node "${pluginRoot}/host/codex-adapter.js" "${pluginRoot}/${script}" ${args}` (sandbox 호환 + projection)
+     */
+    wrapHookCommand(pluginRoot: string, scriptPath: string, args: string): string;
+    /**
+     * settings hook injection strategy.
+     *   - 'generate': generateHooksJson({runtime}) 호출 (Codex 등, host-aware wrapping 필요)
+     *   - 'pre-baked-file': pkgRoot/hooks/hooks.json 읽고 ${CLAUDE_PLUGIN_ROOT} 치환 (Claude — 빌드 산출물 재사용)
+     */
+    readonly hookInjectionStrategy: 'generate' | 'pre-baked-file';
+}
+export declare function getHostRuntime(runtime: RuntimeHost): HostRuntime;

package/dist/host/host-runtime.js

@@ -0,0 +1,51 @@
+/**
+ * HostRuntime — Multi-Host Core Design Phase 2
+ *
+ * `runtime === 'codex'` 분기를 core 에서 제거하기 위한 host-specific 표면 모듈.
+ * spec §3.3 / §5.3 의 비대칭 경계: core 는 Claude semantics 알아도 됨, Codex 표면만 모름.
+ *
+ * 본 모듈이 노출하는 host-specific 표면:
+ *   - launcher binary 이름 (codex / claude)
+ *   - 사용자 표시 라벨 (Codex / Claude)
+ *   - hook command wrapping (Codex 는 codex-adapter 경유)
+ *   - 미설치 시 에러 메시지 (host 별 안내)
+ *
+ * core 측 코드는 본 모듈의 `getHostRuntime(runtime)` 만 호출하여 동작 분기를 위임.
+ */
+function quoteArg(raw) {
+    return `"${raw.replace(/"/g, '\\"')}"`;
+}
+const claudeRuntime = {
+    id: 'claude',
+    displayName: 'Claude',
+    launcher: 'claude',
+    missingInstallMessage: 'Claude Code is not installed. npm install -g @anthropic-ai/claude-code',
+    wrapHookCommand(pluginRoot, scriptPath, args) {
+        const fullScript = `${pluginRoot}/${scriptPath}`;
+        return args ? `node ${quoteArg(fullScript)} ${args}` : `node ${quoteArg(fullScript)}`;
+    },
+    hookInjectionStrategy: 'pre-baked-file',
+};
+const codexRuntime = {
+    id: 'codex',
+    displayName: 'Codex',
+    launcher: 'codex',
+    missingInstallMessage: 'Codex is not installed.',
+    wrapHookCommand(pluginRoot, scriptPath, args) {
+        const adapterPath = `${pluginRoot}/host/codex-adapter.js`;
+        const fullScript = `${pluginRoot}/${scriptPath}`;
+        const base = `node ${quoteArg(adapterPath)} ${quoteArg(fullScript)}`;
+        return args ? `${base} ${args}` : base;
+    },
+    hookInjectionStrategy: 'generate',
+};
+const RUNTIMES = {
+    claude: claudeRuntime,
+    codex: codexRuntime,
+};
+export function getHostRuntime(runtime) {
+    const r = RUNTIMES[runtime];
+    if (!r)
+        throw new Error(`Unknown runtime host: ${runtime}`);
+    return r;
+}