@wooojin/forgen 0.4.5 → 0.4.7

package/dist/core/usage-telemetry.js

@@ -0,0 +1,101 @@
+/**
+ * Forgen Usage Telemetry — ADR-008 §"테마 A unattended resilience"
+ *
+ * 5h / weekly window 의 tool call 수를 sliding window 로 추적하여 statusline
+ * (`forgen me`) 에 노출. rate-limit hit 전에 사용자가 사용량을 가시화할 수 있도록.
+ *
+ * 정책:
+ *  - 각 PostToolUse 마다 append-only JSONL 에 timestamp 한 줄 기록
+ *  - read 시 sliding window 로 필터 + 카운트 (스트리밍 — 메모리 절약)
+ *  - 10K 엔트리 누적 시 weekly cap 밖 엔트리 prune (rewrite once)
+ *  - fail-open: 모든 I/O 실패는 로그 후 무시, 호출 측 차단 안 함
+ *
+ * 0.4.6 신설. limit prediction 은 의도적으로 제외 — Anthropic 의 실제 limit 가
+ * 계정/플랜별 가변이라 hard-code 부정확. raw count 만 노출하고 사용자가 판단.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from './paths.js';
+import { createLogger } from './logger.js';
+const log = createLogger('usage-telemetry');
+const TELEMETRY_PATH = path.join(STATE_DIR, 'usage-telemetry.jsonl');
+const HOUR5_MS = 5 * 60 * 60 * 1000;
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const PRUNE_THRESHOLD = 10_000; // 10K lines 누적 시 prune
+export function recordToolCall(runtime = 'claude') {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        const entry = { ts: Date.now(), rt: runtime };
+        fs.appendFileSync(TELEMETRY_PATH, `${JSON.stringify(entry)}\n`);
+    }
+    catch (e) {
+        log.debug('telemetry append 실패', e);
+    }
+}
+/**
+ * sliding window count. fail-open: 파일 미존재/parse 실패는 0 반환.
+ *
+ * @param now epoch ms (테스트 결정성)
+ */
+export function getUsageStats(now = Date.now()) {
+    const stats = {
+        hour5: { claude: 0, codex: 0, total: 0 },
+        week: { claude: 0, codex: 0, total: 0 },
+    };
+    try {
+        if (!fs.existsSync(TELEMETRY_PATH))
+            return stats;
+        const cutoff5h = now - HOUR5_MS;
+        const cutoffWeek = now - WEEK_MS;
+        const raw = fs.readFileSync(TELEMETRY_PATH, 'utf-8');
+        const lines = raw.split('\n');
+        let total = 0;
+        for (const line of lines) {
+            if (!line)
+                continue;
+            total++;
+            try {
+                const e = JSON.parse(line);
+                if (typeof e.ts !== 'number' || e.ts < cutoffWeek)
+                    continue;
+                const rt = e.rt === 'codex' ? 'codex' : 'claude';
+                stats.week[rt]++;
+                stats.week.total++;
+                if (e.ts >= cutoff5h) {
+                    stats.hour5[rt]++;
+                    stats.hour5.total++;
+                }
+            }
+            catch { /* skip malformed line */ }
+        }
+        if (total > PRUNE_THRESHOLD)
+            pruneOldEntries(now);
+    }
+    catch (e) {
+        log.debug('telemetry read 실패', e);
+    }
+    return stats;
+}
+/** 누적 엔트리가 PRUNE_THRESHOLD 초과 시 weekly cap 밖 entry 제거 (rewrite). */
+function pruneOldEntries(now) {
+    try {
+        const cutoff = now - WEEK_MS;
+        const raw = fs.readFileSync(TELEMETRY_PATH, 'utf-8');
+        const kept = [];
+        for (const line of raw.split('\n')) {
+            if (!line)
+                continue;
+            try {
+                const e = JSON.parse(line);
+                if (typeof e.ts === 'number' && e.ts >= cutoff)
+                    kept.push(line);
+            }
+            catch { /* drop malformed */ }
+        }
+        fs.writeFileSync(TELEMETRY_PATH, kept.join('\n') + (kept.length ? '\n' : ''));
+        log.debug(`telemetry pruned to ${kept.length} entries`);
+    }
+    catch (e) {
+        log.debug('telemetry prune 실패', e);
+    }
+}

package/dist/fgx.js

@@ -11,9 +11,10 @@ const args = process.argv.slice(2);
 // 이미 포함되어 있으면 중복 추가하지 않음
 const launchContext = resolveLaunchContext(args);
 const runtime = launchContext.runtime;
+const skipFlag = getHostRuntime(runtime).dangerousSkipFlag;
 const launchArgs = [...launchContext.args];
-if (!launchArgs.includes('--dangerously-skip-permissions')) {
-    launchArgs.unshift('--dangerously-skip-permissions');
+if (!launchArgs.includes(skipFlag)) {
+    launchArgs.unshift(skipFlag);
 }
 async function main() {
     // Security warning — fgx bypasses all Claude Code permission checks.
@@ -23,8 +24,8 @@ async function main() {
     // alias `fgx` unknowingly run with zero guardrails. Users who rely on
     // the profile trust policy should NOT use `fgx`. Surface the mismatch
     // loudly (harness.ts also prints the Trust 상승 warning downstream).
-    console.warn('\n  ⚠  fgx: ALL permission checks are disabled (--dangerously-skip-permissions)');
-    console.warn('  ⚠  Claude Code will execute tools without asking for confirmation.');
+    console.warn(`\n  ⚠  fgx: ALL permission checks are disabled (${skipFlag})`);
+    console.warn(`  ⚠  ${getHostRuntime(runtime).displayName} will execute tools without asking for confirmation.`);
     console.warn('  ⚠  Use only in trusted environments. If your profile trust policy is');
     console.warn('  ⚠  "가드레일 우선" or "승인 완화", consider `forgen` (no flag) instead.\n');
     // fgx는 서브커맨드 없이 바로 Claude Code 실행 전용
@@ -43,7 +44,7 @@ async function main() {
     if (v1.session) {
         console.log(`[forgen] Trust: ${v1.session.effective_trust_policy}`);
     }
-    console.log('[forgen] Mode: dangerously-skip-permissions');
+    console.log(`[forgen] Mode: ${skipFlag.replace(/^--/, '')}`);
     const runtimeLabel = getHostRuntime(runtime).displayName;
     console.log(`[forgen] Starting ${runtimeLabel}...\n`);
     await spawnClaude(launchArgs, context, runtime);

package/dist/hooks/context-guard.d.ts

@@ -9,6 +9,19 @@
  * 또한 UserPromptSubmit에서 현재 대화 길이를 추적하여
  * context 한계에 접근 시 preemptive 경고를 제공합니다.
  */
+export declare const TOKEN_LIMIT_REGEX: RegExp;
+export declare const RATE_LIMIT_REGEX: RegExp;
+/**
+ * Best-effort reset 시각 파서 (ADR-008 §2).
+ *
+ * 5 패턴 시도, 모두 실패 시 null. 실제 메시지 포맷은 Claude/Codex CLI 의
+ * 공식 contract 가 아니므로 hotfix 가능한 best-effort.
+ *
+ * @param msg stderr/error message text
+ * @param now epoch ms (테스트 결정성 위해 주입 가능)
+ * @returns ISO timestamp 또는 null
+ */
+export declare function parseRateLimitResetAt(msg: string, now?: number): string | null;
 /** 경고 표시 여부 판정 (순수 함수) */
 export declare function shouldWarn(contextPercent: {
     promptCount: number;

package/dist/hooks/context-guard.js

@@ -21,8 +21,111 @@ import { approve, approveWithContext, approveWithWarning, failOpenWithTracking }
 import { HANDOFFS_DIR, STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
 import { sanitizeId } from './shared/sanitize-id.js';
+import { redactSecrets } from './secret-filter.js';
 const log = createLogger('context-guard');
 const CONTEXT_STATE_PATH = path.join(STATE_DIR, 'context-guard.json');
+const PROMPT_HISTORY_PATH = path.join(STATE_DIR, 'prompt-history.jsonl');
+const PROMPT_HISTORY_TRUNCATE = 1024; // ADR-008: 1KB cap per entry
+const RATE_LIMIT_MISSES_PATH = path.join(STATE_DIR, 'rate-limit-misses.jsonl');
+// ADR-008: detection regex 분리. token-limit 은 context window, rate-limit 은 API quota.
+export const TOKEN_LIMIT_REGEX = /context.*limit|token.*limit|conversation.*too.*long/i;
+export const RATE_LIMIT_REGEX = /rate.?limit|5.?hour.*limit|weekly.*limit|usage.*limit|quota.*exceeded/i;
+/**
+ * Best-effort reset 시각 파서 (ADR-008 §2).
+ *
+ * 5 패턴 시도, 모두 실패 시 null. 실제 메시지 포맷은 Claude/Codex CLI 의
+ * 공식 contract 가 아니므로 hotfix 가능한 best-effort.
+ *
+ * @param msg stderr/error message text
+ * @param now epoch ms (테스트 결정성 위해 주입 가능)
+ * @returns ISO timestamp 또는 null
+ */
+export function parseRateLimitResetAt(msg, now = Date.now()) {
+    // Pattern 4: explicit ISO timestamp — "available again at <ISO>"
+    const isoMatch = msg.match(/(?:available|reset|retry)\s+(?:again\s+)?(?:at|on)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)/i);
+    if (isoMatch) {
+        const ts = Date.parse(isoMatch[1]);
+        if (Number.isFinite(ts))
+            return new Date(ts).toISOString();
+    }
+    // Pattern 2: "Resets in 4h 12m" / "in 4h" / "in 12m"
+    const hMin = msg.match(/(?:reset|retry|try\s+again)s?\s+in\s+(?:(\d+)\s*h)?\s*(?:(\d+)\s*m(?:in)?)?/i);
+    if (hMin && (hMin[1] || hMin[2])) {
+        const hours = parseInt(hMin[1] ?? '0', 10);
+        const mins = parseInt(hMin[2] ?? '0', 10);
+        const offset = (hours * 3600 + mins * 60) * 1000;
+        if (offset > 0)
+            return new Date(now + offset).toISOString();
+    }
+    // Pattern 3: "Resets in 18000 seconds"
+    const secMatch = msg.match(/(?:reset|retry|try\s+again)s?\s+in\s+(\d+)\s*sec(?:ond)?s?/i);
+    if (secMatch) {
+        const sec = parseInt(secMatch[1], 10);
+        if (sec > 0)
+            return new Date(now + sec * 1000).toISOString();
+    }
+    // Pattern 1: "Resets at HH:MM(:SS)? TZ" — TZ 미지원 (UTC 가정)
+    const hhmm = msg.match(/(?:reset|retry|available)s?\s+at\s+(\d{1,2}):(\d{2})(?::(\d{2}))?\s*(UTC|GMT|PST|PDT|EST|EDT|KST|JST)?/i);
+    if (hhmm) {
+        const h = parseInt(hhmm[1], 10);
+        const m = parseInt(hhmm[2], 10);
+        const s = parseInt(hhmm[3] ?? '0', 10);
+        if (h < 24 && m < 60 && s < 60) {
+            const d = new Date(now);
+            d.setUTCHours(h, m, s, 0);
+            // 이미 지난 시각이면 다음 날
+            if (d.getTime() <= now)
+                d.setUTCDate(d.getUTCDate() + 1);
+            return d.toISOString();
+        }
+    }
+    return null;
+}
+/**
+ * Detector 실패 (RATE_LIMIT_REGEX 매칭 실패) raw 메시지를 누적.
+ * ADR-008 §5: 5건 누적 시 사용자 경고 — patch release 로 hotfix 신호.
+ */
+function logRateLimitMiss(errorMsg) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.appendFileSync(RATE_LIMIT_MISSES_PATH, `${JSON.stringify({
+            timestamp: new Date().toISOString(),
+            message: errorMsg.slice(0, 500),
+        })}\n`);
+    }
+    catch (e) {
+        log.debug('rate-limit-miss log 실패', e);
+    }
+}
+/**
+ * Append-only prompt history writer (docs/codex-integration.md §"prompt-history.jsonl").
+ *
+ * compound-extractor.ts:547 의 read 코드가 0.4.5 까지 dead code 였음. 0.4.6
+ * 부터 UserPromptSubmit hook 에서 truncated prompt 를 append 하여 활성화.
+ *
+ * fail-open: 실패는 hook 차단하지 않음.
+ */
+function appendPromptHistory(sessionId, prompt) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        // ADR-008 critical: secret/PII redaction via secret-filter regex 재사용.
+        // password/api-key 가 평문 prompt 에 들어가면 그대로 disk 에 박제되는 위험 차단.
+        const safePrompt = redactSecrets(prompt).redacted;
+        const truncated = safePrompt.length > PROMPT_HISTORY_TRUNCATE
+            ? safePrompt.slice(0, PROMPT_HISTORY_TRUNCATE)
+            : safePrompt;
+        const entry = JSON.stringify({
+            timestamp: new Date().toISOString(),
+            sessionId,
+            promptLength: prompt.length,
+            prompt: truncated,
+        });
+        fs.appendFileSync(PROMPT_HISTORY_PATH, `${entry}\n`);
+    }
+    catch (e) {
+        log.debug('prompt-history append 실패', e);
+    }
+}
 // 경고 임계값: 프롬프트 50회 또는 총 문자 수 200K 이상
 const PROMPT_WARNING_THRESHOLD = 50;
 const CHARS_WARNING_THRESHOLD = 200_000;
@@ -108,16 +211,20 @@ export async function main() {
                 console.log(forgeLoopBlock);
                 return;
             }
-            // 에러가 포함된 경우: context limit 감지
+            // 에러가 포함된 경우: context-limit / rate-limit 감지 (ADR-008)
             if (input.error) {
                 const errorMsg = input.error;
-                if (/context.*limit|token.*limit|conversation.*too.*long/i.test(errorMsg)) {
+                // FORGEN_RUNTIME 은 buildEnv (config-injector.ts:479) 에서 spawn 시 주입.
+                // hook 은 claude/codex CLI 를 통해 invoke 되어 부모 env 상속.
+                const runtime = process.env.FORGEN_RUNTIME ?? 'claude';
+                if (TOKEN_LIMIT_REGEX.test(errorMsg)) {
                     saveHandoff(sessionId, 'context-limit', errorMsg);
                     try {
                         const resumePath = path.join(STATE_DIR, 'pending-resume.json');
                         fs.writeFileSync(resumePath, JSON.stringify({
                             reason: 'token-limit',
                             sessionId,
+                            runtime,
                             savedAt: new Date().toISOString(),
                             cwd: process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd(),
                         }, null, 2));
@@ -126,6 +233,30 @@ export async function main() {
                     console.log(approveWithWarning(`[Forgen] Context limit reached. Current state has been saved to ~/.forgen/handoffs/.\nThe previous work will be automatically recovered in the next session.`));
                     return;
                 }
+                if (RATE_LIMIT_REGEX.test(errorMsg)) {
+                    const resetAt = parseRateLimitResetAt(errorMsg);
+                    saveHandoff(sessionId, 'rate-limit', errorMsg);
+                    try {
+                        const resumePath = path.join(STATE_DIR, 'pending-resume.json');
+                        fs.writeFileSync(resumePath, JSON.stringify({
+                            reason: 'rate-limit',
+                            sessionId,
+                            runtime,
+                            resetAt,
+                            savedAt: new Date().toISOString(),
+                            cwd: process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd(),
+                        }, null, 2));
+                    }
+                    catch { /* fail-open */ }
+                    const eta = resetAt ? `at ${resetAt}` : 'with backoff schedule';
+                    console.log(approveWithWarning(`[Forgen] Rate limit reached. Auto-resume scheduled ${eta}. State saved to ~/.forgen/handoffs/.`));
+                    return;
+                }
+                // ADR-008 §5: detection 실패 raw 누적 → patch hotfix 신호
+                // (어느 limit regex 도 매칭 안 됨 = unknown error 또는 detector miss)
+                if (/limit|quota|throttle/i.test(errorMsg)) {
+                    logRateLimitMiss(errorMsg);
+                }
             }
             // 정상 종료 시: 의미 있는 세션이었으면 compound 안내/자동 트리거
             if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
@@ -175,6 +306,8 @@ export async function main() {
             const state = loadContextState(sessionId);
             state.promptCount++;
             state.totalChars += input.prompt.length;
+            // ADR-008 / docs/codex-integration.md — prompt-history writer 활성화
+            appendPromptHistory(sessionId, input.prompt);
             // auto-compact: 추적 문자 120K 이상이면 compact 지시 주입
             const autoCompactThreshold = typeof config?.autoCompactChars === 'number' ? config.autoCompactChars : undefined;
             if (shouldAutoCompact(state, autoCompactThreshold !== undefined ? { charsThreshold: autoCompactThreshold } : {})) {
@@ -246,7 +379,24 @@ const FORGE_LOOP_STATE_PATH = path.join(STATE_DIR, 'forge-loop.json');
  * dedup 파일은 session-recovery hook 과 공유되어 double-run 방지.
  * fire-and-forget (detached) — hook timeout 과 무관.
  */
-const AUTO_COMPOUND_COOLDOWN_MS = 5 * 60 * 1000; // 5 min
+const AUTO_COMPOUND_COOLDOWN_MS = 5 * 60 * 1000; // 5 min (default)
+const AUTO_COMPOUND_BARREN_COOLDOWN_MS = 30 * 60 * 1000; // 30 min if last run extracted nothing
+/**
+ * 0.4.6 perf #12 — adaptive cooldown.
+ *
+ * 마지막 auto-compound run 이 0건 추출했으면 (barren), 다음 cooldown 을 5min →
+ * 30min 으로 확장. 같은 session 의 짧은 prompt 추가에서 동일 transcript 로 매번
+ * 3 LLM 호출하는 wasted run 차단. completed marker 의 extractedSolutions /
+ * promotedRules / userPatternFound 합산이 0 이면 barren 판정.
+ *
+ * 일반 case (추출 있음) 은 5분 cooldown 유지 — adaptive 가 sparsity 시그널을
+ * 강화할 뿐 정상 동작 차단 안 함.
+ */
+function effectiveCooldownMs(parsed) {
+    const total = (parsed.extractedSolutions ?? 0) + (parsed.promotedRules ?? 0)
+        + (parsed.userPatternFound ? 1 : 0);
+    return total === 0 ? AUTO_COMPOUND_BARREN_COOLDOWN_MS : AUTO_COMPOUND_COOLDOWN_MS;
+}
 async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
     if (!transcriptPath || promptCount < 10)
         return;
@@ -256,7 +406,8 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
         const parsed = JSON.parse(raw);
         if (parsed.sessionId === sessionId) {
             const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
-            if (Number.isFinite(last) && Date.now() - last < AUTO_COMPOUND_COOLDOWN_MS)
+            const cooldown = effectiveCooldownMs(parsed);
+            if (Number.isFinite(last) && Date.now() - last < cooldown)
                 return;
         }
     }

package/dist/hooks/post-tool-use.js

@@ -21,6 +21,7 @@ import { STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
 import { createDriftState, evaluateDrift } from '../core/drift-score.js';
 import { appendImplicitFeedback } from '../store/implicit-feedback-store.js';
+import { recordToolCall } from '../core/usage-telemetry.js';
 const RECENT_TOOL_NAMES_WINDOW = 20;
 /** Lightweight hash for content comparison (not cryptographic) */
 function simpleHash(content) {
@@ -118,6 +119,8 @@ async function main() {
             console.log(approve());
             return;
         }
+        // ADR-008 / 0.4.6 — usage telemetry. fail-open, hook 차단 안 함.
+        recordToolCall(process.env.FORGEN_RUNTIME ?? 'claude');
         const toolName = data.tool_name ?? data.toolName ?? '';
         const toolInput = data.tool_input ?? data.toolInput ?? {};
         // tool_response 는 string / object / array 모두 가능 (sub-agent 결과는 object 가 흔함).

package/dist/hooks/pre-tool-use.js

@@ -165,6 +165,32 @@ function getActiveReminders() {
     }
     return reminders;
 }
+/**
+ * Tool-call supplement log (ADR-008 / docs/codex-integration.md).
+ *
+ * Codex `approval_policy=auto`/`workspace-write` 환경에서 PermissionRequest
+ * hook 이 dispatch 되지 않아 `permissions-<id>.jsonl` 가 생성되지 않는 갭을
+ * 보완. 모든 PreToolUse 호출에서 동일 파일에 append (source='pre-tool-use'
+ * 로 구분). permission-handler 의 entry 와 source 필드로 reader 측 dedup.
+ *
+ * fail-open: write 실패는 hook 차단하지 않음.
+ */
+function logToolCallSupplement(sessionId, toolName) {
+    try {
+        const logPath = path.join(STATE_DIR, `permissions-${sanitizeId(sessionId)}.jsonl`);
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        const entry = JSON.stringify({
+            timestamp: new Date().toISOString(),
+            tool: toolName,
+            decision: 'pre-approved',
+            source: 'pre-tool-use',
+        });
+        fs.appendFileSync(logPath, `${entry}\n`);
+    }
+    catch (e) {
+        log.debug('tool-call supplement log 실패', e);
+    }
+}
 /** 연속 파싱 실패 카운터 관리 */
 function getAndIncrementFailCount() {
     try {
@@ -322,6 +348,11 @@ async function main() {
         const toolName = data.tool_name ?? data.toolName ?? '';
         const toolInput = data.tool_input ?? data.toolInput ?? {};
         const sessionId = data.session_id ?? 'default';
+        // ADR-008 / codex-integration.md — Codex `approval_policy=auto` 에서
+        // PermissionRequest 가 dispatch 안 되는 갭 보완. 모든 tool call 을
+        // permissions-<id>.jsonl 에 supplement 로 append (source='pre-tool-use').
+        if (toolName)
+            logToolCallSupplement(sessionId, toolName);
         // ADR-001 Mech-A PreToolUse dispatcher — 사용자가 정의한 rule 이 빌트인 위험-명령 감지보다 먼저.
         // 이렇게 해야 rule.block_message (맥락 있는 안내) 가 제네릭 "Dangerous command blocked" 대신 노출됨.
         // fail-open: 예외는 hook 차단 안 함.

package/dist/hooks/session-recovery.js

@@ -149,6 +149,17 @@ async function main() {
             console.log(approve());
             return;
         }
+        // 0.4.6 — codex/claude 진입점 양쪽에서 v1-bootstrap 보장.
+        // 이전엔 prepareHarness (fgx/forgen wrapper) 만 호출 → 직접 claude/codex 호출 시
+        // ~/.forgen/state/sessions/<id>.json 미생성. SessionStart hook 에서도 호출하여
+        // 양쪽 진입 경로 모두에서 session state 박제.
+        try {
+            const { bootstrapV1Session } = await import('../core/v1-bootstrap.js');
+            bootstrapV1Session();
+        }
+        catch (e) {
+            log.debug('v1-bootstrap SessionStart 호출 실패 (fail-open)', e);
+        }
         if (!fs.existsSync(STATE_DIR)) {
             console.log(approve());
             return;

package/dist/hooks/shared/read-stdin.js

@@ -5,54 +5,69 @@
  * (for await of process.stdin은 일부 환경에서 hang 발생)
  */
 const MAX_STDIN_BYTES = 10 * 1024 * 1024; // 10MB — 메모리 고갈 방지
+/**
+ * 0.4.6 perf #11 — idle-based early resolve + initial-wait fallback.
+ *
+ * Claude/Codex CLI 가 hook 호출 후 stdin 을 EOF 닫지 않고 hang on 하는 케이스가 있어
+ * 이전엔 timeoutMs (2000ms) 까지 무조건 대기 → p95 hook latency 가 2003ms 였음
+ * (hook-timing.jsonl 측정 결과).
+ *
+ * 두 단계 fix:
+ *  1. IDLE_RESOLVE_MS — 'data' 받은 후 추가 chunk 없으면 100ms 후 resolve
+ *  2. INITIAL_WAIT_MS — 'data' 자체가 안 오는 케이스 (codex 일부 hook event)
+ *     를 대비해 INITIAL_WAIT_MS 후 chunks 가 비어 있으면 빈 데이터로 resolve
+ *
+ * 합법적 데이터 손실 위험 없음 — Claude/Codex 의 stdin 페이로드는 호출 즉시
+ * (≤ INITIAL_WAIT_MS) 첫 chunk 도착. 안 오면 그 이벤트는 stdin 자체가 없는 것.
+ */
+const IDLE_RESOLVE_MS = 100;
+const INITIAL_WAIT_MS = 300;
 /** stdin에서 JSON 데이터를 읽어 파싱. 실패 시 null 반환. */
 export async function readStdinJSON(timeoutMs = 2000) {
     const chunks = [];
     let totalSize = 0;
     let settled = false;
+    let idleTimer = null;
     const raw = await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-            if (!settled) {
-                settled = true;
-                process.stdin.removeAllListeners();
+        const settle = (clearIdle = true) => {
+            if (settled)
+                return;
+            settled = true;
+            if (clearIdle && idleTimer)
+                clearTimeout(idleTimer);
+            clearTimeout(timeout);
+            process.stdin.removeAllListeners();
+            if (typeof process.stdin.pause === 'function')
                 process.stdin.pause();
-                resolve(Buffer.concat(chunks).toString('utf-8'));
-            }
-        }, timeoutMs);
+            resolve(Buffer.concat(chunks).toString('utf-8'));
+        };
+        const timeout = setTimeout(() => settle(), timeoutMs);
+        // perf: INITIAL_WAIT_MS 안에 'data' 가 한 번도 안 오면 stdin 부재로 간주, 조기 resolve.
+        // codex 일부 hook event (e.g. SessionStart, Stop without payload) 가 stdin 안 보내는 케이스 대응.
+        const initialWait = setTimeout(() => {
+            if (!settled && chunks.length === 0)
+                settle();
+        }, INITIAL_WAIT_MS);
         // 일부 Node.js 환경에서 stdin이 paused 상태로 시작 — 명시적 resume 필요
         if (typeof process.stdin.resume === 'function') {
             process.stdin.resume();
         }
         process.stdin.on('data', (chunk) => {
+            clearTimeout(initialWait);
             const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
             totalSize += buf.length;
             if (totalSize > MAX_STDIN_BYTES) {
-                if (!settled) {
-                    settled = true;
-                    clearTimeout(timeout);
-                    process.stdin.removeAllListeners();
-                    if (typeof process.stdin.pause === 'function')
-                        process.stdin.pause();
-                    resolve('');
-                }
+                settle();
                 return;
             }
             chunks.push(buf);
+            // perf: 데이터 수신 후 IDLE_RESOLVE_MS 동안 추가 chunk 없으면 early resolve
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => settle(false), IDLE_RESOLVE_MS);
         });
-        process.stdin.on('end', () => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timeout);
-                resolve(Buffer.concat(chunks).toString('utf-8'));
-            }
-        });
-        process.stdin.on('error', () => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timeout);
-                resolve('');
-            }
-        });
+        process.stdin.on('end', () => settle());
+        process.stdin.on('error', () => settle());
     });
     try {
         return JSON.parse(raw);

package/dist/host/codex-adapter.js

@@ -55,11 +55,16 @@ async function main() {
         }
     })();
     try {
+        // 0.4.6 fix — delegate hook 이 자기가 codex runtime context 인지 알 수 있게
+        // FORGEN_RUNTIME=codex 명시 주입. 이전엔 buildEnv (forgen wrapper) 경로로만
+        // set 되어 codex 직접 호출 시 default 'claude' 로 fall-through → usage-telemetry
+        // 의 rt 필드가 잘못 박힘 (clean-container e2e 라운드 20 에서 발견).
         const result = spawnSync(process.execPath, [delegatePath, ...restArgs], {
             encoding: 'utf-8',
             input: JSON.stringify(input),
             cwd: process.cwd(),
             stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, FORGEN_RUNTIME: 'codex' },
         });
         if (result.error) {
             console.log(JSON.stringify({ continue: true }));

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

@@ -33,5 +33,11 @@ export interface HostRuntime {
      *   - 'pre-baked-file': pkgRoot/hooks/hooks.json 읽고 ${CLAUDE_PLUGIN_ROOT} 치환 (Claude — 빌드 산출물 재사용)
      */
     readonly hookInjectionStrategy: 'generate' | 'pre-baked-file';
+    /**
+     * 권한 전수 우회용 CLI 플래그 (fgx 등 dangerously-skip 모드에서 사용).
+     * Claude: --dangerously-skip-permissions
+     * Codex:  --dangerously-bypass-approvals-and-sandbox
+     */
+    readonly dangerousSkipFlag: string;
 }
 export declare function getHostRuntime(runtime: RuntimeHost): HostRuntime;

package/dist/host/host-runtime.js

@@ -25,6 +25,7 @@ const claudeRuntime = {
         return args ? `node ${quoteArg(fullScript)} ${args}` : `node ${quoteArg(fullScript)}`;
     },
     hookInjectionStrategy: 'pre-baked-file',
+    dangerousSkipFlag: '--dangerously-skip-permissions',
 };
 const codexRuntime = {
     id: 'codex',
@@ -38,6 +39,7 @@ const codexRuntime = {
         return args ? `${base} ${args}` : base;
     },
     hookInjectionStrategy: 'generate',
+    dangerousSkipFlag: '--dangerously-bypass-approvals-and-sandbox',
 };
 const RUNTIMES = {
     claude: claudeRuntime,

package/dist/host/install-codex.js

@@ -23,13 +23,19 @@ const AGENTS_MD_END = '<!-- <<< forgen-managed-rules -->';
 function resolveCodexHome(opts) {
     return opts.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
 }
+// 0.4.6 fix — pkgRoot match 외에 script-marker fallback 추가.
+// Stale install path (예: 다른 머신에서 install 한 hooks.json 마운트, 또는
+// node_modules path 변경) 의 forgen entry 를 "user entry" 로 오분류 → 중복 누적
+// 하던 버그. forgen hook 의 시그니처는 dist/host/codex-adapter.js 또는
+// dist/hooks/<name>.js — 사용자 custom hook 과 충돌 가능성 거의 없음.
+const FORGEN_HOOK_SCRIPT_MARKER = /\bdist\/(host\/codex-adapter|hooks\/[a-z][a-z0-9-]+)\.js\b/;
 function isForgenManagedHook(entry, pkgRoot) {
     if (!entry || typeof entry !== 'object')
         return false;
     const e = entry;
     if (!Array.isArray(e.hooks))
         return false;
-    return e.hooks.some((h) => typeof h.command === 'string' && h.command.includes(pkgRoot));
+    return e.hooks.some((h) => typeof h.command === 'string' && (h.command.includes(pkgRoot) || FORGEN_HOOK_SCRIPT_MARKER.test(h.command)));
 }
 function readJsonFile(p) {
     try {

package/dist/host/install-orchestrator.js

@@ -12,6 +12,7 @@
  */
 import * as path from 'node:path';
 import * as readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
 import { detectAvailableHosts } from '../core/host-detect.js';
 import { planClaudeInstall } from './install-claude.js';
 import { planCodexInstall } from './install-codex.js';
@@ -121,6 +122,6 @@ export function renderResult(result, dryRun) {
 }
 /** pkgRoot resolve from binary location (dist/cli.js → pkgRoot). */
 export function resolvePkgRootFromBinary(metaUrl) {
-    const here = path.dirname(new URL(metaUrl).pathname);
+    const here = path.dirname(fileURLToPath(metaUrl));
     return path.resolve(here, '..');
 }

package/dist/services/session.js

@@ -85,6 +85,19 @@ export function resolveLaunchContext(args) {
             }
             continue;
         }
+        // 0.4.6 — shortcut flags `--codex` / `--claude` (= `--runtime codex|claude`).
+        // fgx --codex 같은 짧은 호출을 위해. claude/codex CLI 가 동일 이름 플래그를
+        // 자체적으로 정의하지 않는 한 forwarding 충돌 없음.
+        if (arg === '--codex') {
+            result.runtime = 'codex';
+            result.runtimeSource = 'flag';
+            continue;
+        }
+        if (arg === '--claude') {
+            result.runtime = 'claude';
+            result.runtimeSource = 'flag';
+            continue;
+        }
         result.args.push(arg);
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wooojin/forgen",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "preferGlobal": true,
   "main": "dist/lib.js",
   "types": "./dist/lib.d.ts",