@wooojin/forgen 0.4.1 → 0.4.4

package/dist/hooks/stop-guard.js

@@ -26,6 +26,9 @@ import { approve, approveWithWarning, blockStop, failOpenWithTracking } from './
 import { takeLastExtractionNotice } from '../core/extraction-notice.js';
 import { checkConclusionVerificationRatio } from '../checks/conclusion-verification-ratio.js';
 import { checkSelfScoreInflation } from '../checks/self-score-deflation.js';
+import { checkFactVsAgreement } from '../checks/fact-vs-agreement.js';
+import { checkDangerousResponsePattern } from '../checks/dangerous-response-pattern.js';
+import { sanitizeForGuard } from '../checks/_shared/text-sanitizer.js';
 import { STATE_DIR } from '../core/paths.js';
 import { sanitizeId } from './shared/sanitize-id.js';
 import { detectRecallReferences } from '../core/recall-reference-detector.js';
@@ -495,42 +498,71 @@ export async function main() {
         // block/approve 어느 경로이든 동일하게 기록 (참조는 응답 내용이 결정).
         const sessionIdForRef = input?.session_id ?? 'unknown';
         emitRecallReferencesFailOpen(sessionIdForRef, lastMessage);
-        // TEST-2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        // TEST-1/2/3: rule-free meta guards — FORGEN_USER_CONFIRMED=1 우회 공통.
+        // Pathfinder D7: 3중 보일러플레이트를 CHECKS 배열 + for-loop 디스패처로 통합.
+        // Pathfinder D4/D5: sanitizeForGuard 가 모든 체크 입력 단계에 일괄 적용.
         if (process.env.FORGEN_USER_CONFIRMED !== '1') {
             const sessionId = input?.session_id ?? 'unknown';
-            // TEST-2 (자가 점수 인플레이션): 숫자 점수 상승 선언 + 측정 도구 0회 → block.
-            // TEST-3 보다 강한 신호라 먼저 평가.
             const recentTools = loadRecentToolNames(sessionId);
-            const score = checkSelfScoreInflation({ text: lastMessage, recentTools });
-            if (score.block) {
-                recordViolation({
-                    rule_id: 'builtin:self-score-inflation',
-                    session_id: sessionId,
-                    source: 'stop-guard',
+            const sanitized = sanitizeForGuard(lastMessage);
+            // 평가 순서: DANGEROUS-RESPONSE (즉시 차단 — 안전 우선) → TEST-2 (강한 신호) → TEST-3 (텍스트 비율) → TEST-1 (alert-only).
+            const checks = [
+                {
+                    shortId: 'dangerous-response-pattern',
+                    ruleSlug: 'rule:DANGEROUS-RESPONSE — destructive command suggestion',
                     kind: 'block',
-                    message_preview: lastMessage.slice(0, 120),
-                });
-                const reasonText = `[forgen:stop-guard/self-score-inflation] ${score.reason}
-
-(Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
-                console.log(blockStop(reasonText, 'rule:TEST-2 — self-score inflation'));
-                return;
-            }
-            // TEST-3: 결론/검증 비율 — Claude 가 실제 측정 도구는 돌렸지만 서술이
-            // 결론-편향이면 여전히 block.
-            const ratio = checkConclusionVerificationRatio({ text: lastMessage });
-            if (ratio.block) {
+                    // 주의: sanitizer 가 백틱/코드블록을 제거하므로 raw lastMessage 를 전달.
+                    // 위험 명령은 코드 fence 안에 있어도 동등하게 위험함.
+                    run: () => {
+                        const r = checkDangerousResponsePattern({ text: lastMessage });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'self-score-inflation',
+                    ruleSlug: 'rule:TEST-2 — self-score inflation',
+                    kind: 'block',
+                    run: () => {
+                        const r = checkSelfScoreInflation({ text: sanitized, recentTools });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'conclusion-ratio',
+                    ruleSlug: 'rule:TEST-3 — conclusion/verification ratio',
+                    kind: 'block',
+                    run: () => {
+                        const r = checkConclusionVerificationRatio({ text: sanitized });
+                        return { triggered: r.block, reason: r.reason };
+                    },
+                },
+                {
+                    shortId: 'fact-vs-agreement',
+                    ruleSlug: 'rule:TEST-1 — fact vs agreement',
+                    kind: 'correction', // alert-level only per fact-vs-agreement.ts design
+                    run: () => {
+                        const r = checkFactVsAgreement({ text: sanitized, recentTools, minMeasurements: 1 });
+                        return { triggered: r.alert, reason: r.reason };
+                    },
+                },
+            ];
+            for (const c of checks) {
+                const out = c.run();
+                if (!out.triggered)
+                    continue;
                 recordViolation({
-                    rule_id: 'builtin:conclusion-verification-ratio',
+                    rule_id: `builtin:${c.shortId}`,
                     session_id: sessionId,
                     source: 'stop-guard',
-                    kind: 'block',
+                    kind: c.kind,
                     message_preview: lastMessage.slice(0, 120),
                 });
-                const reasonText = `[forgen:stop-guard/conclusion-ratio] ${ratio.reason}
+                if (c.kind !== 'block')
+                    continue;
+                const reasonText = `[forgen:stop-guard/${c.shortId}] ${out.reason}
 
 (Override this turn: set FORGEN_USER_CONFIRMED=1 (audited).)`;
-                console.log(blockStop(reasonText, 'rule:TEST-3 — conclusion/verification ratio'));
+                console.log(blockStop(reasonText, c.ruleSlug));
                 return;
             }
         }

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

@@ -0,0 +1,8 @@
+/**
+ * Claude HostCapabilities — Multi-Host Core Design §9.0
+ *
+ * Claude 는 reference host. 모든 TrustLayerIntent 가 supported (identity binding).
+ * 본 선언은 *spec 정의 그 자체* 의 코드 표현 — 변경 시 spec §9.0 도 같이 갱신해야 한다.
+ */
+import type { HostCapabilities } from '../core/trust-layer-intent.js';
+export declare const claudeCapabilities: HostCapabilities;

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;