@wooojin/forgen 0.4.1 → 0.4.3

package/dist/hooks/shared/forge-loop-state.js

@@ -0,0 +1,116 @@
+/**
+ * Forge Loop State — RC6 가드 (US-M1)
+ *
+ * 직전 forge-loop 의 findings 또는 진행 중 stories 를 ≤1KB 요약으로 렌더한다.
+ * SessionStart 와 UserPromptSubmit 두 hook 이 공유하는 단일 진입점.
+ *
+ * RC6 자기증거: 본 세션 R1 에서 head -80 으로 forge-loop.json 을 읽어 findings
+ * 8줄(line 92~99)이 잘렸음. 결과적으로 직전 결론을 컨텍스트에 못 가져 같은
+ * 가설을 재발. 이 모듈은 그 회귀를 시스템 레벨에서 차단한다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../../core/paths.js';
+const FORGE_LOOP_PATH = path.join(STATE_DIR, 'forge-loop.json');
+const SOFT_STALE_MS = 24 * 60 * 60 * 1000;
+const HARD_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_INJECT_BYTES = 1024;
+const MAX_TASK_CHARS = 240;
+const MAX_FINDING_CHARS = 240;
+const MAX_PENDING = 5;
+export function readForgeLoopState(filePath = FORGE_LOOP_PATH) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (typeof raw !== 'object' || raw === null)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+function ageMs(state, now = Date.now()) {
+    const ts = state.completedAt ?? state.startedAt;
+    if (!ts)
+        return Number.POSITIVE_INFINITY;
+    const t = new Date(ts).getTime();
+    if (Number.isNaN(t))
+        return Number.POSITIVE_INFINITY;
+    return now - t;
+}
+function clipBlock(block) {
+    if (block.length <= MAX_INJECT_BYTES)
+        return block;
+    return `${block.slice(0, MAX_INJECT_BYTES - 3)}...`;
+}
+function escXml(s) {
+    return s.replace(/[<>&"]/g, c => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;' })[c] ?? c);
+}
+/** SessionStart 용 — 완료된 forge-loop 의 findings 또는 진행 중 stories 요약. */
+export function renderForgeLoopForSession(state, now = Date.now()) {
+    if (!state)
+        return null;
+    const age = ageMs(state, now);
+    if (age > HARD_STALE_MS)
+        return null;
+    const stale = age > SOFT_STALE_MS;
+    const lines = [];
+    const task = String(state.task ?? '').trim();
+    if (task)
+        lines.push(`Task: ${escXml(task.slice(0, MAX_TASK_CHARS))}`);
+    if (state.active && Array.isArray(state.stories)) {
+        const total = state.stories.length;
+        const done = state.stories.filter(s => s?.passes).length;
+        lines.push(`Status: in-progress ${done}/${total}${stale ? ' (stale)' : ''}`);
+        const pending = state.stories
+            .filter(s => !s?.passes)
+            .slice(0, MAX_PENDING)
+            .map(s => `- ${escXml(String(s.id))}: ${escXml(String(s.title))}`);
+        if (pending.length) {
+            lines.push('Pending:');
+            lines.push(...pending);
+        }
+    }
+    else if (state.findings && typeof state.findings === 'object') {
+        lines.push(`Status: completed${stale ? ' (stale)' : ''}`);
+        for (const [id, val] of Object.entries(state.findings)) {
+            const text = String(val ?? '').slice(0, MAX_FINDING_CHARS);
+            if (text)
+                lines.push(`- ${escXml(id)}: ${escXml(text)}`);
+        }
+    }
+    else {
+        return null;
+    }
+    if (lines.length === 0)
+        return null;
+    const tag = stale ? '<forge-loop-state stale="true">' : '<forge-loop-state>';
+    const body = lines.join('\n');
+    return clipBlock(`${tag}\n${body}\n</forge-loop-state>`);
+}
+/** UserPromptSubmit 용 — active=true 시에만 짧은 진행 상황 1~2줄. */
+export function renderForgeLoopForPrompt(state, now = Date.now()) {
+    if (!state || !state.active || !Array.isArray(state.stories))
+        return null;
+    const age = ageMs(state, now);
+    if (age > HARD_STALE_MS)
+        return null;
+    const total = state.stories.length;
+    const done = state.stories.filter(s => s?.passes).length;
+    const next = state.stories.find(s => !s?.passes);
+    if (!next)
+        return null;
+    const stale = age > SOFT_STALE_MS;
+    const tag = stale ? '<forge-loop-active stale="true">' : '<forge-loop-active>';
+    const body = `Progress: ${done}/${total} | next: ${escXml(String(next.id))} ${escXml(String(next.title))}`;
+    return clipBlock(`${tag}\n${body}\n</forge-loop-active>`);
+}
+/** 테스트 노출용 상수 — 회귀 시 임계값 변경 즉시 감지. */
+export const FORGE_LOOP_LIMITS = {
+    SOFT_STALE_MS,
+    HARD_STALE_MS,
+    MAX_INJECT_BYTES,
+    MAX_PENDING,
+};

package/dist/hooks/shared/hook-response.d.ts

@@ -34,6 +34,24 @@ export declare function approveWithWarning(warning: string): string;
 export declare function deny(reason: string): string;
 /** 사용자 확인 요청 (PreToolUse 전용) */
 export declare function ask(reason: string): string;
+/**
+ * P3' enforcement helper (2026-04-27)
+ *
+ * ALLOW-LIST 에 있는 hook 만 진짜 deny — 아닌 경우 approve + 관찰 신호로 강등.
+ *
+ * 사용:
+ * ```ts
+ * import { canBlock } from './blocking-allowlist.js';
+ * if (someCondition) {
+ *   console.log(blockOrObserve(hookName, 'reason', logCallback));
+ *   return;
+ * }
+ * ```
+ *
+ * 점진 마이그레이션 — 본 helper 를 새로 사용하는 hook 은 ALLOW-LIST 외라면
+ * 자동 관찰 모드로 작동. 기존 hook 들은 별도 PR 에서 마이그레이션.
+ */
+export declare function denyOrObserve(hookName: string, reason: string, observer?: (msg: string) => void): string;
 /**
  * Stop hook only — block the agent from stopping and feed a self-check
  * question back to Claude so the current session resumes with new guidance.

package/dist/hooks/shared/hook-response.js

@@ -16,6 +16,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { STATE_DIR } from '../../core/paths.js';
+import { canBlock } from './blocking-allowlist.js';
 /** 통과 응답 (컨텍스트 없음, 모든 이벤트 공통) */
 export function approve() {
     return JSON.stringify({ continue: true });
@@ -65,6 +66,36 @@ export function ask(reason) {
         },
     });
 }
+/**
+ * P3' enforcement helper (2026-04-27)
+ *
+ * ALLOW-LIST 에 있는 hook 만 진짜 deny — 아닌 경우 approve + 관찰 신호로 강등.
+ *
+ * 사용:
+ * ```ts
+ * import { canBlock } from './blocking-allowlist.js';
+ * if (someCondition) {
+ *   console.log(blockOrObserve(hookName, 'reason', logCallback));
+ *   return;
+ * }
+ * ```
+ *
+ * 점진 마이그레이션 — 본 helper 를 새로 사용하는 hook 은 ALLOW-LIST 외라면
+ * 자동 관찰 모드로 작동. 기존 hook 들은 별도 PR 에서 마이그레이션.
+ */
+export function denyOrObserve(hookName, reason, observer) {
+    if (canBlock(hookName)) {
+        return deny(reason);
+    }
+    // ALLOW-LIST 외 — log only, approve
+    if (observer) {
+        try {
+            observer(`[${hookName}] would-deny (observe-only): ${reason}`);
+        }
+        catch { /* fail-open */ }
+    }
+    return approve();
+}
 /**
  * Stop hook only — block the agent from stopping and feed a self-check
  * question back to Claude so the current session resumes with new guidance.

package/dist/hooks/skill-injector.js

@@ -181,7 +181,7 @@ function collectSkills() {
     const skills = [];
     const seen = new Map(); // name → source dir
     // 패키지 내장 스킬 경로 (dist/../skills/)
-    const pkgSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'commands');
+    const pkgSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'claude', 'commands');
     // 프로젝트 .forgen > 프로젝트 .compound > 개인 > 글로벌 > 패키지 내장
     const dirs = [
         path.join(process.cwd(), '.forgen', 'skills'),

package/dist/hooks/stop-guard.js

@@ -26,6 +26,7 @@ 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 { STATE_DIR } from '../core/paths.js';
 import { sanitizeId } from './shared/sanitize-id.js';
 import { detectRecallReferences } from '../core/recall-reference-detector.js';
@@ -533,6 +534,20 @@ export async function main() {
                 console.log(blockStop(reasonText, 'rule:TEST-3 — conclusion/verification ratio'));
                 return;
             }
+            // TEST-1: 사실 vs 합의 — fact assertion 키워드가 있으나 측정 도구 호출 0건.
+            // 원 design intent (per fact-vs-agreement.ts): alert level only — block 은 TEST-2/3.
+            // 여기서는 measurement 신호를 violations.jsonl 에 'alert' kind 로 기록만 (block 안 함).
+            // wiring gap 발견 (forgen-eval introspect) → 측정 가능하게 wired up.
+            const fva = checkFactVsAgreement({ text: lastMessage, recentTools, minMeasurements: 1 });
+            if (fva.alert) {
+                recordViolation({
+                    rule_id: 'builtin:fact-vs-agreement',
+                    session_id: sessionId,
+                    source: 'stop-guard',
+                    kind: 'correction', // alert-level signal (not block) per fact-vs-agreement.ts design
+                    message_preview: lastMessage.slice(0, 120),
+                });
+            }
         }
         const rules = loadStopRules();
         if (rules.length === 0) {

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