@wooojin/forgen 0.4.13 → 0.5.5

package/dist/hooks/context-guard.js

@@ -22,6 +22,7 @@ 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';
+import { stripPrivate } from '../engine/private-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');
@@ -135,9 +136,14 @@ function appendPromptHistory(sessionId, prompt) {
         // 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;
+        // W2-5 (private 태그, flow-reviewer SEV-2): prompt-history 는 disk 에 영속되고
+        // extraction-session.ts 가 이를 읽어 세션 컨텍스트 추출에 쓴다. 사용자가 프롬프트에
+        // 넣은 <private> 범위가 박제·추출입력이 되지 않도록 저장 전에 제거한다(보안 축인
+        // redactSecrets 와 별개인 프라이버시 축).
+        const privatelessPrompt = stripPrivate(safePrompt).cleaned;
+        const truncated = privatelessPrompt.length > PROMPT_HISTORY_TRUNCATE
+            ? privatelessPrompt.slice(0, PROMPT_HISTORY_TRUNCATE)
+            : privatelessPrompt;
         const entry = JSON.stringify({
             timestamp: new Date().toISOString(),
             sessionId,
@@ -215,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에
@@ -230,7 +240,7 @@ export async function main() {
                 log.debug('finalizeSession 실패 (fail-open)', e);
             }
             // forge-loop 활성 시 미완료 스토리 감지 → 지속 메시지 주입 (polite-stop 방지)
-            const forgeLoopBlock = checkForgeLoopActive();
+            const forgeLoopBlock = checkForgeLoopActive(sessionId);
             if (forgeLoopBlock) {
                 console.log(forgeLoopBlock);
                 return;
@@ -283,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 로 트리거.
@@ -355,11 +365,11 @@ export async function main() {
     }
 }
 /**
- * 세션 종료 시 "forgen이 도움이 된 정도"를 요약.
- * solution-cache에서 이번 세션에 주입된 compound 솔루션 수를 집계하여
- * 카운터팩추얼 "forgen 없었으면 ~N분 더 걸렸을 것" 메시지 생성.
+ * 세션 종료 시 forgen *활동*을 요약 (관찰 — 인과 효과/절약 미주장).
+ * solution-cache 에서 이번 세션 주입된 compound 수·상위 솔루션·주입 대화 비율을 보여준다.
+ * honest-null (positioning #74): "forgen 없었으면 ~N분 절약" 카운터팩추얼은 은퇴.
  */
-function buildSessionSummary(sessionId, promptCount) {
+export function buildSessionSummary(sessionId, promptCount) {
     try {
         // P1-S3 fix (2026-04-20): sanitizeId로 path traversal 차단.
         // 다른 세션 캐시 경로는 모두 sanitizeId 사용. 여기만 누락되어 있었다.
@@ -370,20 +380,20 @@ function buildSessionSummary(sessionId, promptCount) {
         const injected = Array.isArray(cache.injected) ? cache.injected : [];
         if (injected.length === 0)
             return '';
-        // 카운터팩추얼: 주입된 compound 1건당 평균 8분 절약 가정 (하한 추정)
-        const savedMins = injected.length * 8;
-        const savedStr = savedMins >= 60
-            ? `${Math.floor(savedMins / 60)}시간 ${savedMins % 60}분`
-            : `${savedMins}분`;
-        // 상위 3개 솔루션
+        // honest-null (2026-07-21, positioning #74 정합): "절약 시간(forgen 없었으면)"
+        // 카운터팩추얼은 은퇴 — 측정된 δ 없이 시간절약을 추정하는 건 날조다. *관찰 가능한*
+        // 활동만 보여준다 (무엇이 주입됐나), 인과 효과 크기는 주장하지 않는다.
         const topNames = injected.slice(0, 3).map(i => `"${i.name}"`).join(', ');
         const moreCount = injected.length - 3;
         const topStr = moreCount > 0 ? `${topNames} 외 ${moreCount}개` : topNames;
+        // 리뷰 SEV-3: 이전 "주입이 있던 대화 비율 = injected/promptCount × 100" 은 단위
+        // 불일치(솔루션수/프롬프트수)라 한 프롬프트 다중 주입 시 >100% 라는 불가능한 %가
+        // 났다. injected 캐시엔 프롬프트별 그룹핑이 없으므로 커버리지%를 낼 수 없다 →
+        // 오해 없는 *원시 밀도*(N건 / M프롬프트)로 관찰만 보여준다.
         return [
-            `\n📊 이번 세션 forgen 효과:`,
+            `\n📊 이번 세션 forgen 활동:`,
             `  주입된 compound: ${injected.length}건 (${topStr})`,
-            `  추정 절약 시간: ${savedStr} (forgen 없었으면 시행착오 필요)`,
-            `  프롬프트 대비 효율: ${(injected.length / promptCount * 100).toFixed(0)}% 의 대화가 축적된 지식의 도움을 받음\n`,
+            `  세션 규모: ${promptCount} 프롬프트 ${'\x1b[2m'}(주입 밀도 = 주입 ${injected.length}건 / ${promptCount} 프롬프트, 관찰 — 도움 여부는 미측정)${'\x1b[0m'}`,
         ].join('\n');
     }
     catch {
@@ -416,10 +426,18 @@ const AUTO_COMPOUND_BARREN_COOLDOWN_MS = 30 * 60 * 1000; // 30 min if last run e
  * 일반 case (추출 있음) 은 5분 cooldown 유지 — adaptive 가 sparsity 시그널을
  * 강화할 뿐 정상 동작 차단 안 함.
  */
-function effectiveCooldownMs(parsed) {
+// ADR-011 B수정: barren backoff 는 "지난번 0건 추출" 세션의 재추출을 30분 미룬다.
+// 하지만 세션이 그동안 자라났으면(새 프롬프트 ≥ 이 값) 새 학습거리가 생긴 것이므로
+// barren 을 무시하고 정상 쿨다운(5분)으로 재추출한다 — 긴 활성 세션이 굶지 않도록.
+const AUTO_COMPOUND_GROWTH_THRESHOLD = 5;
+export function effectiveCooldownMs(parsed, currentPromptCount = 0) {
     const total = (parsed.extractedSolutions ?? 0) + (parsed.promotedRules ?? 0)
         + (parsed.userPatternFound ? 1 : 0);
-    return total === 0 ? AUTO_COMPOUND_BARREN_COOLDOWN_MS : AUTO_COMPOUND_COOLDOWN_MS;
+    if (total !== 0)
+        return AUTO_COMPOUND_COOLDOWN_MS;
+    // barren: 세션 성장 시 backoff 무시(재추출), 아니면 barren 유지.
+    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) {
     if (!transcriptPath || promptCount < 10)
@@ -430,7 +448,7 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
         const parsed = JSON.parse(raw);
         if (parsed.sessionId === sessionId) {
             const last = parsed.completedAt ? Date.parse(parsed.completedAt) : 0;
-            const cooldown = effectiveCooldownMs(parsed);
+            const cooldown = effectiveCooldownMs(parsed, promptCount);
             if (Number.isFinite(last) && Date.now() - last < cooldown)
                 return;
         }
@@ -463,43 +481,80 @@ async function maybeSpawnAutoCompound(sessionId, transcriptPath, promptCount) {
     else if (override) {
         log.debug('FORGEN_AUTO_COMPOUND_RUNNER_PATH 무시 — FORGEN_TEST=1 가 필요');
     }
-    const child = spawnProcess('node', [runnerPath, cwd, transcriptPath, sessionId], {
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    log.debug(`Stop-triggered auto-compound 시작: ${sessionId} (${promptCount} prompts)`);
+    // 리뷰 SEV-2 #3: runAutoCompound 와 공유하는 in-flight start-gate 로 이중 spawn 방지.
+    // (이 경로는 test-override 러너를 쓰므로 runAutoCompound 를 직접 호출하지 않고 게이트만 공유.)
+    const { claimAutoCompoundInflight, releaseAutoCompoundInflight } = await import('../core/spawn.js');
+    if (!claimAutoCompoundInflight(sessionId)) {
+        log.debug('Stop-triggered auto-compound skip: 세션 in-flight');
+        return;
+    }
+    try {
+        const child = spawnProcess('node', [runnerPath, cwd, transcriptPath, sessionId, String(promptCount)], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+        log.debug(`Stop-triggered auto-compound 시작: ${sessionId} (${promptCount} prompts)`);
+    }
+    catch (e) {
+        releaseAutoCompoundInflight(sessionId); // spawn 실패 → 재시도 가능
+        log.debug('Stop-triggered auto-compound spawn 실패', e);
+    }
 }
 // forge-loop 차단 안전 상한 (무한 루프 방지)
 const FORGE_LOOP_MAX_BLOCKS = 30;
-const FORGE_LOOP_STALE_MS = 2 * 60 * 60 * 1000; // 2시간
+// TTL: 24시간. 과거 2시간은 정상적으로 오래 걸리는 forge-loop 세션까지 중도
+// 해제시켰다. "크래시된 세션의 잔여 active:true 가 무관한 후속 세션을 영구
+// 차단"하는 문제는 이 TTL 이 아니라 아래 sessionId 바인딩으로 별도 해결한다 —
+// TTL 은 진짜로 죽은(재개 안 되는) 세션을 회수하기 위한 상한일 뿐이다.
+const FORGE_LOOP_STALE_MS = 24 * 60 * 60 * 1000;
 /**
  * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
  * OMC의 persistent-mode.cjs 패턴 참고.
+ *
+ * @param sessionId 호출한 Stop hook 의 세션 ID. 미지정 시(레거시 호출) 세션
+ *   바인딩을 건너뛰고 기존처럼 전역으로 평가한다.
  */
-export function checkForgeLoopActive() {
+export function checkForgeLoopActive(sessionId) {
     try {
         if (!fs.existsSync(FORGE_LOOP_STATE_PATH))
             return null;
         const state = JSON.parse(fs.readFileSync(FORGE_LOOP_STATE_PATH, 'utf-8'));
         if (!state.active)
             return null;
-        // Stale 감지: 2시간+ 미활동 → 자동 비활성화
+        // 세션 바인딩: 이미 다른 세션에 귀속된 루프라면 이 세션과 무관 — 손대지 않고 통과.
+        // 크래시된 세션이 남긴 active:true 가 이후 전혀 다른 세션을 영구 차단하는 것을 방지.
+        if (state.sessionId && sessionId && state.sessionId !== sessionId) {
+            return null;
+        }
+        // 최초 차단 후보 세션에 자동 귀속 (스킬은 세션 ID를 알 필요 없음).
+        if (!state.sessionId && sessionId) {
+            state.sessionId = sessionId;
+        }
+        // 사용자 명시 우회 — 이번 턴만 통과시키고 루프 상태(active/blockCount)는 보존.
+        // pre-tool-use/stop-guard 와 동일한 FORGEN_USER_CONFIRMED=1 관용구.
+        if (process.env.FORGEN_USER_CONFIRMED === '1')
+            return null;
+        // Stale 감지: TTL(24h) 초과 → 자동 비활성화 + 1회성 안내 (침묵 해제 금지).
         const startedAt = new Date(state.startedAt).getTime();
         if (Number.isFinite(startedAt) && Date.now() - startedAt > FORGE_LOOP_STALE_MS) {
             state.active = false;
             atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
-            return null;
+            return approveWithWarning(`[Forgen] forge-loop 상태가 ${Math.round(FORGE_LOOP_STALE_MS / 3_600_000)}시간 이상 갱신되지 않아 자동 해제되었습니다. ` +
+                `재개하려면 "/forge-loop resume" 를 입력하세요.`);
         }
-        // 확인 대기 중이면 차단하지 않음 (사용자 개입 허용)
-        if (state.awaitingConfirmation)
+        // 확인 대기 중이면 차단하지 않음 (사용자 개입 허용) — 귀속은 반영 후 통과.
+        if (state.awaitingConfirmation) {
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
             return null;
-        // 안전 상한: 30회 이상 차단 시 무한 루프로 간주하여 해제
+        }
+        // 안전 상한: 30회 이상 연속 차단 시 무한 루프로 간주하여 해제 + 1회성 안내.
         const blockCount = state.blockCount ?? 0;
         if (blockCount >= FORGE_LOOP_MAX_BLOCKS) {
             state.active = false;
             atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
-            return null;
+            return approveWithWarning(`[Forgen] forge-loop 이 연속 ${FORGE_LOOP_MAX_BLOCKS}회 차단되어 안전 상한으로 자동 해제되었습니다. ` +
+                `무한 루프 가능성을 점검한 뒤 필요 시 "/forge-loop resume" 로 재개하세요.`);
         }
         // 미완료 스토리 확인
         const stories = Array.isArray(state.stories) ? state.stories : [];
@@ -515,25 +570,20 @@ export function checkForgeLoopActive() {
         state.lastBlockAt = new Date().toISOString();
         atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
         const nextStory = pending[0];
-        const message = [
+        const firstAC = Array.isArray(nextStory.acceptanceCriteria) ? nextStory.acceptanceCriteria[0] : undefined;
+        const lines = [
             `<forgen-forge-loop iteration="${state.blockCount}/${FORGE_LOOP_MAX_BLOCKS}">`,
             `[FORGE-LOOP] ${pending.length}개 스토리가 미완료입니다.`,
             `현재 스토리: ${nextStory.id} — ${nextStory.title}`,
-            ``,
-            `계속 진행하세요. 보고는 다음 시점에만 합니다:`,
-            `  1. 모든 스토리 완료 (최종 리포트)`,
-            `  2. 3회 실패 (에스컬레이션)`,
-            `  3. Context limit 접근 (handoff)`,
-            ``,
-            `중간 "완료했습니다" 보고는 polite-stop anti-pattern입니다.`,
-            `취소하려면: "/forge-loop cancel" 또는 "cancelforgen" 입력`,
-            `</forgen-forge-loop>`,
-        ].join('\n');
+        ];
+        if (firstAC)
+            lines.push(`AC1: ${firstAC}`);
+        lines.push(``, `계속 진행하세요. 보고는 다음 시점에만 합니다:`, `  1. 모든 스토리 완료 (최종 리포트)`, `  2. 3회 실패 (에스컬레이션)`, `  3. Context limit 접근 (handoff)`, ``, `중간 "완료했습니다" 보고는 polite-stop anti-pattern입니다.`, `취소하려면: "/forge-loop cancel" 또는 "cancelforgen" 입력`, `</forgen-forge-loop>`);
         // block 결정으로 Claude가 계속 작업하도록 강제
         return JSON.stringify({
             continue: true,
             decision: 'block',
-            reason: message,
+            reason: lines.join('\n'),
         });
     }
     catch (e) {

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,11 @@ export interface HookEntry {
     timeout: number;
     /** compound 피드백 루프에 필수인 훅인지 */
     compoundCritical: boolean;
+    /**
+     * ADR-015: 이 훅을 등록할 host 목록. 생략 시 모든 host. Codex 의 hooks.json 은 바이트 동일성이
+     * 훅 신뢰(trust) 와 묶여 있으므로, Claude 에만 추가하는 이벤트는 `["claude"]` 로 한정한다.
+     */
+    hosts?: Array<'claude' | 'codex' | 'opencode'>;
 }
 export declare const HOOK_REGISTRY: HookEntry[];
 /** 티어별 훅 목록 조회 */

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;

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

@@ -21,7 +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';
+// ADR-010 W2-2: usage-telemetry 기록 제거 — native /usage 이관. (hot path I/O 절감)
 import { emitSolutionEvent, querySurfacedWithin } from '../core/observability-store.js';
 import { parseSolutionV3 } from '../engine/solution-format.js';
 import { ME_SOLUTIONS } from '../core/paths.js';
@@ -122,8 +122,7 @@ async function main() {
             console.log(approve());
             return;
         }
-        // ADR-008 / 0.4.6 — usage telemetry. fail-open, hook 차단 안 함.
-        recordToolCall(process.env.FORGEN_RUNTIME ?? 'claude');
+        // (ADR-010 W2-2: usage-telemetry 기록 제거됨 — native /usage 이관)
         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-compact.js

@@ -179,6 +179,20 @@ async function main() {
         return;
     }
     const sessionId = data.session_id ?? 'default';
+    // ADR-011 B수정: 프롬프트 주입(모델이 추출)에 더해, **러너도 spawn** 해서 컴팩션으로
+    // 컨텍스트가 사라지기 직전에 확실히 추출한다. runAutoCompound 의 in-flight/cooldown
+    // dedup 이 Stop 훅과의 이중실행을 막는다(최근에 이미 돌았으면 skip).
+    const transcriptPath = data.transcript_path;
+    if (transcriptPath) {
+        try {
+            const { runAutoCompound } = await import('../core/spawn.js');
+            const cwd = data.cwd ?? process.cwd();
+            runAutoCompound(cwd, transcriptPath, sessionId);
+        }
+        catch (e) {
+            log.debug('PreCompact auto-compound spawn 실패 (프롬프트 주입은 계속)', e);
+        }
+    }
     // 오래된 handoff 정리
     cleanOldHandoffs();
     // 기존 behavioral 패턴 목록 로드 (중복 방지)

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

@@ -18,6 +18,7 @@ import { withFileLockSync, FileLockError } from './shared/file-lock.js';
 import { sanitizeId } from './shared/sanitize-id.js';
 import { incrementEvidence } from '../engine/solution-writer.js';
 import { isReflectionCandidate } from './compound-reflection.js';
+import { stripPrivate } from '../engine/private-filter.js';
 import { isHookEnabled } from './hook-config.js';
 import { approve, approveWithWarning, denyOrObserve, failOpenWithTracking } from './shared/hook-response.js';
 import { FORGEN_HOME, STATE_DIR } from '../core/paths.js';
@@ -229,7 +230,10 @@ function resetFailCount() {
 function checkCompoundReflection(toolName, toolInput, sessionId) {
     if (toolName !== 'Edit' && toolName !== 'Write')
         return;
-    const code = String(toolInput.new_string ?? toolInput.content ?? '');
+    // W2-5 (private 태그): 사용자가 <private> 로 표시한 코드 범위는 reflection 관측
+    // 대상에서 제외한다. isReflectionCandidate 내부에서도 strip 하지만, 아래 태그
+    // fallback 매칭은 이 code 를 직접 쓰므로 여기서 한 번 스트립해 두 경로를 일치시킨다.
+    const code = stripPrivate(String(toolInput.new_string ?? toolInput.content ?? '')).cleaned;
     if (!code || code.length < 10)
         return;
     const cachePath = path.join(STATE_DIR, `injection-cache-${sanitizeId(sessionId)}.json`);

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Forgen — SessionEnd Hook (ADR-015 C-G6, Claude Code 전용)
+ *
+ * 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 에는 등록하지 않는다 (hooks.json 바이트 동일성 = 훅 신뢰 유지). Codex 의 SessionEnd 는
+ *   hooks.json 변경이 필요한 다음 메이저에서 함께 추가.
+ * - 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;
+/** 순수 판정: 이 입력으로 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,100 @@
+#!/usr/bin/env node
+/**
+ * Forgen — SessionEnd Hook (ADR-015 C-G6, Claude Code 전용)
+ *
+ * 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 에는 등록하지 않는다 (hooks.json 바이트 동일성 = 훅 신뢰 유지). Codex 의 SessionEnd 는
+ *   hooks.json 변경이 필요한 다음 메이저에서 함께 추가.
+ * - 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);
+    }
+}
+/** 순수 판정: 이 입력으로 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 = countUserMessagesBounded(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/hooks/shared/stop-triggers.d.ts

@@ -5,11 +5,21 @@
  * 단일 소스로 통합. 한쪽만 고치면 다른 쪽이 drift 하는 sibling-bug 패턴 차단.
  *
  * 설계 결정:
- *   - trigger 는 명시적 완료 선언 동사/어미만 — "완료" 단독 매칭 금지 (retraction 오매칭 방지).
+ *   - DEFAULT trigger 는 명시적 완료 선언 동사/어미만 — "완료" 단독 매칭 금지 (retraction 오매칭 방지).
  *   - exclude 는 retraction/negation/meta 언급 광범위 차단.
  *   - A1 spike 결과로 검증됨 (10/10 scenarios pass, FP 0%).
+ *
+ * 2026-07-22 (강제층 실측 갭 — critic-review 룰 한정 수정, 리뷰 SEV-2 반영):
+ *   완료 키워드 없이 "리뷰 생략하고 다음으로 넘어감" 하는 응답이 완료-키워드 트리거를
+ *   우회해 critic-룰(청크마다 리뷰) 강제가 새던 갭. 이를 닫되:
+ *   - skip-signal 은 DEFAULT 에 섞지 않고 **critic-review 룰 전용** CRITIC_STOP_TRIGGER 로 분리
+ *     (e2e·mock-as-proof 등 다른 완료룰 오염 방지, 리뷰 SEV-2 #3).
+ *   - "리뷰 생략" AND "다음으로 넘어감" **결합(conjunction)** 으로만 발화 → 경고/질문/신중
+ *     응답 FP 제거 (리뷰 SEV-2 #1).
+ *   - exclude 에 부정/금지/질문형(말고·안 했·should not·될까요…) 보강 (리뷰 SEV-2 #2).
+ *   - 기존 baked 룰(b0aabac3)은 `forgen rule migrate-triggers` 로 재-bake 해야 적용 (리뷰 SEV-2 #4).
  */
-/** Stop hook 에서 rule trigger 가 명시되지 않을 때의 기본 완료 선언 매칭. */
+/** Stop hook 기본 완료 선언 매칭 (완료 동사/어미만 — skip-signal 미포함). */
 export declare const DEFAULT_STOP_TRIGGER_RE = "(\uC644\uB8CC\uD588|\uC644\uC131\uB410|\uC644\uC131\uB418|\uC644\uC131\uD588|done\\.|ready\\.|shipped\\.|LGTM|finished\\.)";
 /** Stop hook 기본 exclude — retraction/negation/meta 맥락 제외. */
 export declare const DEFAULT_STOP_EXCLUDE_RE = "(\uCDE8\uC18C|\uCCA0\uD68C|\uC5C6\uC74C|\uC5C6\uC2B5\uB2C8\uB2E4|\uC54A\uC558|\uD558\uC9C0\\s*\uC54A|\uC544\uB2D9\uB2C8\uB2E4|not\\s*yet|no\\s*longer|retract|withdraw|\uC544\uC9C1\\s*(\uC548|\uC544))";
@@ -17,3 +27,20 @@ export declare const DEFAULT_STOP_EXCLUDE_RE = "(\uCDE8\uC18C|\uCCA0\uD68C|\uC5C
 export declare const MOCK_TRIGGER_RE = "(mock|stub|fake)";
 /** mock trigger 의 exclude — 테스트 맥락은 정상. */
 export declare const MOCK_EXCLUDE_RE = "(\uD14C\uC2A4\uD2B8|test|vi\\.mock|jest\\.mock|spec\\.)";
+/**
+ * "리뷰 생략" AND "다음으로 넘어감" 이 함께 있을 때만 발화하는 결합 트리거.
+ * 두 lookahead 로 conjunction — 한쪽만 있는 경고/질문/신중 응답은 미발화(FP 0).
+ */
+export declare const SKIP_REVIEW_TRIGGER_RE = "(?=[\\s\\S]*?(?:(\uB9AC\uBDF0|\uAC80\uD1A0)[^.!?\\n]{0,8}(\uC0DD\uB7B5|\uAC74\uB108\uB6F0|\uC5C6\uC774|\uC2A4\uD0B5|\uD328\uC2A4|\uC548\\s*\uD558\uACE0)|skip(?:ping|s)?\\s+(?:the\\s+)?review))(?=[\\s\\S]*?(?:\uB118\uC5B4\uAC00|\uB118\uC5B4\uAC11|\uB118\uC5B4\uAC14|\uB118\uC5B4\uAC10|\uB118\uC5B4\uAC08|\uB2E4\uC74C\\s*(\uC791\uC5C5|\uAE30\uB2A5|\uB2E8\uACC4|\uC2A4\uD15D|\uAC83|\uC774\uD130\uB808\uC774\uC158)|move\\s+on|next\\s+(step|task|feature)|proceed))";
+/**
+ * critic-review 룰 트리거 = 완료 선언 OR 리뷰생략-넘어감.
+ * (완료 시점 + skip 시점 양쪽에서 critic 강제. e2e/mock 룰엔 부여 안 함 — DEFAULT 만 사용.)
+ */
+export declare const CRITIC_STOP_TRIGGER_RE = "((\uC644\uB8CC\uD588|\uC644\uC131\uB410|\uC644\uC131\uB418|\uC644\uC131\uD588|done\\.|ready\\.|shipped\\.|LGTM|finished\\.)|(?=[\\s\\S]*?(?:(\uB9AC\uBDF0|\uAC80\uD1A0)[^.!?\\n]{0,8}(\uC0DD\uB7B5|\uAC74\uB108\uB6F0|\uC5C6\uC774|\uC2A4\uD0B5|\uD328\uC2A4|\uC548\\s*\uD558\uACE0)|skip(?:ping|s)?\\s+(?:the\\s+)?review))(?=[\\s\\S]*?(?:\uB118\uC5B4\uAC00|\uB118\uC5B4\uAC11|\uB118\uC5B4\uAC14|\uB118\uC5B4\uAC10|\uB118\uC5B4\uAC08|\uB2E4\uC74C\\s*(\uC791\uC5C5|\uAE30\uB2A5|\uB2E8\uACC4|\uC2A4\uD15D|\uAC83|\uC774\uD130\uB808\uC774\uC158)|move\\s+on|next\\s+(step|task|feature)|proceed)))";
+/**
+ * critic 트리거 exclude — 기본 retraction + 부정/금지/질문형 + 숙고형 보강.
+ * 주의: bare `안\s*하` 는 넣지 않는다 — "리뷰 안 하고 넘어감"(실제 skip TP)을 죽이므로.
+ * retraction 은 과거형 `안\s*했`(안 했다)만 배제. 숙고형(할지|여부|고민…)은 skip 단언이
+ * 아니라 결정 전 단계라 배제 (리뷰 SEV-3 (a)).
+ */
+export declare const CRITIC_STOP_EXCLUDE_RE: string;