@wooojin/forgen 0.2.0 → 0.3.0

package/dist/core/doctor.js

@@ -2,7 +2,8 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { FORGEN_HOME, LAB_DIR, ME_BEHAVIOR, ME_DIR, ME_PHILOSOPHY, ME_SOLUTIONS, ME_RULES, PACKS_DIR, SESSIONS_DIR, STATE_DIR } from './paths.js';
+import { FORGEN_HOME, LAB_DIR, ME_BEHAVIOR, ME_DIR, ME_PHILOSOPHY, ME_SOLUTIONS, ME_RULES, ME_SKILLS, PACKS_DIR, SESSIONS_DIR, STATE_DIR } from './paths.js';
+import { getTimingStats } from '../hooks/shared/hook-timing.js';
 /** ~/.claude/projects/ — Claude Code 세션 저장 경로 */
 const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 function check(label, condition, hint) {
@@ -104,6 +105,60 @@ export async function runDoctor() {
     }
     console.log(`  Claude Code sessions: ${CLAUDE_PROJECTS_DIR}`);
     console.log();
+    // Hook Health: recent error tracking
+    console.log('  [Hook Health]');
+    try {
+        const hookErrorsPath = path.join(STATE_DIR, 'hook-errors.jsonl');
+        if (exists(hookErrorsPath)) {
+            const content = fs.readFileSync(hookErrorsPath, 'utf-8');
+            const entries = content.trim().split('\n')
+                .map(line => { try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            } })
+                .filter(Boolean);
+            const byHook = new Map();
+            for (const e of entries) {
+                byHook.set(e.hook, (byHook.get(e.hook) ?? 0) + 1);
+            }
+            if (byHook.size === 0) {
+                console.log('  No hook errors recorded.');
+            }
+            else {
+                for (const [hook, count] of [...byHook.entries()].sort((a, b) => b[1] - a[1])) {
+                    console.log(`  ${hook}: ${count} error(s)`);
+                }
+            }
+        }
+        else {
+            console.log('  No hook errors recorded.');
+        }
+    }
+    catch {
+        console.log('  Unable to read hook error log.');
+    }
+    console.log();
+    // Hook Timing: performance stats
+    console.log('  [Hook Timing]');
+    const timingStats = getTimingStats();
+    if (timingStats.length === 0) {
+        console.log('  No timing data collected yet.');
+    }
+    else {
+        console.log('  Hook                  Count   p50ms   p95ms   max ms');
+        console.log('  ' + '-'.repeat(56));
+        for (const s of timingStats) {
+            const hook = s.hook.padEnd(22);
+            const count = String(s.count).padStart(5);
+            const p50 = String(s.p50).padStart(7);
+            const p95 = String(s.p95).padStart(7);
+            const max = String(s.max).padStart(8);
+            console.log(`  ${hook}${count}${p50}${p95}${max}`);
+        }
+    }
+    console.log();
     console.log();
     // v1: 팀 팩 시스템 제거. 개인 모드만 지원.
     console.log('  [Pack Connections]');
@@ -149,32 +204,107 @@ export async function runDoctor() {
             console.log();
         }
     }
-    // 훅 에러 카운트
-    console.log('  [Hook Health]');
-    const hookErrorPath = path.join(STATE_DIR, 'hook-errors.json');
-    if (fs.existsSync(hookErrorPath)) {
-        try {
-            const errors = JSON.parse(fs.readFileSync(hookErrorPath, 'utf-8'));
-            const entries = Object.entries(errors);
-            if (entries.length === 0) {
-                console.log('  No hook errors recorded');
-            }
-            else {
-                for (const [hookName, { count, lastAt }] of entries) {
-                    const icon = count === 0 ? '✓' : '⚠';
-                    const lastDate = lastAt ? lastAt.split('T')[0] : 'unknown';
-                    console.log(`  ${icon} ${hookName}: ${count} error${count !== 1 ? 's' : ''}${count > 0 ? ` (last: ${lastDate})` : ''}`);
+    // Harness Maturity section
+    console.log('  [Harness Maturity]');
+    const cwd = process.cwd();
+    // 1. Preparation
+    const hasClaude = fs.existsSync(path.join(cwd, 'CLAUDE.md'));
+    let rulesCount = 0;
+    try {
+        const rulesDir = path.join(cwd, '.claude', 'rules');
+        if (fs.existsSync(rulesDir)) {
+            rulesCount = fs.readdirSync(rulesDir).filter(f => f.endsWith('.md')).length;
+        }
+    }
+    catch { /* fail-open */ }
+    let hooksActive = 0;
+    try {
+        const hooksJsonPath = path.join(cwd, 'hooks', 'hooks.json');
+        if (fs.existsSync(hooksJsonPath)) {
+            const hooksData = JSON.parse(fs.readFileSync(hooksJsonPath, 'utf-8'));
+            if (hooksData.hooks && typeof hooksData.hooks === 'object') {
+                for (const eventHooks of Object.values(hooksData.hooks)) {
+                    if (Array.isArray(eventHooks)) {
+                        for (const group of eventHooks) {
+                            if (Array.isArray(group.hooks)) {
+                                hooksActive += (group.hooks).length;
+                            }
+                        }
+                    }
                 }
             }
         }
-        catch {
-            console.log('  (hook-errors.json read failed)');
-        }
     }
-    else {
-        console.log('  No hook errors recorded');
+    catch { /* fail-open */ }
+    const prepL = hasClaude && rulesCount >= 3 && hooksActive > 0 ? 'L3' : hasClaude && hooksActive > 0 ? 'L2' : hasClaude ? 'L1' : 'L0';
+    // 2. Context
+    let solutionsCount = 0;
+    try {
+        if (exists(ME_SOLUTIONS))
+            solutionsCount = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md')).length;
+    }
+    catch { /* fail-open */ }
+    let behaviorCount = 0;
+    try {
+        if (exists(ME_BEHAVIOR))
+            behaviorCount = fs.readdirSync(ME_BEHAVIOR).filter(f => f.endsWith('.md')).length;
     }
+    catch { /* fail-open */ }
+    const ctxL = solutionsCount >= 5 && behaviorCount >= 3 ? 'L3' : solutionsCount >= 3 || behaviorCount >= 1 ? 'L2' : solutionsCount > 0 || behaviorCount > 0 ? 'L1' : 'L0';
+    // 3. Execution
+    const hasSkills = exists(ME_SKILLS);
+    const execL = hasSkills ? 'L2' : 'L1';
+    // 4. Validation
+    const hasTests = fs.existsSync(path.join(cwd, 'tests'));
+    const hasCI = fs.existsSync(path.join(cwd, '.github', 'workflows'));
+    const validL = hasTests && hasCI ? 'L3' : hasTests ? 'L2' : 'L1';
+    // 5. Improvement: reflection rate from solutions
+    let reflectionRate = 0;
+    try {
+        if (exists(ME_SOLUTIONS)) {
+            const solFiles = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
+            if (solFiles.length > 0) {
+                let reflected = 0;
+                for (const f of solFiles) {
+                    try {
+                        const content = fs.readFileSync(path.join(ME_SOLUTIONS, f), 'utf-8');
+                        const match = content.match(/reflected:\s*(\d+)/);
+                        if (match && parseInt(match[1], 10) > 0)
+                            reflected++;
+                    }
+                    catch { /* skip */ }
+                }
+                reflectionRate = Math.round((reflected / solFiles.length) * 100);
+            }
+        }
+    }
+    catch { /* fail-open */ }
+    const improvL = reflectionRate > 0 ? 'L3' : solutionsCount > 0 ? 'L2' : 'L1';
+    const levelIcon = (l) => l === 'L3' ? '✓' : l === 'L2' ? '✓' : l === 'L1' ? '✗' : '✗';
+    console.log(`  Axis               Level  Detail`);
+    console.log(`  ${'─'.repeat(55)}`);
+    console.log(`  ${levelIcon(prepL)} Preparation        ${prepL}     CLAUDE.md:${hasClaude ? 'yes' : 'no'}, rules:${rulesCount}, hooks:${hooksActive}`);
+    console.log(`  ${levelIcon(ctxL)} Context            ${ctxL}     solutions:${solutionsCount}, behavior:${behaviorCount}`);
+    console.log(`  ${levelIcon(execL)} Execution          ${execL}     skills:${hasSkills ? 'yes' : 'no'}`);
+    console.log(`  ${levelIcon(validL)} Validation         ${validL}     tests:${hasTests ? 'yes' : 'no'}, CI:${hasCI ? 'yes' : 'no'}`);
+    console.log(`  ${levelIcon(improvL)} Improvement        ${improvL}     reflection:${reflectionRate}%`);
     console.log();
+    // Quick wins: suggest for lowest scoring axes
+    const axes = [
+        { name: 'Preparation', level: prepL, hint: 'Add CLAUDE.md + .claude/rules/ files' },
+        { name: 'Context', level: ctxL, hint: 'Run /compound to accumulate solutions' },
+        { name: 'Execution', level: execL, hint: 'Promote solutions to skills' },
+        { name: 'Validation', level: validL, hint: 'Add tests/ dir and .github/workflows' },
+        { name: 'Improvement', level: improvL, hint: 'Reflect on existing solutions' },
+    ];
+    const quickWins = axes.filter(a => a.level === 'L0' || a.level === 'L1').slice(0, 3);
+    if (quickWins.length > 0) {
+        console.log('  Quick Wins (Top 3):');
+        for (const win of quickWins) {
+            console.log(`  → ${win.name}: ${win.hint}`);
+        }
+        console.log();
+    }
     // 현재 디렉토리 git 정보
     console.log('  [Git]');
     try {

package/dist/core/drift-score.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Forgen — Drift Score (Session Drift Detection)
+ *
+ * 세션 내 수정 패턴을 추적하여 drift(산만/반복 수정)를 감지.
+ * EWMA(Exponentially Weighted Moving Average) 기반 이동평균으로
+ * 최근 수정 강도를 측정하고, 임계값 초과 시 경고.
+ *
+ * Codex 합의: DriftState + evaluateDrift 2개만. 최소 인터페이스.
+ */
+/** Drift 상태 (세션 단위, STATE_DIR에 저장) */
+export interface DriftState {
+    sessionId: string;
+    totalEdits: number;
+    totalReverts: number;
+    /** EWMA edit rate (0~1, 높을수록 최근 수정 빈도 높음) */
+    ewmaEditRate: number;
+    /** EWMA revert rate (0~1) */
+    ewmaRevertRate: number;
+    /** 최근 경고 timestamp (쿨다운용) */
+    lastWarningAt: number;
+    lastCriticalAt: number;
+    hardCapReached: boolean;
+}
+export interface DriftResult {
+    level: 'normal' | 'warning' | 'critical' | 'hardcap';
+    score: number;
+    message: string | null;
+}
+export interface DriftThresholds {
+    alpha?: number;
+    warningEdits?: number;
+    criticalEdits?: number;
+    criticalReverts?: number;
+    hardCapEdits?: number;
+    warningCooldownMs?: number;
+    criticalCooldownMs?: number;
+}
+/** EWMA 업데이트 (순수 함수) */
+export declare function updateEwma(prev: number, sample: number, alpha: number): number;
+/** 새 DriftState 생성 */
+export declare function createDriftState(sessionId: string): DriftState;
+/**
+ * 도구 호출 이벤트로 drift 상태를 갱신하고 평가 결과를 반환.
+ * @param state 현재 상태 (mutate됨)
+ * @param isEdit Write/Edit 도구 호출 여부
+ * @param isRevert revert 감지 여부
+ * @param thresholds 커스텀 임계치 (hook-config에서 로드)
+ */
+export declare function evaluateDrift(state: DriftState, isEdit: boolean, isRevert: boolean, thresholds?: DriftThresholds): DriftResult;

package/dist/core/drift-score.js

@@ -0,0 +1,87 @@
+/**
+ * Forgen — Drift Score (Session Drift Detection)
+ *
+ * 세션 내 수정 패턴을 추적하여 drift(산만/반복 수정)를 감지.
+ * EWMA(Exponentially Weighted Moving Average) 기반 이동평균으로
+ * 최근 수정 강도를 측정하고, 임계값 초과 시 경고.
+ *
+ * Codex 합의: DriftState + evaluateDrift 2개만. 최소 인터페이스.
+ */
+const DEFAULTS = {
+    alpha: 0.35,
+    warningEdits: 15,
+    criticalEdits: 30,
+    criticalReverts: 2,
+    hardCapEdits: 50,
+    warningCooldownMs: 5 * 60 * 1000,
+    criticalCooldownMs: 10 * 60 * 1000,
+};
+/** EWMA 업데이트 (순수 함수) */
+export function updateEwma(prev, sample, alpha) {
+    return alpha * sample + (1 - alpha) * prev;
+}
+/** 새 DriftState 생성 */
+export function createDriftState(sessionId) {
+    return {
+        sessionId,
+        totalEdits: 0,
+        totalReverts: 0,
+        ewmaEditRate: 0,
+        ewmaRevertRate: 0,
+        lastWarningAt: 0,
+        lastCriticalAt: 0,
+        hardCapReached: false,
+    };
+}
+/**
+ * 도구 호출 이벤트로 drift 상태를 갱신하고 평가 결과를 반환.
+ * @param state 현재 상태 (mutate됨)
+ * @param isEdit Write/Edit 도구 호출 여부
+ * @param isRevert revert 감지 여부
+ * @param thresholds 커스텀 임계치 (hook-config에서 로드)
+ */
+export function evaluateDrift(state, isEdit, isRevert, thresholds = {}) {
+    const t = { ...DEFAULTS, ...thresholds };
+    const now = Date.now();
+    // Update counters
+    if (isEdit)
+        state.totalEdits++;
+    if (isRevert)
+        state.totalReverts++;
+    // Update EWMA
+    state.ewmaEditRate = updateEwma(state.ewmaEditRate, isEdit ? 1 : 0, t.alpha);
+    state.ewmaRevertRate = updateEwma(state.ewmaRevertRate, isRevert ? 1 : 0, t.alpha);
+    // Calculate drift score: edit rate 65% + revert rate 35%
+    const rawScore = (state.ewmaEditRate * 65) + (state.ewmaRevertRate * 35);
+    const score = Math.min(100, Math.max(0, Math.round(rawScore)));
+    // Hard cap
+    if (state.totalEdits >= t.hardCapEdits) {
+        state.hardCapReached = true;
+        return {
+            level: 'hardcap',
+            score: 100,
+            message: `[Forgen] ⛔ Session drift hard cap reached (${state.totalEdits} edits). Stop and reassess the approach before continuing.`,
+        };
+    }
+    // Critical: 2+ reverts OR 30+ edits OR score >= 78
+    if ((state.totalReverts >= t.criticalReverts || state.totalEdits >= t.criticalEdits || score >= 78) &&
+        (now - state.lastCriticalAt > t.criticalCooldownMs)) {
+        state.lastCriticalAt = now;
+        return {
+            level: 'critical',
+            score,
+            message: `[Forgen] ⚠ High drift detected (score: ${score}, edits: ${state.totalEdits}, reverts: ${state.totalReverts}). Consider stopping to redesign the approach.`,
+        };
+    }
+    // Warning: 15+ edits OR score >= 52
+    if ((state.totalEdits >= t.warningEdits || score >= 52) &&
+        (now - state.lastWarningAt > t.warningCooldownMs)) {
+        state.lastWarningAt = now;
+        return {
+            level: 'warning',
+            score,
+            message: `[Forgen] Drift building up (score: ${score}, edits: ${state.totalEdits}). Review your approach if changes feel repetitive.`,
+        };
+    }
+    return { level: 'normal', score, message: null };
+}

package/dist/core/harness.d.ts

@@ -11,14 +11,19 @@
  * - Lines 400-550: Rule file injection, gitignore, compound memory
  * - Lines 550+: prepareHarness — main orchestration
  */
+import { type RuntimeHost } from './types.js';
 import { rollbackSettings } from './settings-lock.js';
 import { type V1BootstrapResult } from './v1-bootstrap.js';
 export interface V1HarnessContext {
     cwd: string;
     inTmux: boolean;
     v1: V1BootstrapResult;
+    runtime: RuntimeHost;
 }
 /** 최초 실행 여부: ~/.forgen/ 디렉토리가 없으면 true */
 export declare function isFirstRun(): boolean;
 export { rollbackSettings };
-export declare function prepareHarness(cwd: string): Promise<V1HarnessContext>;
+interface PrepareHarnessOptions {
+    runtime?: RuntimeHost;
+}
+export declare function prepareHarness(cwd: string, options?: PrepareHarnessOptions): Promise<V1HarnessContext>;

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/mcp-config.d.ts

@@ -11,6 +11,8 @@ export interface McpServerConfig {
     command: string;
     args: string[];
     env?: Record<string, string>;
+    /** HTTP/SSE transport URL (alternative to command+args) */
+    url?: string;
 }
 /**
  * 기본 MCP 서버 템플릿 목록 반환

package/dist/core/mcp-config.js

@@ -101,7 +101,12 @@ export async function handleMcp(args) {
             for (const name of names) {
                 const cfg = installed[name];
                 console.log(`    ${name}`);
-                console.log(`      command: ${cfg.command} ${cfg.args.join(' ')}`);
+                if (cfg.command) {
+                    console.log(`      command: ${cfg.command} ${(cfg.args ?? []).join(' ')}`);
+                }
+                else if (cfg.url) {
+                    console.log(`      url: ${cfg.url}`);
+                }
                 if (cfg.env && Object.keys(cfg.env).length > 0) {
                     console.log(`      env: ${JSON.stringify(cfg.env)}`);
                 }

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"];
+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',
+    '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>;