@wooojin/forgen 0.2.1 → 0.3.1

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;
 /**
@@ -43,10 +44,39 @@ export declare const STATE_DIR: string;
  * `src/engine/match-eval-log.ts`; never on the hook critical path.
  */
 export declare const MATCH_EVAL_LOG_PATH: string;
+/**
+ * ~/.forgen/state/solution-quarantine.jsonl — JSONL log of solution files
+ * dropped during index build due to malformed frontmatter. Append-only,
+ * dedupe-by-path. Used by `forgen doctor` to surface dead solutions that
+ * would otherwise vanish silently (see `diagnoseFrontmatter`).
+ */
+export declare const SOLUTION_QUARANTINE_PATH: string;
+/**
+ * ~/.forgen/state/outcomes/ — per-session JSONL logs of solution inject →
+ * outcome events (accept / correct / error / unknown). Written by the
+ * solution-outcome-tracker hook. One file per session for write-safety
+ * under concurrent sessions. Consumers aggregate across files to compute
+ * fitness (see `solution-fitness.ts`).
+ */
+export declare const OUTCOMES_DIR: string;
+/**
+ * ~/.forgen/lab/candidates/ — Phase 4 quarantine zone for evolver-agent
+ * proposals before they enter the live solution index. The evolver writes
+ * here; promotion and rollback commands move files out (to ME_SOLUTIONS
+ * or to `lab/archived-{ts}/`). Keeping candidates isolated means a
+ * runaway agent cannot silently poison the match pool.
+ */
+export declare const CANDIDATES_DIR: string;
+/** ~/.forgen/lab/archived/ — rollback destination for evolved solutions. */
+export declare const ARCHIVED_DIR: string;
 /** ~/.forgen/sessions/ — 세션 로그 */
 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 +104,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');
 /**
@@ -46,10 +47,39 @@ export const STATE_DIR = path.join(FORGEN_HOME, 'state');
  * `src/engine/match-eval-log.ts`; never on the hook critical path.
  */
 export const MATCH_EVAL_LOG_PATH = path.join(STATE_DIR, 'match-eval-log.jsonl');
+/**
+ * ~/.forgen/state/solution-quarantine.jsonl — JSONL log of solution files
+ * dropped during index build due to malformed frontmatter. Append-only,
+ * dedupe-by-path. Used by `forgen doctor` to surface dead solutions that
+ * would otherwise vanish silently (see `diagnoseFrontmatter`).
+ */
+export const SOLUTION_QUARANTINE_PATH = path.join(STATE_DIR, 'solution-quarantine.jsonl');
+/**
+ * ~/.forgen/state/outcomes/ — per-session JSONL logs of solution inject →
+ * outcome events (accept / correct / error / unknown). Written by the
+ * solution-outcome-tracker hook. One file per session for write-safety
+ * under concurrent sessions. Consumers aggregate across files to compute
+ * fitness (see `solution-fitness.ts`).
+ */
+export const OUTCOMES_DIR = path.join(STATE_DIR, 'outcomes');
+/**
+ * ~/.forgen/lab/candidates/ — Phase 4 quarantine zone for evolver-agent
+ * proposals before they enter the live solution index. The evolver writes
+ * here; promotion and rollback commands move files out (to ME_SOLUTIONS
+ * or to `lab/archived-{ts}/`). Keeping candidates isolated means a
+ * runaway agent cannot silently poison the match pool.
+ */
+export const CANDIDATES_DIR = path.join(FORGEN_HOME, 'lab', 'candidates');
+/** ~/.forgen/lab/archived/ — rollback destination for evolved solutions. */
+export const ARCHIVED_DIR = path.join(FORGEN_HOME, 'lab', 'archived');
 /** ~/.forgen/sessions/ — 세션 로그 */
 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 +110,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 */