@wooojin/forgen 0.2.1 → 0.3.0

package/dist/core/harness.js

@@ -20,6 +20,7 @@ import { buildEnv, generateClaudeRuleFiles, registerTmuxBindings } from './confi
 import { createLogger } from './logger.js';
 import { HANDOFFS_DIR, ME_BEHAVIOR, ME_DIR, ME_RULES, ME_SKILLS, ME_SOLUTIONS, SESSIONS_DIR, STATE_DIR, FORGEN_HOME } from './paths.js';
 import { RULE_FILE_CAPS } from '../hooks/shared/injection-caps.js';
+import { generateHooksJson } from '../hooks/hooks-generator.js';
 import { acquireLock, atomicWriteFileSync, CLAUDE_DIR, releaseLock, rollbackSettings, SETTINGS_BACKUP_PATH, SETTINGS_PATH, } from './settings-lock.js';
 import { ConfigError } from './errors.js';
 import { bootstrapV1Session, ensureV1Directories } from './v1-bootstrap.js';
@@ -104,7 +105,7 @@ function isForgenHookEntry(entry, pkgRoot) {
     return Array.isArray(hooks) && hooks.some(h => typeof h.command === 'string' && matchesPath(h.command));
 }
 /** Strip existing forgen hooks from settings, merge fresh hooks.json. */
-function mergeHooksIntoSettings(settings) {
+function mergeHooksIntoSettings(settings, runtime, cwd) {
     const pkgRoot = getPackageRoot();
     const hooksConfig = settings.hooks ?? {};
     // Remove existing forgen hooks (clean slate before re-inject)
@@ -117,18 +118,28 @@ function mergeHooksIntoSettings(settings) {
         else
             hooksConfig[event] = filtered;
     }
-    // Read hooks.json and inject, replacing ${CLAUDE_PLUGIN_ROOT}
-    const hooksJsonPath = path.join(pkgRoot, 'hooks', 'hooks.json');
     try {
-        if (fs.existsSync(hooksJsonPath)) {
-            const hooksJson = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf-8'));
-            const hooksData = hooksJson.hooks;
-            if (hooksData) {
-                const resolved = JSON.parse(JSON.stringify(hooksData).replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pkgRoot));
-                for (const [event, handlers] of Object.entries(resolved)) {
-                    if (!hooksConfig[event])
-                        hooksConfig[event] = [];
-                    hooksConfig[event].push(...handlers);
+        if (runtime === 'codex') {
+            const generated = generateHooksJson({ cwd, runtime, pluginRoot: path.join(pkgRoot, 'dist') });
+            for (const [event, handlers] of Object.entries(generated.hooks)) {
+                if (!hooksConfig[event])
+                    hooksConfig[event] = [];
+                hooksConfig[event].push(...handlers);
+            }
+        }
+        else {
+            // Read hooks.json and inject, replacing ${CLAUDE_PLUGIN_ROOT}
+            const hooksJsonPath = path.join(pkgRoot, 'hooks', 'hooks.json');
+            if (fs.existsSync(hooksJsonPath)) {
+                const hooksJson = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf-8'));
+                const hooksData = hooksJson.hooks;
+                if (hooksData) {
+                    const resolved = JSON.parse(JSON.stringify(hooksData).replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pkgRoot));
+                    for (const [event, handlers] of Object.entries(resolved)) {
+                        if (!hooksConfig[event])
+                            hooksConfig[event] = [];
+                        hooksConfig[event].push(...handlers);
+                    }
                 }
             }
         }
@@ -177,14 +188,14 @@ function applyTrustPolicyPermissions(settings, v1Result) {
  * atomic write). Each phase is now a named function with a single
  * responsibility, testable in isolation if needed.
  */
-function injectSettings(env, v1Result) {
+function injectSettings(env, v1Result, runtime, cwd) {
     fs.mkdirSync(CLAUDE_DIR, { recursive: true });
     acquireLock();
     const settings = readSettingsWithBackup();
     // Merge env vars
     settings.env = { ...(settings.env ?? {}), ...env };
     applyStatusLine(settings);
-    mergeHooksIntoSettings(settings);
+    mergeHooksIntoSettings(settings, runtime, cwd);
     applyTrustPolicyPermissions(settings, v1Result);
     try {
         atomicWriteFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
@@ -252,14 +263,58 @@ function installAgentsFromDir(sourceDir, targetDir, prefix, hashes) {
         hashes[dstName] = newHash;
     }
 }
+/**
+ * 현재 source에 없는 stale ch-*.md 에이전트 파일을 정리.
+ * forgen-managed 마커가 있는 파일만 삭제 (사용자 수정 파일 보호).
+ */
+function cleanupStaleAgents(sourceDir, targetDir, prefix, hashes) {
+    if (!fs.existsSync(targetDir))
+        return;
+    if (!fs.existsSync(sourceDir))
+        return;
+    // 현재 source의 유효한 파일 목록
+    const validFiles = new Set(fs.readdirSync(sourceDir)
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => `${prefix}${f}`));
+    // targetDir에서 prefix로 시작하지만 유효 목록에 없는 파일 삭제
+    for (const existing of fs.readdirSync(targetDir)) {
+        if (!existing.startsWith(prefix) || !existing.endsWith('.md'))
+            continue;
+        if (validFiles.has(existing))
+            continue;
+        const filePath = path.join(targetDir, existing);
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            // 사용자 수정 보호: forgen-managed 마커가 있고 hash가 기록된 경우만 삭제
+            const recordedHash = hashes[existing];
+            const hasMarker = content.includes('<!-- forgen-managed -->');
+            if (!hasMarker) {
+                log.debug(`에이전트 삭제 스킵: ${existing} (forgen-managed 마커 없음)`);
+                continue;
+            }
+            if (recordedHash && contentHash(content) !== recordedHash) {
+                log.debug(`에이전트 삭제 스킵: ${existing} (사용자 수정 감지)`);
+                continue;
+            }
+            fs.unlinkSync(filePath);
+            delete hashes[existing];
+            log.debug(`stale 에이전트 삭제: ${existing}`);
+        }
+        catch (e) {
+            log.debug(`에이전트 삭제 실패: ${existing}`, e);
+        }
+    }
+}
 /** 에이전트 정의 파일 설치 (패키지 내장만) */
 function installAgents(cwd) {
     const pkgRoot = getPackageRoot();
     const targetDir = path.join(cwd, '.claude', 'agents');
     fs.mkdirSync(targetDir, { recursive: true });
     const hashes = loadAgentHashes();
+    const sourceDir = path.join(pkgRoot, 'agents');
     try {
-        installAgentsFromDir(path.join(pkgRoot, 'agents'), targetDir, 'ch-', hashes);
+        installAgentsFromDir(sourceDir, targetDir, 'ch-', hashes);
+        cleanupStaleAgents(sourceDir, targetDir, 'ch-', hashes);
         saveAgentHashes(hashes);
     }
     catch (e) {
@@ -560,7 +615,8 @@ function checkCompoundStaleness() {
         log.debug('Staleness check failed (non-fatal)', e);
     }
 }
-export async function prepareHarness(cwd) {
+export async function prepareHarness(cwd, options = {}) {
+    const runtime = options.runtime ?? 'claude';
     try {
         // 0. 스토리지 마이그레이션 (v5.1: ~/.compound/ → ~/.forgen/)
         migrateToForgen();
@@ -591,8 +647,8 @@ export async function prepareHarness(cwd) {
         // 3. 환경 확인
         const inTmux = !!process.env.TMUX;
         // 4. Claude Code 설정 주입 (환경변수 + trust 기반 permissions)
-        const env = buildEnv(cwd, v1Result.session?.session_id);
-        injectSettings(env, v1Result);
+        const env = buildEnv(cwd, v1Result.session?.session_id, runtime);
+        injectSettings(env, v1Result, runtime, cwd);
         // 5. 에이전트 설치
         installAgents(cwd);
         // 6. 규칙 파일 생성 및 주입 (v1 부트스트랩 결과의 renderedRules를 직접 전달)
@@ -612,7 +668,7 @@ export async function prepareHarness(cwd) {
         await startLegacySessionLog(cwd, inTmux, v1Result);
         // 12. Compound staleness guard
         checkCompoundStaleness();
-        return { cwd, inTmux, v1: v1Result };
+        return { cwd, inTmux, v1: v1Result, runtime };
     }
     catch (err) {
         rollbackSettings();

package/dist/core/paths.d.ts

@@ -1,5 +1,6 @@
 /** ~/.claude/ — Claude Code 설정 디렉토리 */
 export declare const CLAUDE_DIR: string;
+export declare const CODEX_DIR: string;
 /** ~/.claude/settings.json — Claude Code 설정 파일 */
 export declare const SETTINGS_PATH: string;
 /**
@@ -47,6 +48,10 @@ export declare const MATCH_EVAL_LOG_PATH: string;
 export declare const SESSIONS_DIR: string;
 /** ~/.forgen/config.json — 글로벌 설정 */
 export declare const GLOBAL_CONFIG: string;
+/** ~/.forgen/state/session-quality/ — 세션 품질 점수 */
+export declare const SESSION_QUALITY_DIR: string;
+/** ~/.forgen/state/meta-learning/ — 메타학습 상태 파일 */
+export declare const META_LEARNING_DIR: string;
 /** ~/.forgen/lab/ — Lab 적응형 최적화 엔진 데이터 */
 export declare const LAB_DIR: string;
 /** ~/.forgen/lab/events.jsonl — Lab 이벤트 로그 (JSONL) */
@@ -74,7 +79,7 @@ export declare const V1_RAW_LOGS_DIR: string;
 /** @deprecated use GLOBAL_CONFIG */
 export declare const V1_GLOBAL_CONFIG: string;
 /** 모든 실행 모드 이름 (cancel/recovery 시 사용) */
-export declare const ALL_MODES: readonly ["ralph", "autopilot", "ultrawork", "team", "pipeline", "ccg", "ralplan", "deep-interview", "ecomode", "specify"];
+export declare const ALL_MODES: readonly ["ralph", "autopilot", "ultrawork", "team", "pipeline", "ccg", "ralplan", "deep-interview", "forge-loop", "ship", "retro", "learn", "calibrate"];
 /** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
 export declare function projectDir(cwd: string): string;
 /** {repo}/.compound/pack.link — 팀 팩 연결 파일 */

package/dist/core/paths.js

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 const HOME = os.homedir();
 /** ~/.claude/ — Claude Code 설정 디렉토리 */
 export const CLAUDE_DIR = path.join(HOME, '.claude');
+export const CODEX_DIR = path.join(HOME, '.codex');
 /** ~/.claude/settings.json — Claude Code 설정 파일 */
 export const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
 /**
@@ -50,6 +51,10 @@ export const MATCH_EVAL_LOG_PATH = path.join(STATE_DIR, 'match-eval-log.jsonl');
 export const SESSIONS_DIR = path.join(FORGEN_HOME, 'sessions');
 /** ~/.forgen/config.json — 글로벌 설정 */
 export const GLOBAL_CONFIG = path.join(FORGEN_HOME, 'config.json');
+/** ~/.forgen/state/session-quality/ — 세션 품질 점수 */
+export const SESSION_QUALITY_DIR = path.join(STATE_DIR, 'session-quality');
+/** ~/.forgen/state/meta-learning/ — 메타학습 상태 파일 */
+export const META_LEARNING_DIR = path.join(STATE_DIR, 'meta-learning');
 /** ~/.forgen/lab/ — Lab 적응형 최적화 엔진 데이터 */
 export const LAB_DIR = path.join(FORGEN_HOME, 'lab');
 /** ~/.forgen/lab/events.jsonl — Lab 이벤트 로그 (JSONL) */
@@ -80,8 +85,19 @@ export const V1_GLOBAL_CONFIG = GLOBAL_CONFIG;
 // ── 레거시 ──
 /** 모든 실행 모드 이름 (cancel/recovery 시 사용) */
 export const ALL_MODES = [
-    'ralph', 'autopilot', 'ultrawork', 'team', 'pipeline',
-    'ccg', 'ralplan', 'deep-interview', 'ecomode', 'specify',
+    'ralph',
+    'autopilot',
+    'ultrawork',
+    'team',
+    'pipeline',
+    'ccg',
+    'ralplan',
+    'deep-interview',
+    'forge-loop',
+    'ship',
+    'retro',
+    'learn',
+    'calibrate',
 ];
 /** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
 export function projectDir(cwd) {

package/dist/core/spawn.d.ts

@@ -1,8 +1,9 @@
 import type { V1HarnessContext } from './harness.js';
+import { type RuntimeHost } from './types.js';
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
-export declare function spawnClaude(args: string[], context: V1HarnessContext): Promise<number>;
+export declare function spawnClaude(args: string[], context: V1HarnessContext, runtime?: RuntimeHost): Promise<number>;
 /**
  * 토큰 한도 도달 시 자동 재시작을 지원하는 claude 실행 래퍼.
  * context-guard가 pending-resume.json 마커를 생성하면 쿨다운 후 재시작.
  */
-export declare function spawnClaudeWithResume(args: string[], context: V1HarnessContext, contextFactory: () => Promise<V1HarnessContext>): Promise<void>;
+export declare function spawnClaudeWithResume(args: string[], context: V1HarnessContext, contextFactory: () => Promise<V1HarnessContext>, runtime?: RuntimeHost): Promise<void>;

package/dist/core/spawn.js

@@ -12,6 +12,9 @@ const log = createLogger('spawn');
 function findClaude() {
     return 'claude';
 }
+function findRuntimeLauncher(runtime) {
+    return runtime === 'codex' ? 'codex' : findClaude();
+}
 /**
  * 가장 최근 transcript 파일을 찾는다.
  * Claude Code는 세션 대화를 ~/.claude/projects/{sanitized-cwd}/{uuid}.jsonl에 저장.
@@ -60,32 +63,43 @@ async function indexTranscriptToFTS(cwd, transcriptPath, sessionId) {
     }
 }
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
-export async function spawnClaude(args, context) {
-    const claudePath = findClaude();
-    const env = buildEnv(context.cwd);
+export async function spawnClaude(args, context, runtime = 'claude') {
+    const launcher = findRuntimeLauncher(runtime);
+    const env = buildEnv(context.cwd, context.v1.session?.session_id, runtime);
     const cleanArgs = [...args];
     // config.json에서 dangerouslySkipPermissions 기본값 적용
     const globalConfig = loadGlobalConfig();
-    if (globalConfig.dangerouslySkipPermissions && !cleanArgs.includes('--dangerously-skip-permissions')) {
+    if (runtime === 'claude' &&
+        globalConfig.dangerouslySkipPermissions &&
+        !cleanArgs.includes('--dangerously-skip-permissions')) {
         cleanArgs.unshift('--dangerously-skip-permissions');
     }
     // 세션 시작 전 timestamp 기록 (종료 후 transcript 찾기 위해)
     const sessionStartTime = Date.now();
     return new Promise((resolve, reject) => {
-        const child = spawn(claudePath, cleanArgs, {
+        const child = spawn(launcher, cleanArgs, {
             stdio: 'inherit',
             env: { ...process.env, ...env },
             cwd: context.cwd,
         });
         child.on('error', (err) => {
             if (err.code === 'ENOENT') {
-                reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
+                if (runtime === 'codex') {
+                    reject(new Error('Codex is not installed.'));
+                }
+                else {
+                    reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
+                }
             }
             else {
                 reject(err);
             }
         });
         child.on('exit', async (code) => {
+            if (runtime !== 'claude') {
+                resolve(code ?? 0);
+                return;
+            }
             // 세션 종료 후 하네스 작업
             try {
                 const transcript = findLatestTranscript(context.cwd);
@@ -135,11 +149,16 @@ const MAX_RESUMES = 3;
  * 토큰 한도 도달 시 자동 재시작을 지원하는 claude 실행 래퍼.
  * context-guard가 pending-resume.json 마커를 생성하면 쿨다운 후 재시작.
  */
-export async function spawnClaudeWithResume(args, context, contextFactory) {
+export async function spawnClaudeWithResume(args, context, contextFactory, runtime = 'claude') {
     let resumeCount = 0;
     let currentContext = context;
     while (true) {
-        const exitCode = await spawnClaude(args, currentContext);
+        const exitCode = await spawnClaude(args, currentContext, runtime);
+        if (runtime !== 'claude') {
+            if (exitCode !== 0)
+                process.exit(exitCode);
+            break;
+        }
         const resumePath = path.join(STATE_DIR, 'pending-resume.json');
         if (!fs.existsSync(resumePath)) {
             if (exitCode !== 0)

package/dist/core/types.d.ts

@@ -106,3 +106,37 @@ export interface HarnessContext {
     /** 모델 라우팅 프리셋 (default, cost-saving, max-quality) */
     routingPreset?: string;
 }
+/** 런타임 Host */
+export type RuntimeHost = 'claude' | 'codex';
+/** 런칭 컨텍스트 — CLI에서 runtime/args 결정을 모델화 */
+export interface LaunchContext {
+    runtime: RuntimeHost;
+    args: string[];
+    runtimeSource: 'flag' | 'env' | 'default';
+}
+/** 훅 입력 이벤트 스키마 (버전 간 상위 호환용 최소 스펙) */
+export interface HookEventInput {
+    hookEventName?: string;
+    event?: string;
+    session_id?: string;
+    sessionId?: string;
+    tool_name?: string;
+    toolName?: string;
+    tool_input?: Record<string, unknown>;
+    toolInput?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** 훅 출력 스키마 (Claude/Codex 정규화용 공통 뷰) */
+export interface HookEventOutput {
+    continue?: boolean;
+    suppressOutput?: boolean;
+    systemMessage?: string;
+    hookSpecificOutput?: {
+        hookEventName?: string;
+        permissionDecision?: string;
+        permissionDecisionReason?: string;
+        additionalContext?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}

package/dist/engine/compound-lifecycle.d.ts

@@ -1,4 +1,5 @@
 import type { SolutionFrontmatter, SolutionStatus } from './solution-format.js';
+import type { AdaptiveLifecycleThresholds } from './meta-learning/types.js';
 export interface LifecycleResult {
     promoted: string[];
     demoted: string[];
@@ -11,8 +12,8 @@ export declare function nextStatus(current: SolutionStatus): SolutionStatus | nu
  * Spacing: 0.25 between levels for meaningful differentiation in matching scores.
  * Previous: 0.3/0.6/0.8/0.85 had only 0.05 gap between verified and mature. */
 export declare function statusConfidence(status: SolutionStatus): number;
-/** Check promotion eligibility */
-export declare function checkPromotion(fm: SolutionFrontmatter): boolean;
+/** Check promotion eligibility (with optional adaptive thresholds) */
+export declare function checkPromotion(fm: SolutionFrontmatter, thresholds?: AdaptiveLifecycleThresholds | null): boolean;
 /** Check if solution should be demoted due to confidence-status mismatch */
 export declare function checkConfidenceDemotion(fm: SolutionFrontmatter): SolutionStatus | null;
 /** Check if solution identifiers still exist in codebase (staleness detection) */
@@ -25,7 +26,7 @@ export declare function isStale(fm: SolutionFrontmatter): boolean;
  */
 export declare function updateSolutionFile(filePath: string, updates: Partial<SolutionFrontmatter>): boolean;
 /** Run lifecycle check on all solutions */
-export declare function runLifecycleCheck(sessionId?: string): LifecycleResult;
+export declare function runLifecycleCheck(_sessionId?: string): LifecycleResult;
 /** Detect contradictions between solutions */
 export declare function detectContradictions(dirs: string[]): string[];
 /** Manual verify command: immediately promote to verified */

package/dist/engine/compound-lifecycle.js

@@ -1,11 +1,12 @@
+import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { execFileSync } from 'node:child_process';
+import { createLogger } from '../core/logger.js';
 import { parseFrontmatterOnly } from './solution-format.js';
 import { mutateSolutionFile } from './solution-writer.js';
-import { createLogger } from '../core/logger.js';
 const log = createLogger('compound-lifecycle');
-import { ME_SOLUTIONS, ME_RULES } from '../core/paths.js';
+import { ME_RULES, ME_SOLUTIONS, META_LEARNING_DIR } from '../core/paths.js';
+import { safeReadJSON } from '../hooks/shared/atomic-write.js';
 /** Circuit breaker negative thresholds by status */
 const CIRCUIT_BREAKER_THRESHOLDS = {
     experiment: 2,
@@ -29,10 +30,14 @@ const STATUS_CONFIDENCE_MIN = {
 /** Get the next promotion status */
 export function nextStatus(current) {
     switch (current) {
-        case 'experiment': return 'candidate';
-        case 'candidate': return 'verified';
-        case 'verified': return 'mature';
-        default: return null;
+        case 'experiment':
+            return 'candidate';
+        case 'candidate':
+            return 'verified';
+        case 'verified':
+            return 'mature';
+        default:
+            return null;
     }
 }
 /** Get confidence for a status level.
@@ -40,30 +45,54 @@ export function nextStatus(current) {
  * Previous: 0.3/0.6/0.8/0.85 had only 0.05 gap between verified and mature. */
 export function statusConfidence(status) {
     switch (status) {
-        case 'experiment': return 0.3;
-        case 'candidate': return 0.55;
-        case 'verified': return 0.75;
-        case 'mature': return 0.90;
-        case 'retired': return 0;
+        case 'experiment':
+            return 0.3;
+        case 'candidate':
+            return 0.55;
+        case 'verified':
+            return 0.75;
+        case 'mature':
+            return 0.9;
+        case 'retired':
+            return 0;
     }
 }
-/** Check promotion eligibility */
-export function checkPromotion(fm) {
+/** Load adaptive thresholds from meta-learning state (returns null if not tuned) */
+function loadAdaptiveThresholds() {
+    const thresholdsPath = path.join(META_LEARNING_DIR, 'lifecycle-thresholds.json');
+    return safeReadJSON(thresholdsPath, null);
+}
+/** Check promotion eligibility (with optional adaptive thresholds) */
+export function checkPromotion(fm, thresholds) {
     const ev = fm.evidence;
+    const t = thresholds ?? null;
     switch (fm.status) {
-        case 'experiment':
-            // A: reflected >= 3 AND negative == 0 AND sessions >= 3 (Beta(4,1) → P(rate>0.5)=0.94)
-            // B: reExtracted >= 2 AND negative == 0 AND reflected >= 1 (prevents trivial re-extraction)
-            return (ev.negative === 0) && ((ev.reflected >= 3 && ev.sessions >= 3) ||
-                (ev.reExtracted >= 2 && ev.reflected >= 1));
-        case 'candidate':
-            // A: reflected >= 4 AND negative == 0 AND sessions >= 3
-            // B: reExtracted >= 2 AND negative == 0
-            return (ev.negative === 0) && ((ev.reflected >= 4 && ev.sessions >= 3) ||
-                (ev.reExtracted >= 2));
-        case 'verified':
-            // reflected >= 8, negative <= 1, sessions >= 5
-            return ev.reflected >= 8 && ev.negative <= 1 && ev.sessions >= 5;
+        case 'experiment': {
+            const minReflected = t?.experiment.reflected ?? 3;
+            const minSessions = t?.experiment.sessions ?? 3;
+            const minReExtracted = t?.experiment.reExtracted ?? 2;
+            // A: reflected >= threshold AND negative == 0 AND sessions >= threshold
+            // B: reExtracted >= threshold AND negative == 0 AND reflected >= 1
+            return (ev.negative === 0 &&
+                ((ev.reflected >= minReflected && ev.sessions >= minSessions) ||
+                    (ev.reExtracted >= minReExtracted && ev.reflected >= 1)));
+        }
+        case 'candidate': {
+            const minReflected = t?.candidate.reflected ?? 4;
+            const minSessions = t?.candidate.sessions ?? 3;
+            const minReExtracted = t?.candidate.reExtracted ?? 2;
+            // A: reflected >= threshold AND negative == 0 AND sessions >= threshold
+            // B: reExtracted >= threshold AND negative == 0
+            return (ev.negative === 0 &&
+                ((ev.reflected >= minReflected && ev.sessions >= minSessions) ||
+                    ev.reExtracted >= minReExtracted));
+        }
+        case 'verified': {
+            const minReflected = t?.verified.reflected ?? 8;
+            const minSessions = t?.verified.sessions ?? 5;
+            const maxNegative = t?.verified.negative ?? 1;
+            return (ev.reflected >= minReflected && ev.negative <= maxNegative && ev.sessions >= minSessions);
+        }
         default:
             return false;
     }
@@ -88,21 +117,28 @@ export function checkIdentifierStaleness(fm, cwd) {
     if (fm.identifiers.length === 0)
         return false; // no identifiers to check
     try {
-        const validIds = fm.identifiers.slice(0, 5).filter(id => id.length >= 6);
+        const validIds = fm.identifiers.slice(0, 5).filter((id) => id.length >= 6);
         // All identifiers were too short — nothing to grep, treat as stale (matches original behavior)
         if (validIds.length === 0)
             return true;
         // Escape regex metacharacters and join with OR for a single grep call
         // (previously: one execFileSync per identifier — up to 15s worst case)
-        const pattern = validIds.map(id => id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+        const pattern = validIds.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
         execFileSync('grep', [
-            '-r', '-E',
-            '--include=*.ts', '--include=*.tsx',
-            '--include=*.js', '--include=*.jsx',
+            '-r',
+            '-E',
+            '--include=*.ts',
+            '--include=*.tsx',
+            '--include=*.js',
+            '--include=*.jsx',
             '--exclude-dir=node_modules',
             '--exclude-dir=dist',
             '--exclude-dir=.git',
-            '-l', '-m', '1', pattern, '.',
+            '-l',
+            '-m',
+            '1',
+            pattern,
+            '.',
         ], { cwd, encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
         return false; // grep exit 0 = at least one identifier found = not stale
     }
@@ -143,7 +179,7 @@ export function isStale(fm) {
  * PR2b: solution-writer.mutateSolutionFile로 통합. lock + fresh re-read + atomic write.
  */
 export function updateSolutionFile(filePath, updates) {
-    return mutateSolutionFile(filePath, sol => {
+    return mutateSolutionFile(filePath, (sol) => {
         sol.frontmatter = {
             ...sol.frontmatter,
             ...updates,
@@ -152,15 +188,17 @@ export function updateSolutionFile(filePath, updates) {
     });
 }
 /** Run lifecycle check on all solutions */
-export function runLifecycleCheck(sessionId = 'system') {
+export function runLifecycleCheck(_sessionId = 'system') {
     const result = { promoted: [], demoted: [], retired: [], contradictions: [] };
+    // Meta-learning: load adaptive thresholds if available
+    const adaptiveThresholds = loadAdaptiveThresholds();
     const dirs = [ME_SOLUTIONS, ME_RULES];
     for (const dir of dirs) {
         if (!fs.existsSync(dir))
             continue;
         let files;
         try {
-            files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
         }
         catch {
             continue;
@@ -182,7 +220,10 @@ export function runLifecycleCheck(sessionId = 'system') {
                 // 2. Check confidence-status consistency
                 const demoteTo = checkConfidenceDemotion(fm);
                 if (demoteTo) {
-                    if (updateSolutionFile(filePath, { status: demoteTo, confidence: statusConfidence(demoteTo) })) {
+                    if (updateSolutionFile(filePath, {
+                        status: demoteTo,
+                        confidence: statusConfidence(demoteTo),
+                    })) {
                         result.demoted.push(`${fm.name}: ${fm.status} → ${demoteTo}`);
                     }
                     continue;
@@ -198,7 +239,7 @@ export function runLifecycleCheck(sessionId = 'system') {
                 // 4. Check promotion FIRST (with minimum age gate based on updated timestamp)
                 //    Promotion must run before identifier staleness to give solutions a chance
                 //    to be promoted before being penalized for stale identifiers.
-                if (checkPromotion(fm)) {
+                if (checkPromotion(fm, adaptiveThresholds)) {
                     const minAgeMs = MIN_AGE_FOR_PROMOTION[fm.status] ?? 0;
                     const ageMs = Date.now() - new Date(fm.updated || fm.created).getTime();
                     if (ageMs >= minAgeMs) {
@@ -215,7 +256,7 @@ export function runLifecycleCheck(sessionId = 'system') {
                 if (fm.identifiers.length > 0) {
                     const effectiveCwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
                     if (checkIdentifierStaleness(fm, effectiveCwd)) {
-                        const newConf = Math.max(0, fm.confidence - 0.20);
+                        const newConf = Math.max(0, fm.confidence - 0.2);
                         if (updateSolutionFile(filePath, { confidence: newConf })) {
                             result.demoted.push(`${fm.name}: identifier-stale (confidence → ${newConf})`);
                         }
@@ -239,7 +280,7 @@ export function detectContradictions(dirs) {
         if (!fs.existsSync(dir))
             continue;
         try {
-            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
             for (const file of files) {
                 const content = fs.readFileSync(path.join(dir, file), 'utf-8');
                 const fm = parseFrontmatterOnly(content);
@@ -248,22 +289,24 @@ export function detectContradictions(dirs) {
                 solutions.push({ name: fm.name, tags: fm.tags, identifiers: fm.identifiers });
             }
         }
-        catch { /* 솔루션 파일 파싱 실패 무시 — 중복 감지는 best-effort */ }
+        catch {
+            /* 솔루션 파일 파싱 실패 무시 — 중복 감지는 best-effort */
+        }
     }
     // Pre-build tag Sets for O(1) lookup — avoids O(m²) per pair
-    const tagSets = solutions.map(s => new Set(s.tags));
+    const tagSets = solutions.map((s) => new Set(s.tags));
     // Pairwise comparison
     for (let i = 0; i < solutions.length; i++) {
         for (let j = i + 1; j < solutions.length; j++) {
             const a = solutions[i];
             const b = solutions[j];
             // Tags overlap > 70%
-            const overlap = a.tags.filter(t => tagSets[j].has(t));
+            const overlap = a.tags.filter((t) => tagSets[j].has(t));
             const overlapRatio = overlap.length / Math.max(a.tags.length, b.tags.length, 1);
             if (overlapRatio < 0.7)
                 continue;
             // Identifiers completely different
-            const idOverlap = a.identifiers.filter(id => b.identifiers.includes(id));
+            const idOverlap = a.identifiers.filter((id) => b.identifiers.includes(id));
             if (idOverlap.length === 0 && a.identifiers.length > 0 && b.identifiers.length > 0) {
                 contradictions.push(`${a.name} vs ${b.name} (tags ${(overlapRatio * 100).toFixed(0)}% overlap, identifiers disjoint)`);
             }
@@ -278,7 +321,7 @@ export function verifySolution(solutionName) {
         if (!fs.existsSync(dir))
             continue;
         try {
-            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
             for (const file of files) {
                 const filePath = path.join(dir, file);
                 // PR2c-4 (security L-1): symlink을 통한 임의 파일 read 차단.
@@ -299,7 +342,9 @@ export function verifySolution(solutionName) {
                 return updateSolutionFile(filePath, { status: 'verified', confidence: 0.8 });
             }
         }
-        catch { /* 솔루션 파일 읽기/업데이트 실패 무시 — false 반환으로 재시도 가능 */ }
+        catch {
+            /* 솔루션 파일 읽기/업데이트 실패 무시 — false 반환으로 재시도 가능 */
+        }
     }
     return false;
 }