@wooojin/forgen 0.5.0 → 0.5.6

package/dist/core/spawn.js

@@ -112,7 +112,7 @@ function findSessionTranscript(cwd, sessionStartMs, preSnapshot, runtime = 'clau
  *
  * 단일 함수에서 둘 다 처리 — schema 자동 감지.
  */
-async function countUserMessages(transcriptPath) {
+export async function countUserMessages(transcriptPath) {
     const { createInterface } = await import('node:readline');
     const stream = fs.createReadStream(transcriptPath, { encoding: 'utf-8' });
     const rl = createInterface({ input: stream, crlfDelay: Infinity });
@@ -300,6 +300,18 @@ export function releaseAutoCompoundInflight(sessionId) {
         /* noop */
     }
 }
+/**
+ * ~/.forgen/state/auto-compound/<sessionId>.log — 세션별 러너 로그 경로.
+ *
+ * 결함2 관측성 fix (2026-08-18): 이전엔 detached spawn 을 `stdio: 'ignore'` 로
+ * 실행해 러너의 stdout/stderr(진단 메시지 포함)를 통째로 버렸다. 그 결과 solution
+ * extraction 이 98/98 sweep 에서 `extractedSolutions=0` 을 기록해도 원인을 알 방법이
+ * 없었다(완전 무음 실패). 이제 fd 를 파일로 열어 넘겨 러너의 모든 출력을 세션별
+ * 로그로 남긴다 — 다음 실패 모드를 디버그 가능하게 만드는 전제 조건.
+ */
+export function autoCompoundLogPath(sessionId) {
+    return path.join(STATE_DIR, 'auto-compound', `${sessionId.replace(/[^a-zA-Z0-9_-]/g, '_')}.log`);
+}
 export function runAutoCompound(cwd, transcriptPath, sessionId, promptCount = 0) {
     const now = Date.now();
     // 1. 완료 마커 cooldown (secondary, 단일슬롯 — 값싼 read 먼저).
@@ -322,17 +334,40 @@ export function runAutoCompound(cwd, transcriptPath, sessionId, promptCount = 0)
         return 'skipped-inflight';
     }
     const runnerPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'auto-compound-runner.js');
+    // 로그 파일 fd 열기 — 실패(디스크 문제 등)해도 fail-open 으로 'ignore' 폴백.
+    const logPath = autoCompoundLogPath(sessionId);
+    let logFd;
     try {
-        const child = spawn('node', [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
+        fs.mkdirSync(path.dirname(logPath), { recursive: true });
+        logFd = fs.openSync(logPath, 'a');
+    }
+    catch (e) {
+        log.debug('auto-compound 로그 파일 열기 실패 — stdio ignore로 폴백', e);
+    }
+    try {
+        // 결함2 corrected fix (2026-08-19): 리터럴 'node' 대신 process.execPath 로 spawn.
+        // 실 cron 은 절대 nvm node 경로로 sweep 를 돌리는데, 러너를 'node' 로 spawn 하면
+        // cron sparse PATH 의 /bin/node 로 해석돼 러너의 process.execPath 가 달라지고,
+        // 러너가 forgen(nvm 형제 바이너리)을 절대경로로 못 찾아 solution write 가 ENOENT 로
+        // 실패한다. execPath 를 물려주면 러너가 sweep 과 같은 node(=forgen 형제)를 상속한다.
+        const child = spawn(process.execPath, [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
             cwd,
             detached: true,
-            stdio: 'ignore',
+            stdio: logFd !== undefined ? ['ignore', logFd, logFd] : 'ignore',
         });
         child.unref();
+        if (logFd !== undefined)
+            fs.closeSync(logFd); // child가 dup — 부모 측 fd는 닫아도 안전
         console.log('\n[forgen] 세션 분석을 백그라운드로 시작했습니다 (자동 compound) — 결과는 다음 세션 시작 시 반영됩니다.\n');
         return 'spawned';
     }
     catch (e) {
+        if (logFd !== undefined) {
+            try {
+                fs.closeSync(logFd);
+            }
+            catch { /* noop */ }
+        }
         log.debug('auto-compound 시작 실패', e);
         releaseAutoCompoundInflight(sessionId); // spawn 실패 시 표식 제거 → 재시도 가능
         return 'failed';

package/dist/core/uninstall.d.ts

@@ -1,3 +1,10 @@
+/** ADR-016 D3 — ~/.claude/skills/verify 제거 (forgen-managed 마커가 있는 것만; 사용자 스킬은 보존) */
+export declare function cleanVerifySkill(homeDir?: string): boolean;
+/**
+ * ADR-016 D1 — Codex config.toml 의 forgen notify 블록 제거. 남겨 두면 Codex 가 매 턴 사라진 스크립트를
+ * spawn 한다. (Codex hooks.json / MCP 블록 정리는 아직 uninstall 범위 밖 — 알려진 갭.)
+ */
+export declare function cleanCodexNotify(codexHome?: string): Promise<boolean>;
 /** forgen uninstall 메인 */
 export declare function handleUninstall(cwd: string, options: {
     force?: boolean;

package/dist/core/uninstall.js

@@ -96,6 +96,47 @@ function cleanSlashCommands() {
         console.log('  - No forgen-managed slash commands found');
     }
 }
+/** ADR-016 D3 — ~/.claude/skills/verify 제거 (forgen-managed 마커가 있는 것만; 사용자 스킬은 보존) */
+export function cleanVerifySkill(homeDir = os.homedir()) {
+    const dir = path.join(homeDir, '.claude', 'skills', 'verify');
+    const file = path.join(dir, 'SKILL.md');
+    try {
+        if (fs.lstatSync(dir).isSymbolicLink() || fs.lstatSync(file).isSymbolicLink())
+            return false;
+        const content = fs.readFileSync(file, 'utf-8');
+        if (!/^---\n[\s\S]*?\n---\n\s*<!-- forgen-managed -->/.test(content))
+            return false;
+        fs.unlinkSync(file);
+        try {
+            if (fs.readdirSync(dir).length === 0)
+                fs.rmdirSync(dir);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+    catch {
+        return false; // 없음
+    }
+}
+/**
+ * ADR-016 D1 — Codex config.toml 의 forgen notify 블록 제거. 남겨 두면 Codex 가 매 턴 사라진 스크립트를
+ * spawn 한다. (Codex hooks.json / MCP 블록 정리는 아직 uninstall 범위 밖 — 알려진 갭.)
+ */
+export async function cleanCodexNotify(codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex')) {
+    const configPath = path.join(codexHome, 'config.toml');
+    try {
+        const current = fs.readFileSync(configPath, 'utf-8');
+        const { removeNotifyBlock } = await import('../host/install-codex.js');
+        const r = removeNotifyBlock(current);
+        if (!r.removed)
+            return false;
+        fs.writeFileSync(configPath, r.content, 'utf-8');
+        return true;
+    }
+    catch {
+        return false; // Codex 미사용
+    }
+}
 /** 사용자에게 y/n 확인 */
 function confirm(message) {
     return new Promise((resolve) => {
@@ -301,7 +342,7 @@ export async function handleUninstall(cwd, options) {
     console.log('  2. Delete .claude/agents/ch-*.md agent files');
     console.log('  3. Delete .claude/rules/ rule files (project-context, routing, forge-*)');
     console.log('  4. Remove forgen block from CLAUDE.md');
-    console.log('  5. Remove slash commands (~/.claude/commands/forgen/)');
+    console.log('  5. Remove slash commands (~/.claude/commands/forgen/) and the forgen-managed verify skill (~/.claude/skills/verify/)');
     console.log('  6. Remove plugin artifacts (cache, installed_plugins.json, plugin directory)');
     if (options.purge) {
         console.log('  7. --purge: Delete ~/.forgen/ entirely (rules, me/, state/, solutions/, behavior/)');
@@ -330,6 +371,10 @@ export async function handleUninstall(cwd, options) {
     cleanCompoundRules(cwd);
     cleanClaudeMd(cwd);
     cleanSlashCommands();
+    if (cleanVerifySkill())
+        console.log('  ✓ Removed forgen verify skill (~/.claude/skills/verify/)');
+    if (await cleanCodexNotify())
+        console.log('  ✓ Removed forgen notify block from Codex config.toml');
     cleanPluginArtifacts();
     if (options.purge) {
         try {

package/dist/engine/compound-loop.js

@@ -210,6 +210,17 @@ export async function handleCompound(args) {
 `);
         return;
     }
+    // --- manual add (defense-in-depth, 2026-08-20) ---
+    // manual add(--solution/--rule/--convention/--pattern)를 아래 서브커맨드 dispatch 보다
+    // 먼저 처리한다. dispatch 는 args.includes('remove'|'clean-stale'|...) 로 전체 인자를
+    // 스캔하므로, add 의 위치인자(title/content)에 그런 토큰이 섞이면 삭제·정리 분기를
+    // 탈취할 수 있다(argument confusion — auto-compound 러너가 untrusted 모델 출력을 넘기던
+    // 경로에서 실증). type flag 는 add 전용이라 우선 처리해도 legit 동작 불변이며, 이렇게
+    // 하면 title/content 가 dispatch 스캔에 아예 닿지 않는다. (러너측 대시-선두 가드에 더한 2중 방어)
+    if (['--solution', '--rule', '--convention', '--pattern'].some(f => args.includes(f))) {
+        await handleManualAdd(args, cwd, scope);
+        return;
+    }
     // --- export command ---
     // 통짜 tar.gz export(플래그만, positional 없음) vs 이름 지정 패턴 export를
     // positional 인자 유무로 구분한다. `compound export foo` = 패턴 export,
@@ -435,10 +446,18 @@ export async function handleCompound(args) {
         console.log('  Unknown compound arguments. Run `forgen compound --help` for usage.\n');
         return;
     }
+    await handleManualAdd(args, cwd, scope);
+}
+/**
+ * 수동 인사이트 추가 (--solution/--rule/--convention/--pattern).
+ * handleCompound 에서 두 경로로 호출된다:
+ *  (1) hoisted early-dispatch — type flag 가 있으면 서브커맨드 스캔 전에 즉시(arg-confusion 방어).
+ *  (2) fallthrough — type flag 없이 다른 known flag(예: --to)만 있는 legacy 경로(동작 보존).
+ */
+async function handleManualAdd(args, cwd, scope) {
     console.log('\n  Compound Loop — Accumulating insights\n');
     console.log(`  Scope: ${scope.summary}`);
     console.log();
-    // 수동 인사이트 추가
     const type = args.includes('--solution') ? 'solution'
         : args.includes('--rule') ? 'rule'
             : args.includes('--convention') ? 'convention'

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

@@ -57,6 +57,9 @@ export declare function effectiveCooldownMs(parsed: {
     userPatternFound?: boolean;
     promptCount?: number;
 }, currentPromptCount?: number): number;
+export declare function maybeSpawnAutoCompound(sessionId: string, transcriptPath: string | undefined, promptCount: number, 
+/** ADR-016 D1: notify 폴백은 훅 env(FORGEN_CWD) 없이 돌므로 페이로드의 cwd 를 넘긴다. */
+cwdOverride?: string): Promise<boolean>;
 /**
  * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
  * OMC의 persistent-mode.cjs 패턴 참고.

package/dist/hooks/context-guard.js

@@ -221,8 +221,12 @@ export async function main() {
             return;
         }
         const sessionId = input.session_id ?? 'default';
-        // Stop 훅: stop_hook_type이 있으면 처리
-        if (input.stop_hook_type) {
+        // Stop 훅 판별. Claude 는 `stop_hook_type`(user|end_turn|…) 을 주지만 Codex 의 Stop 입력에는 그 필드가
+        // 없고 `hook_event_name:"Stop"` 만 온다 (0.5.5 — 이전엔 Codex 세션에서 Stop 분기 전체가 건너뛰어져
+        // finalizeSession / Stop 트리거 auto-compound / rate-limit 감지가 돌지 않았다). Codex 의 정상 턴 종료는
+        // end_turn 과 동치로 취급한다.
+        const stopType = input.stop_hook_type ?? (input.hook_event_name === 'Stop' ? 'end_turn' : undefined);
+        if (stopType) {
             _hookEvent = 'Stop';
             // 세션 종료 시 pending outcome을 unknown으로 finalize.
             // 과거에는 프로덕션에서 호출되지 않아 pending이 다음 세션의 flushAccept에
@@ -289,7 +293,7 @@ export async function main() {
                 }
             }
             // 정상 종료 시: 의미 있는 세션이었으면 compound 안내/자동 트리거
-            if (input.stop_hook_type === 'user' || input.stop_hook_type === 'end_turn') {
+            if (stopType === 'user' || stopType === 'end_turn') {
                 const state = loadContextState(sessionId);
                 // ADR-002 T1 — 세션 중간에 교정이 들어와도 session-scoped rule 이 me-scope 으로
                 // 승급되도록 Stop 에서 직접 auto-compound-runner 를 debounced 로 트리거.
@@ -435,9 +439,11 @@ export function effectiveCooldownMs(parsed, currentPromptCount = 0) {
     const grew = currentPromptCount - (parsed.promptCount ?? 0) >= AUTO_COMPOUND_GROWTH_THRESHOLD;
     return grew ? AUTO_COMPOUND_COOLDOWN_MS : AUTO_COMPOUND_BARREN_COOLDOWN_MS;
 }
-async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
+export async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount, 
+/** ADR-016 D1: notify 폴백은 훅 env(FORGEN_CWD) 없이 돌므로 페이로드의 cwd 를 넘긴다. */
+cwdOverride) {
     if (!transcriptPath || promptCount < 10)
-        return;
+        return false;
     const markerPath = path.join(STATE_DIR, 'last-auto-compound.json');
     try {
         const raw = fs.readFileSync(markerPath, 'utf-8');
@@ -446,12 +452,12 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
             const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
             const cooldown = effectiveCooldownMs(parsed, promptCount);
             if (Number.isFinite(last) && Date.now() - last < cooldown)
-                return;
+                return false;
         }
     }
     catch { /* first time or corrupt — proceed */ }
     const { spawn: spawnProcess } = await import('node:child_process');
-    const cwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
+    const cwd = cwdOverride ?? process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
     // 기본: 번들된 auto-compound-runner. 프로덕션 빌드는 이 경로만 실행.
     const defaultRunner = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'core', 'auto-compound-runner.js');
     // 테스트 주입 경로 — FORGEN_TEST=1 게이트 + 경로 containment (~/.forgen 또는 /tmp 하위만 허용).
@@ -482,7 +488,7 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
     const { claimAutoCompoundInflight, releaseAutoCompoundInflight } = await import('../core/spawn.js');
     if (!claimAutoCompoundInflight(sessionId)) {
         log.debug('Stop-triggered auto-compound skip: 세션 in-flight');
-        return;
+        return false;
     }
     try {
         const child = spawnProcess('node', [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
@@ -491,10 +497,12 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
         });
         child.unref();
         log.debug(`Stop-triggered auto-compound 시작: ${sessionId} (${promptCount} prompts)`);
+        return true;
     }
     catch (e) {
         releaseAutoCompoundInflight(sessionId); // spawn 실패 → 재시도 가능
         log.debug('Stop-triggered auto-compound spawn 실패', e);
+        return false;
     }
 }
 // forge-loop 차단 안전 상한 (무한 루프 방지)

package/dist/hooks/hook-config.js

@@ -146,6 +146,11 @@ export function loadHookConfig(hookName) {
  *   4. 기본값 true (하위호환)
  */
 export function isHookEnabled(hookName) {
+    // -1) ADR-015 C-G1: forgen 자신이 띄운 중첩 `claude -p` 추출 실행 안에서는 모든 훅을 끈다.
+    //     (--bare 는 OAuth 를 끊어 쓸 수 없음.) 이전엔 추출 run 마다 22개 훅이 재귀 발화해
+    //     hook-timing / sessions / usage-telemetry 를 오염시키고 auto-compound 연쇄를 유발했다.
+    if (process.env.FORGEN_NESTED_RUN === '1')
+        return false;
     // 0) compound-core 가드레일 — config 어떤 경로로도 끌 수 없음
     if (PROTECTED_HOOKS.has(hookName))
         return true;

package/dist/hooks/hook-registry.d.ts

@@ -11,7 +11,7 @@
  *   - workflow: 워크플로우 스킬 훅 (다른 플러그인 감지 시 자동 비활성)
  */
 export type HookTier = 'compound-core' | 'safety' | 'workflow';
-export type HookEventType = 'UserPromptSubmit' | 'SessionStart' | 'Stop' | 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'SubagentStart' | 'SubagentStop' | 'PreCompact' | 'PermissionRequest';
+export type HookEventType = 'UserPromptSubmit' | 'SessionStart' | 'Stop' | 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'SubagentStart' | 'SubagentStop' | 'PreCompact' | 'PermissionRequest' | 'SessionEnd';
 export interface HookEntry {
     /** 고유 이름 (hook-config.json에서 사용) */
     name: string;
@@ -27,6 +27,22 @@ export interface HookEntry {
     timeout: number;
     /** compound 피드백 루프에 필수인 훅인지 */
     compoundCritical: boolean;
+    /**
+     * ADR-015: 이 훅을 등록할 host 목록. 생략 시 모든 host. Codex 의 hooks.json 은 바이트 동일성이
+     * 훅 신뢰(trust) 와 묶여 있으므로, Claude 에만 추가하는 이벤트는 `["claude"]` 로 한정한다.
+     */
+    hosts?: Array<'claude' | 'codex' | 'opencode'>;
+    /**
+     * ADR-016 D2: Codex hooks.json 핸들러에만 붙는 필드. Codex 의 trust 해시는 핸들러 단위라
+     * 여기 값을 바꾸면 *그 핸들러만* `/hooks` 재승인이 필요하다 (다른 핸들러는 영향 없음).
+     */
+    codex?: {
+        /**
+         * `additionalContext` 를 임시 파일로 스필하는 임계(근사 토큰, 기본 2500 ≈ 10KB). 0 = 스필 안 함.
+         * Codex 는 PreToolUse/PostToolUse/SessionStart/UserPromptSubmit/SubagentStart 에서만 인정한다.
+         */
+        additionalContextLimit?: number;
+    };
 }
 export declare const HOOK_REGISTRY: HookEntry[];
 /** 티어별 훅 목록 조회 */

package/dist/hooks/hooks-generator.d.ts

@@ -14,6 +14,8 @@ interface HookCommand {
     type: 'command';
     command: string;
     timeout: number;
+    /** Codex 전용 (ADR-016 D2). Claude 산출물에는 넣지 않는다. */
+    additionalContextLimit?: number;
 }
 interface HookMatcher {
     matcher: string;

package/dist/hooks/hooks-generator.js

@@ -57,6 +57,9 @@ export function generateHooksJson(options) {
     const hasOtherPlugins = !releaseMode && detectInstalledPlugins(cwd).length > 0;
     // 활성 훅 필터링
     const activeHooks = HOOK_REGISTRY.filter(hook => {
+        // 0) ADR-015: host 한정 훅 (예: SessionEnd 는 Claude 전용 — Codex hooks.json 바이트 동일성 유지)
+        if (hook.hosts && !hook.hosts.includes(runtime))
+            return false;
         // 1) hook-config.json에서 명시적 비활성화 (releaseMode 시 무시)
         if (!releaseMode && !isHookEnabled(hook.name))
             return false;
@@ -89,7 +92,11 @@ export function generateHooksJson(options) {
             matcher,
             hooks: matcherEntries.map(h => {
                 const command = buildHookCommand(pluginRoot, h.script, runtime);
-                return { type: 'command', command, timeout: h.timeout };
+                const handler = { type: 'command', command, timeout: h.timeout };
+                if (runtime === 'codex' && typeof h.codex?.additionalContextLimit === 'number') {
+                    handler.additionalContextLimit = h.codex.additionalContextLimit;
+                }
+                return handler;
             }),
         }));
     }

package/dist/hooks/session-end.d.ts

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * Forgen — SessionEnd Hook (ADR-015 C-G6 Claude, ADR-016 D2 Codex)
+ *
+ * Claude Code `SessionEnd` (reason: clear|resume|logout|prompt_input_exit|other, 기본 예산 1.5s)
+ * 에서 이전 세션 transcript 를 auto-compound 러너에 넘긴다. 기존 트리거(Stop / PreCompact /
+ * 다음 SessionStart) 는 Stop 이 안 오는 종료(Ctrl+C, /exit 직후 종료) 와 "마지막 컴팩션 이후
+ * 학습" 을 놓쳤다 (memory: forgen-autocompound-gap). runAutoCompound 의 in-flight/cooldown dedup
+ * 이 이중 실행을 막는다.
+ *
+ * - 예산(기본 1.5s, registry timeout 3s 로 상향) 안에 끝나야 하므로: stdin 파싱 → user 메시지 수
+ *   (앞 200KB 만 읽음, 대용량 transcript 보호) → detached spawn.
+ * - Codex 0.153+ 에도 등록한다 (ADR-016 D2). Codex 의 SessionEnd 는 stdin 이
+ *   `session_id`/`transcript_path`/`cwd`/`reason`(항상 "other") 이고 stdout 을 무시하며 타임아웃을 1~3s 로
+ *   clamp 한다 — 같은 "bounded count → detached spawn" 경로가 그대로 맞는다. trust 해시가 핸들러 단위라
+ *   새 이벤트 추가는 기존 훅의 신뢰를 깨지 않는다 (이 훅 1개만 `/hooks` 승인 필요).
+ * - fail-open: 어떤 실패도 종료를 막지 않는다.
+ */
+/** session-recovery 와 동일 임계값 — 짧은 세션은 compound 가치가 없다. */
+export declare const MIN_USER_MESSAGES = 10;
+export interface SessionEndInput {
+    session_id?: string;
+    transcript_path?: string;
+    cwd?: string;
+    reason?: string;
+}
+/** 앞 N바이트만 읽는 상한. critic 2026-10-01: 239MB transcript 전체 스트리밍은 3.2s → 예산 초과로 SIGKILL. */
+export declare const COUNT_SCAN_BYTES: number;
+/**
+ * user 메시지 수를 transcript 앞 COUNT_SCAN_BYTES 만 읽어 센다 (session-recovery 와 동일 방식).
+ * 임계값(MIN_USER_MESSAGES) 판정에만 쓰이므로 하한 추정으로 충분하다. 큰 transcript 에서도 O(200KB).
+ */
+export declare function countUserMessagesBounded(transcriptPath: string, maxBytes?: number): number;
+/**
+ * host 별 user 메시지 수. Codex rollout 은 스키마가 달라 전용 카운터를 쓴다 (ADR-016 D2 — 실제 사용자
+ * 프롬프트만, raw 바이트 스캔). codex-adapter 가 delegate 훅에 FORGEN_RUNTIME=codex 를 주입한다.
+ */
+export declare function countSessionUserMessages(transcriptPath: string, runtime?: string | undefined): Promise<number>;
+/** 순수 판정: 이 입력으로 auto-compound 를 띄울지. (테스트 대상) */
+export declare function shouldRunSessionEndCompound(input: SessionEndInput | null, userMessageCount: number): boolean;
+export declare function main(): Promise<void>;

package/dist/hooks/session-end.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * Forgen — SessionEnd Hook (ADR-015 C-G6 Claude, ADR-016 D2 Codex)
+ *
+ * Claude Code `SessionEnd` (reason: clear|resume|logout|prompt_input_exit|other, 기본 예산 1.5s)
+ * 에서 이전 세션 transcript 를 auto-compound 러너에 넘긴다. 기존 트리거(Stop / PreCompact /
+ * 다음 SessionStart) 는 Stop 이 안 오는 종료(Ctrl+C, /exit 직후 종료) 와 "마지막 컴팩션 이후
+ * 학습" 을 놓쳤다 (memory: forgen-autocompound-gap). runAutoCompound 의 in-flight/cooldown dedup
+ * 이 이중 실행을 막는다.
+ *
+ * - 예산(기본 1.5s, registry timeout 3s 로 상향) 안에 끝나야 하므로: stdin 파싱 → user 메시지 수
+ *   (앞 200KB 만 읽음, 대용량 transcript 보호) → detached spawn.
+ * - Codex 0.153+ 에도 등록한다 (ADR-016 D2). Codex 의 SessionEnd 는 stdin 이
+ *   `session_id`/`transcript_path`/`cwd`/`reason`(항상 "other") 이고 stdout 을 무시하며 타임아웃을 1~3s 로
+ *   clamp 한다 — 같은 "bounded count → detached spawn" 경로가 그대로 맞는다. trust 해시가 핸들러 단위라
+ *   새 이벤트 추가는 기존 훅의 신뢰를 깨지 않는다 (이 훅 1개만 `/hooks` 승인 필요).
+ * - fail-open: 어떤 실패도 종료를 막지 않는다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createLogger } from '../core/logger.js';
+import { readStdinJSON } from './shared/read-stdin.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve } from './shared/hook-response.js';
+import { recordHookTiming } from './shared/hook-timing.js';
+const log = createLogger('session-end');
+/** session-recovery 와 동일 임계값 — 짧은 세션은 compound 가치가 없다. */
+export const MIN_USER_MESSAGES = 10;
+/** 앞 N바이트만 읽는 상한. critic 2026-10-01: 239MB transcript 전체 스트리밍은 3.2s → 예산 초과로 SIGKILL. */
+export const COUNT_SCAN_BYTES = 200 * 1024;
+/**
+ * user 메시지 수를 transcript 앞 COUNT_SCAN_BYTES 만 읽어 센다 (session-recovery 와 동일 방식).
+ * 임계값(MIN_USER_MESSAGES) 판정에만 쓰이므로 하한 추정으로 충분하다. 큰 transcript 에서도 O(200KB).
+ */
+export function countUserMessagesBounded(transcriptPath, maxBytes = COUNT_SCAN_BYTES) {
+    const fd = fs.openSync(transcriptPath, 'r');
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+        const content = buf.toString('utf-8', 0, bytesRead);
+        let n = 0;
+        for (const line of content.split('\n')) {
+            try {
+                const t = JSON.parse(line).type;
+                if (t === 'user' || t === 'queue-operation')
+                    n += 1;
+            }
+            catch { /* partial last line / non-JSON */ }
+        }
+        return n;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * host 별 user 메시지 수. Codex rollout 은 스키마가 달라 전용 카운터를 쓴다 (ADR-016 D2 — 실제 사용자
+ * 프롬프트만, raw 바이트 스캔). codex-adapter 가 delegate 훅에 FORGEN_RUNTIME=codex 를 주입한다.
+ */
+export async function countSessionUserMessages(transcriptPath, runtime = process.env.FORGEN_RUNTIME) {
+    if (runtime === 'codex') {
+        const { countCodexUserPrompts } = await import('../host/codex-rollout.js');
+        return countCodexUserPrompts(transcriptPath);
+    }
+    return countUserMessagesBounded(transcriptPath);
+}
+/** 순수 판정: 이 입력으로 auto-compound 를 띄울지. (테스트 대상) */
+export function shouldRunSessionEndCompound(input, userMessageCount) {
+    if (!input || typeof input.transcript_path !== 'string' || input.transcript_path.length === 0)
+        return false;
+    return userMessageCount >= MIN_USER_MESSAGES;
+}
+export async function main() {
+    const start = Date.now();
+    try {
+        const input = await readStdinJSON();
+        if (!isHookEnabled('session-end') || !input) {
+            console.log(approve());
+            return;
+        }
+        const { runAutoCompound } = await import('../core/spawn.js');
+        const transcript = input.transcript_path ?? '';
+        let count = 0;
+        if (transcript && fs.existsSync(transcript)) {
+            try {
+                count = await countSessionUserMessages(transcript);
+            }
+            catch (e) {
+                log.debug('user message count 실패', e);
+            }
+        }
+        if (shouldRunSessionEndCompound(input, count)) {
+            const cwd = input.cwd ?? process.cwd();
+            const sessionId = input.session_id ?? path.basename(transcript, '.jsonl');
+            const status = runAutoCompound(cwd, transcript, sessionId, count);
+            log.debug(`SessionEnd auto-compound: ${status} (reason=${input.reason ?? '?'}, msgs=${count})`);
+        }
+        console.log(approve());
+    }
+    catch (e) {
+        log.debug('session-end 실패 (fail-open)', e);
+        console.log(approve());
+    }
+    finally {
+        recordHookTiming('session-end', Date.now() - start, 'SessionEnd');
+    }
+}
+if (process.argv[1] && fs.realpathSync(path.resolve(process.argv[1])) === fileURLToPath(import.meta.url)) {
+    main().catch(() => {
+        console.log(approve());
+    });
+}

package/dist/hooks/session-recovery.js

@@ -153,13 +153,28 @@ async function main() {
         // 이전엔 prepareHarness (fgx/forgen wrapper) 만 호출 → 직접 claude/codex 호출 시
         // ~/.forgen/state/sessions/<id>.json 미생성. SessionStart hook 에서도 호출하여
         // 양쪽 진입 경로 모두에서 session state 박제.
+        let v1RenderedRules = null;
         try {
             const { bootstrapV1Session } = await import('../core/v1-bootstrap.js');
-            bootstrapV1Session();
+            v1RenderedRules = bootstrapV1Session().renderedRules;
         }
         catch (e) {
             log.debug('v1-bootstrap SessionStart 호출 실패 (fail-open)', e);
         }
+        // ADR-014 D1 — Codex 에는 .claude/rules/ 로드 표면이 없으므로 같은 룰을 SessionStart
+        // additionalContext 로 주입한다 (Claude 세션은 파일 경로로 이미 로드되므로 skip).
+        const codexRulesBlock = await (async () => {
+            try {
+                const { isCodexRuntime, buildCodexRulesContext } = await import('../host/codex-rules-context.js');
+                if (!isCodexRuntime())
+                    return null;
+                return await buildCodexRulesContext(sessionContext.cwd, v1RenderedRules);
+            }
+            catch (e) {
+                log.debug('codex rules inject 실패 (fail-open)', e);
+                return null;
+            }
+        })();
         if (!fs.existsSync(STATE_DIR)) {
             console.log(approve());
             return;
@@ -435,6 +450,8 @@ async function main() {
         catch (e) {
             log.debug('lifecycle check 실패', e);
         }
+        if (codexRulesBlock)
+            recoveryMessages.unshift(codexRulesBlock);
         if (recoveryMessages.length > 0) {
             console.log(approveWithContext(recoveryMessages.join('\n\n'), 'SessionStart'));
         }

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

@@ -16,9 +16,14 @@ const MAX_LINES = 500;
 // MAX_LINES × 1.5 여유를 둠.
 const ROTATE_SIZE_BYTES = MAX_LINES * 80 * 2; // ~80KB
 export function recordHookTiming(hookName, durationMs, event) {
+    // ADR-015 C-G1 (critic #2): 중첩 추출 run 의 빠른 early-approve 타이밍이 p95 를 왜곡하지 않도록 기록 생략.
+    if (process.env.FORGEN_NESTED_RUN === '1')
+        return;
     try {
         fs.mkdirSync(STATE_DIR, { recursive: true });
-        const entry = JSON.stringify({ hook: hookName, ms: durationMs, event, at: Date.now() });
+        // ADR-014 D5 — host 별 발화 구분 (codex-adapter 가 FORGEN_RUNTIME=codex 주입).
+        const rt = process.env.FORGEN_RUNTIME === 'codex' ? 'codex' : 'claude';
+        const entry = JSON.stringify({ hook: hookName, ms: durationMs, event, at: Date.now(), rt });
         fs.appendFileSync(TIMING_LOG, `${entry}\n`);
         // Rotate if too large — size-gated (statSync only, skip read/write 대부분의 호출)
         try {

package/dist/host/codex-adapter.js

@@ -12,6 +12,7 @@
  */
 import { spawnSync } from 'node:child_process';
 import { projectCodexToClaude } from './projection.js';
+import { markCodexHookAlive } from './codex-hook-alive.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) {
@@ -54,6 +55,10 @@ async function main() {
             return {};
         }
     })();
+    // ADR-016 D1 — "Codex 가 forgen 훅을 실제로 실행 중" 마커 (notify 폴백이 신선도를 본다).
+    // forgen 자신의 추출용 중첩 실행은 사용자 세션이 아니므로 제외.
+    if (process.env.FORGEN_NESTED_RUN !== '1')
+        markCodexHookAlive(input);
     try {
         // 0.4.6 fix — delegate hook 이 자기가 codex runtime context 인지 알 수 있게
         // FORGEN_RUNTIME=codex 명시 주입. 이전엔 buildEnv (forgen wrapper) 경로로만

package/dist/host/codex-hook-alive.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Codex 훅 생존 마커 — ADR-016 D1
+ *
+ * Codex 는 미승인(untrusted)/변경된(modified) 훅을 조용히 skip 한다. "forgen 훅이 실제로 실행되고 있는가"
+ * 를 관측하는 유일한 choke point 는 codex-adapter 다 (Codex 가 forgen 훅을 실행하면 반드시 거친다).
+ * 어댑터가 턴 경계 이벤트에서 전역 마커를 갱신하고, notify 폴백(codex-notify)이 그 신선도를 본다.
+ *
+ * 훅 신뢰 상태는 hooks.json 단위로 모든 세션이 공유하므로 마커는 세션별이 아니라 전역 1개다.
+ * 어댑터가 매 훅마다 import 하므로 의존성은 node 내장 + paths 만 둔다.
+ */
+export declare const CODEX_HOOK_ALIVE_PATH: string;
+/** notify 는 Stop 훅 직후 발화한다. Stop 훅 타임아웃(10s) 대비 넉넉한 창. */
+export declare const CODEX_HOOK_ALIVE_WINDOW_MS = 120000;
+export interface CodexHookAliveMarker {
+    at: number;
+    event: string;
+    sessionId?: string;
+}
+/** 어댑터 입력(stdin JSON)으로 마커 갱신. 대상 이벤트가 아니면 no-op. 실패는 삼킨다 (fail-open). */
+export declare function markCodexHookAlive(input: unknown, now?: number): boolean;
+export declare function readCodexHookAlive(): CodexHookAliveMarker | null;
+/** 최근 window 안에 forgen 훅이 Codex 에서 실행됐는가. */
+export declare function isCodexHookAlive(now?: number, windowMs?: number): boolean;