@wooojin/forgen 0.1.0

package/dist/core/harness.js

@@ -0,0 +1,621 @@
+/**
+ * Forgen v1 — Core Harness (prepareHarness entry point)
+ *
+ * v1 설계: v1-bootstrap 기반 세션 오케스트레이션.
+ * philosophy/scope/pack 의존 제거. Profile + Preset Manager + Rule Renderer.
+ *
+ * Module Structure:
+ * - Lines 1-70: Imports, utility helpers
+ * - Lines 70-220: injectSettings — Claude Code settings.json injection
+ * - Lines 220-400: Agent/skill installation helpers
+ * - Lines 400-550: Rule file injection, gitignore, compound memory
+ * - Lines 550+: prepareHarness — main orchestration
+ */
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildEnv, generateClaudeRuleFiles, registerTmuxBindings } from './config-injector.js';
+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 { 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';
+const log = createLogger('harness');
+/** forgen 패키지 루트 */
+function getPackageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+}
+/** 최초 실행 여부: ~/.forgen/ 디렉토리가 없으면 true */
+export function isFirstRun() {
+    return !fs.existsSync(FORGEN_HOME);
+}
+/**
+ * A5: all directories under FORGEN_HOME only. Pre-A5 this function
+ * also created directories under `~/.compound/` (COMPOUND_HOME), which
+ * caused a dual-reality when the migration symlink was broken. Now the
+ * migration function handles reading from the old location if needed,
+ * but ALL writes go under `~/.forgen/`.
+ */
+function ensureDirectories() {
+    const dirs = [
+        FORGEN_HOME,
+        ME_DIR,
+        ME_SOLUTIONS,
+        ME_BEHAVIOR,
+        ME_RULES,
+        ME_SKILLS,
+        SESSIONS_DIR,
+        STATE_DIR,
+        HANDOFFS_DIR,
+        path.join(FORGEN_HOME, 'plans'),
+        path.join(FORGEN_HOME, 'specs'),
+        path.join(FORGEN_HOME, 'artifacts', 'ask'),
+    ];
+    for (const dir of dirs) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    ensureV1Directories();
+}
+export { rollbackSettings };
+// ── Settings Injection ──
+const FORGEN_PERMISSION_RULES = new Set([
+    '# forgen-managed',
+    'Bash(rm -rf *)',
+    'Bash(git push --force*)',
+    'Bash(git reset --hard*)',
+]);
+function stripForgenManagedRules(rules) {
+    return rules.filter(r => !FORGEN_PERMISSION_RULES.has(r));
+}
+/** Claude Code settings.json에 하네스 환경변수 + 훅 주입 */
+// ── B9: injectSettings sub-phases (extracted from 128-line monolith) ──
+/** Read settings.json with backup, or return empty object on failure. */
+function readSettingsWithBackup() {
+    if (!fs.existsSync(SETTINGS_PATH))
+        return {};
+    try {
+        const settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8'));
+        fs.copyFileSync(SETTINGS_PATH, SETTINGS_BACKUP_PATH);
+        return settings;
+    }
+    catch (e) {
+        log.debug('settings.json 파싱 실패, 빈 설정으로 시작', new ConfigError('settings.json parse failed', { configPath: SETTINGS_PATH, cause: e }));
+        return {};
+    }
+}
+/** Apply forgen statusLine only if user hasn't set a custom one. */
+function applyStatusLine(settings) {
+    const existing = settings.statusLine;
+    const isForgenOwned = !existing || !existing.command || existing.command.startsWith('forgen');
+    if (isForgenOwned) {
+        settings.statusLine = { type: 'command', command: 'forgen me' };
+    }
+}
+/** Check if a settings.json hook entry was installed by forgen. */
+function isForgenHookEntry(entry, pkgRoot) {
+    const distHooksPath = path.join(pkgRoot, 'dist', 'hooks');
+    const matchesPath = (cmd) => cmd.includes(distHooksPath) || /[\\/]dist[\\/]hooks[\\/].*\.js/.test(cmd);
+    if (typeof entry.command === 'string' && matchesPath(entry.command))
+        return true;
+    const hooks = entry.hooks;
+    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) {
+    const pkgRoot = getPackageRoot();
+    const hooksConfig = settings.hooks ?? {};
+    // Remove existing forgen hooks (clean slate before re-inject)
+    for (const [event, entries] of Object.entries(hooksConfig)) {
+        if (!Array.isArray(entries))
+            continue;
+        const filtered = entries.filter(h => !isForgenHookEntry(h, pkgRoot));
+        if (filtered.length === 0)
+            delete hooksConfig[event];
+        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);
+                }
+            }
+        }
+    }
+    catch (e) {
+        log.debug('hooks.json 로드 실패', e);
+    }
+    settings.hooks = Object.keys(hooksConfig).length > 0 ? hooksConfig : undefined;
+    if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+    }
+}
+/** Apply v1 trust policy → permissions (deny/ask lists). */
+function applyTrustPolicyPermissions(settings, v1Result) {
+    if (!v1Result.session)
+        return;
+    const trust = v1Result.session.effective_trust_policy;
+    const permissions = settings.permissions ?? {};
+    const existingDeny = stripForgenManagedRules(permissions.deny ?? []);
+    if (trust === '가드레일 우선') {
+        permissions.deny = [
+            ...existingDeny, '# forgen-managed',
+            'Bash(rm -rf *)', 'Bash(git push --force*)', 'Bash(git reset --hard*)',
+        ];
+    }
+    else if (trust === '승인 완화') {
+        const existingAsk = stripForgenManagedRules(permissions.ask ?? []);
+        permissions.ask = [
+            ...existingAsk, '# forgen-managed',
+            'Bash(rm -rf *)', 'Bash(git push --force*)',
+        ];
+        permissions.deny = existingDeny.length > 0 ? existingDeny : undefined;
+    }
+    // '완전 신뢰 실행': 추가 제한 없음
+    if (!permissions.deny?.length)
+        delete permissions.deny;
+    if (!permissions.ask?.length)
+        delete permissions.ask;
+    if (Object.keys(permissions).length > 0)
+        settings.permissions = permissions;
+}
+/**
+ * B9: injectSettings — now a ~20-line coordinator calling the extracted
+ * sub-phases above. Pre-B9 this was 128 lines with interleaved phases
+ * (read/backup, env merge, statusLine, hook strip+inject, trust policy,
+ * atomic write). Each phase is now a named function with a single
+ * responsibility, testable in isolation if needed.
+ */
+function injectSettings(env, v1Result) {
+    fs.mkdirSync(CLAUDE_DIR, { recursive: true });
+    acquireLock();
+    const settings = readSettingsWithBackup();
+    // Merge env vars
+    settings.env = { ...(settings.env ?? {}), ...env };
+    applyStatusLine(settings);
+    mergeHooksIntoSettings(settings);
+    applyTrustPolicyPermissions(settings, v1Result);
+    try {
+        atomicWriteFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    }
+    catch (err) {
+        rollbackSettings();
+        throw err;
+    }
+    finally {
+        releaseLock();
+    }
+}
+// ── Agent Installation ──
+function contentHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 12);
+}
+const AGENT_HASHES_PATH = path.join(STATE_DIR, 'agent-hashes.json');
+function loadAgentHashes() {
+    try {
+        if (fs.existsSync(AGENT_HASHES_PATH)) {
+            return JSON.parse(fs.readFileSync(AGENT_HASHES_PATH, 'utf-8'));
+        }
+    }
+    catch (e) {
+        log.debug('에이전트 해시 맵 로드 실패', e);
+    }
+    return {};
+}
+function saveAgentHashes(hashes) {
+    try {
+        fs.mkdirSync(path.dirname(AGENT_HASHES_PATH), { recursive: true });
+        fs.writeFileSync(AGENT_HASHES_PATH, JSON.stringify(hashes, null, 2));
+    }
+    catch (e) {
+        log.debug('에이전트 해시 맵 저장 실패', e);
+    }
+}
+function installAgentsFromDir(sourceDir, targetDir, prefix, hashes) {
+    if (!fs.existsSync(sourceDir))
+        return;
+    const files = fs.readdirSync(sourceDir).filter((f) => f.endsWith('.md'));
+    for (const file of files) {
+        const src = path.join(sourceDir, file);
+        const dstName = `${prefix}${file}`;
+        const dst = path.join(targetDir, dstName);
+        const content = fs.readFileSync(src, 'utf-8');
+        const newHash = contentHash(content);
+        if (fs.existsSync(dst)) {
+            const existing = fs.readFileSync(dst, 'utf-8');
+            if (existing === content) {
+                hashes[dstName] = newHash;
+                continue;
+            }
+            const recordedHash = hashes[dstName];
+            if (recordedHash && contentHash(existing) !== recordedHash) {
+                log.debug(`에이전트 파일 보호: ${dstName} (사용자 수정 감지)`);
+                continue;
+            }
+            if (!recordedHash && !existing.includes('<!-- forgen-managed -->')) {
+                log.debug(`에이전트 파일 보호: ${dstName} (레거시 사용자 수정 감지)`);
+                continue;
+            }
+        }
+        fs.writeFileSync(dst, content);
+        hashes[dstName] = newHash;
+    }
+}
+/** 에이전트 정의 파일 설치 (패키지 내장만) */
+function installAgents(cwd) {
+    const pkgRoot = getPackageRoot();
+    const targetDir = path.join(cwd, '.claude', 'agents');
+    fs.mkdirSync(targetDir, { recursive: true });
+    const hashes = loadAgentHashes();
+    try {
+        installAgentsFromDir(path.join(pkgRoot, 'agents'), targetDir, 'ch-', hashes);
+        saveAgentHashes(hashes);
+    }
+    catch (e) {
+        log.debug('에이전트 설치 실패', e);
+    }
+}
+// ── Slash Commands ──
+function buildCommandContent(skillContent, skillName) {
+    const descMatch = skillContent.match(/description:\s*(.+)/);
+    const desc = descMatch?.[1]?.trim() ?? skillName;
+    return `# ${desc}\n\n<!-- forgen-managed -->\n\nActivate Forgen "${skillName}" mode for the task: $ARGUMENTS\n\n${skillContent}`;
+}
+function safeWriteCommand(cmdPath, content) {
+    if (fs.existsSync(cmdPath)) {
+        const existing = fs.readFileSync(cmdPath, 'utf-8');
+        if (!existing.includes('<!-- forgen-managed -->'))
+            return false;
+    }
+    fs.writeFileSync(cmdPath, content);
+    return true;
+}
+function cleanupStaleCommands(commandsDir, validFiles) {
+    if (!fs.existsSync(commandsDir))
+        return 0;
+    let removed = 0;
+    for (const file of fs.readdirSync(commandsDir).filter((f) => f.endsWith('.md'))) {
+        if (validFiles.has(file))
+            continue;
+        const filePath = path.join(commandsDir, file);
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            if (content.includes('<!-- forgen-managed -->')) {
+                fs.unlinkSync(filePath);
+                removed++;
+            }
+        }
+        catch (e) {
+            log.debug(`stale 명령 파일 정리 실패: ${file}`, e);
+        }
+    }
+    return removed;
+}
+/** 스킬을 Claude Code 슬래시 명령으로 설치 (패키지 내장만) */
+function installSlashCommands(_cwd) {
+    const pkgRoot = getPackageRoot();
+    let skillsDir = path.join(pkgRoot, 'commands');
+    if (!fs.existsSync(skillsDir)) {
+        skillsDir = path.join(pkgRoot, 'skills');
+    }
+    const homeDir = os.homedir();
+    const globalCommandsDir = path.join(homeDir, '.claude', 'commands', 'forgen');
+    if (!fs.existsSync(skillsDir))
+        return;
+    fs.mkdirSync(globalCommandsDir, { recursive: true });
+    const skills = fs.readdirSync(skillsDir).filter((f) => f.endsWith('.md'));
+    const validGlobalFiles = new Set();
+    let installed = 0;
+    for (const file of skills) {
+        validGlobalFiles.add(file);
+        const skillName = file.replace('.md', '');
+        const skillContent = fs.readFileSync(path.join(skillsDir, file), 'utf-8');
+        const cmdContent = buildCommandContent(skillContent, skillName);
+        if (safeWriteCommand(path.join(globalCommandsDir, file), cmdContent)) {
+            installed++;
+        }
+    }
+    const removedGlobal = validGlobalFiles.size > 0
+        ? cleanupStaleCommands(globalCommandsDir, validGlobalFiles)
+        : 0;
+    log.debug(`슬래시 명령 설치: ${installed}개 설치, ${removedGlobal}개 정리`);
+}
+// ── Rule File Injection ──
+function injectClaudeRuleFiles(cwd, ruleFiles) {
+    const PER_RULE_CAP = RULE_FILE_CAPS.perRuleFile;
+    const TOTAL_CAP = RULE_FILE_CAPS.totalRuleFiles;
+    const globalRulesDir = path.join(os.homedir(), '.claude', 'rules');
+    const projectRulesDir = path.join(cwd, '.claude', 'rules');
+    fs.mkdirSync(globalRulesDir, { recursive: true });
+    fs.mkdirSync(projectRulesDir, { recursive: true });
+    let totalWritten = 0;
+    for (const [filename, content] of Object.entries(ruleFiles)) {
+        const capped = content.length > PER_RULE_CAP
+            ? `${content.slice(0, PER_RULE_CAP)}\n... (capped at rule file limit)\n`
+            : content;
+        if (totalWritten + capped.length > TOTAL_CAP) {
+            log.debug(`rules/ 총량 캡 도달, ${filename} 생략`);
+            break;
+        }
+        const isUserPreference = filename.startsWith('forge-');
+        const targetDir = isUserPreference ? globalRulesDir : projectRulesDir;
+        fs.writeFileSync(path.join(targetDir, filename), capped);
+        totalWritten += capped.length;
+    }
+    // 마이그레이션: 이전 위치 파일 제거
+    const legacyPath = path.join(cwd, '.claude', 'compound-rules.md');
+    if (fs.existsSync(legacyPath)) {
+        try {
+            fs.unlinkSync(legacyPath);
+        }
+        catch (e) {
+            log.debug('레거시 규칙 파일 삭제 실패', e);
+        }
+    }
+    // CLAUDE.md에서 이전 마커 블록 제거
+    const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+    const marker = '<!-- forgen:start -->';
+    const endMarker = '<!-- forgen:end -->';
+    if (fs.existsSync(claudeMdPath)) {
+        const content = fs.readFileSync(claudeMdPath, 'utf-8');
+        if (content.includes(marker)) {
+            const regex = new RegExp(`\\n*${marker}[\\s\\S]*?${endMarker}\\n*`, 'g');
+            const cleaned = content
+                .replace(regex, '\n')
+                .replace(/\n{3,}/g, '\n\n')
+                .trim();
+            fs.writeFileSync(claudeMdPath, cleaned ? `${cleaned}\n` : '');
+        }
+    }
+}
+// ── Compound Memory ──
+function ensureCompoundMemory(cwd) {
+    try {
+        const sanitized = cwd.replace(/\//g, '-').replace(/^-/, '');
+        const memoryDir = path.join(os.homedir(), '.claude', 'projects', sanitized, 'memory');
+        if (!fs.existsSync(memoryDir))
+            return;
+        const memoryMdPath = path.join(memoryDir, 'MEMORY.md');
+        const compoundPointer = '- [Compound Knowledge](compound-index.md) — accumulated patterns/solutions from past sessions';
+        if (fs.existsSync(memoryMdPath)) {
+            const content = fs.readFileSync(memoryMdPath, 'utf-8');
+            if (content.includes('compound-index.md'))
+                return;
+            fs.writeFileSync(memoryMdPath, content.trimEnd() + '\n' + compoundPointer + '\n');
+        }
+        const indexPath = path.join(memoryDir, 'compound-index.md');
+        const solutionsDir = ME_SOLUTIONS;
+        let solutionCount = 0;
+        try {
+            solutionCount = fs.readdirSync(solutionsDir).filter(f => f.endsWith('.md')).length;
+        }
+        catch { /* solutions dir may not exist */ }
+        const indexContent = [
+            '---',
+            'name: compound-knowledge-index',
+            'description: Forgen compound knowledge — use compound-search MCP tool to find relevant patterns',
+            'type: reference',
+            '---',
+            '',
+            `${solutionCount} accumulated solutions available via forgen-compound MCP tools.`,
+            '',
+            'Use compound-search to find relevant patterns before starting tasks.',
+            'Use compound-read to get full solution content.',
+        ].join('\n');
+        fs.writeFileSync(indexPath, indexContent);
+    }
+    catch {
+        // auto memory 접근 실패는 무시
+    }
+}
+// ── Gitignore ──
+function ensureGitignore(cwd) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const forgenEntries = [
+        '# Forgen (auto-generated, do not commit)',
+        '.claude/agents/ch-*.md',
+        '.claude/agents/pack-*.md',
+        '.claude/rules/project-context.md',
+        '.claude/rules/routing.md',
+        '.claude/rules/forge-*.md',
+        '.claude/rules/v1-rules.md',
+        '.compound/project-map.json',
+        '.claude/commands/forgen/',
+        '.compound/notepad.md',
+    ];
+    const marker = '.claude/agents/ch-*.md';
+    try {
+        let content = '';
+        if (fs.existsSync(gitignorePath)) {
+            content = fs.readFileSync(gitignorePath, 'utf-8');
+            if (content.includes(marker))
+                return;
+        }
+        const newContent = `${content.trimEnd()}\n\n${forgenEntries.join('\n')}\n`;
+        fs.writeFileSync(gitignorePath, newContent);
+    }
+    catch {
+        // .gitignore 쓰기 실패는 무시
+    }
+}
+// ── Main Harness ──
+/** ~/.tenetx/ 및 ~/.compound/ → ~/.forgen/ 스토리지 마이그레이션 */
+function migrateToForgen() {
+    const home = os.homedir();
+    if (home.startsWith('/tmp/') || home.includes('forgen-test'))
+        return;
+    const forgenHome = path.join(home, '.forgen');
+    const legacyDirs = [
+        path.join(home, '.tenetx'),
+        path.join(home, '.compound'),
+    ];
+    for (const legacyHome of legacyDirs) {
+        try {
+            if (fs.lstatSync(legacyHome).isSymbolicLink())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (!fs.existsSync(legacyHome) || !fs.statSync(legacyHome).isDirectory())
+            continue;
+        fs.mkdirSync(forgenHome, { recursive: true });
+        try {
+            const entries = fs.readdirSync(legacyHome, { withFileTypes: true });
+            for (const entry of entries) {
+                const src = path.join(legacyHome, entry.name);
+                const dest = path.join(forgenHome, entry.name);
+                if (fs.existsSync(dest))
+                    continue;
+                if (entry.isDirectory()) {
+                    fs.cpSync(src, dest, { recursive: true });
+                }
+                else if (entry.isFile()) {
+                    fs.copyFileSync(src, dest);
+                }
+            }
+        }
+        catch (e) {
+            log.debug(`migrateToForgen: ${legacyHome} 파일 복사 중 오류`, e);
+        }
+        const backupPath = legacyHome + '.bak';
+        try {
+            if (!fs.existsSync(backupPath)) {
+                fs.renameSync(legacyHome, backupPath);
+                fs.symlinkSync(forgenHome, legacyHome, 'dir');
+                log.debug(`migrateToForgen: ${legacyHome} → ~/.forgen symlink 생성 완료`);
+            }
+        }
+        catch (e) {
+            log.debug(`migrateToForgen: ${legacyHome} symlink 생성 실패`, e);
+        }
+    }
+    // 레거시 디렉토리가 없으면 symlink 생성
+    for (const legacyHome of legacyDirs) {
+        if (!fs.existsSync(legacyHome)) {
+            try {
+                fs.symlinkSync(forgenHome, legacyHome, 'dir');
+            }
+            catch { /* ignore */ }
+        }
+    }
+}
+/** 메인 하네스 준비 함수 (v1) */
+// ── B9: prepareHarness sub-phases (extracted steps 11-12) ──
+/** Step 11: start legacy session log (fail-open). */
+async function startLegacySessionLog(cwd, inTmux, v1Result) {
+    try {
+        const { startSessionLog: legacySessionLog } = await import('./session-logger.js');
+        legacySessionLog({
+            philosophy: { name: 'v1', version: '1.0.0', author: 'forgen', principles: {} },
+            philosophySource: 'default',
+            scope: {
+                me: { philosophyPath: '', solutionCount: 0, ruleCount: 0 },
+                project: { path: cwd, solutionCount: 0 },
+                summary: `v1(${v1Result.session?.quality_pack ?? 'unknown'})`,
+            },
+            cwd,
+            inTmux,
+        });
+    }
+    catch { /* 세션 로그 실패는 무시 */ }
+}
+/** Step 12: write pending-compound.json if last extraction is stale. */
+function checkCompoundStaleness() {
+    try {
+        const stalenessDays = Number(process.env.FORGEN_STALENESS_DAYS ?? process.env.COMPOUND_STALENESS_DAYS) || 3;
+        const stalenessMs = stalenessDays * 24 * 60 * 60 * 1000;
+        const lastExtractionPath = path.join(STATE_DIR, 'last-extraction.json');
+        if (!fs.existsSync(lastExtractionPath))
+            return;
+        const lastExtraction = JSON.parse(fs.readFileSync(lastExtractionPath, 'utf-8'));
+        const extractedAt = lastExtraction.lastExtractedAt ?? lastExtraction.lastRunAt;
+        const lastRunMs = extractedAt ? new Date(extractedAt).getTime() : Number.NaN;
+        if (!Number.isFinite(lastRunMs))
+            return;
+        const elapsed = Date.now() - lastRunMs;
+        if (elapsed > stalenessMs) {
+            const pendingPath = path.join(STATE_DIR, 'pending-compound.json');
+            if (!fs.existsSync(pendingPath)) {
+                fs.writeFileSync(pendingPath, JSON.stringify({
+                    reason: 'staleness',
+                    detectedAt: new Date().toISOString(),
+                    daysSinceLastRun: Math.floor(elapsed / (24 * 60 * 60 * 1000)),
+                }, null, 2));
+            }
+        }
+    }
+    catch (e) {
+        log.debug('Staleness check failed (non-fatal)', e);
+    }
+}
+export async function prepareHarness(cwd) {
+    try {
+        // 0. 스토리지 마이그레이션 (v5.1: ~/.compound/ → ~/.forgen/)
+        migrateToForgen();
+        // 1. 디렉토리 구조 보장
+        ensureDirectories();
+        // 2. v1 Session Bootstrap (legacy 감지 → profile 로드 → preset 합성 → rule 렌더)
+        const v1Result = bootstrapV1Session();
+        if (v1Result.needsOnboarding) {
+            log.debug('v1: 온보딩 필요 — forgen onboarding 실행 안내');
+        }
+        if (v1Result.legacyBackupPath) {
+            log.debug(`v1: 레거시 프로필 백업 완료 → ${v1Result.legacyBackupPath}`);
+        }
+        if (v1Result.session) {
+            const { session } = v1Result;
+            log.debug(`v1 세션 시작: ${session.quality_pack}/${session.autonomy_pack}, trust=${session.effective_trust_policy}`);
+            for (const w of session.warnings) {
+                // mismatch 경고는 사용자에게 직접 표시
+                if (w.includes('mismatch')) {
+                    console.error(`[forgen] ${w}`);
+                }
+                log.debug(`v1 경고: ${w}`);
+            }
+        }
+        if (v1Result.mismatch?.quality_mismatch || v1Result.mismatch?.autonomy_mismatch) {
+            log.debug(`v1 mismatch 감지: quality=${v1Result.mismatch.quality_score}, autonomy=${v1Result.mismatch.autonomy_score}`);
+        }
+        // 3. 환경 확인
+        const inTmux = !!process.env.TMUX;
+        // 4. Claude Code 설정 주입 (환경변수 + trust 기반 permissions)
+        const env = buildEnv(cwd, v1Result.session?.session_id);
+        injectSettings(env, v1Result);
+        // 5. 에이전트 설치
+        installAgents(cwd);
+        // 6. 규칙 파일 생성 및 주입 (v1 부트스트랩 결과의 renderedRules를 직접 전달)
+        const ruleFiles = generateClaudeRuleFiles(cwd, v1Result.renderedRules);
+        injectClaudeRuleFiles(cwd, ruleFiles);
+        // 7. 슬래시 명령 설치
+        installSlashCommands(cwd);
+        // 8. tmux 바인딩 등록
+        if (inTmux) {
+            await registerTmuxBindings();
+        }
+        // 9. .gitignore 등록
+        ensureGitignore(cwd);
+        // 10. Auto memory에 compound 포인터 추가
+        ensureCompoundMemory(cwd);
+        // 11. 세션 로그 시작 (레거시 호환)
+        await startLegacySessionLog(cwd, inTmux, v1Result);
+        // 12. Compound staleness guard
+        checkCompoundStaleness();
+        return { cwd, inTmux, v1: v1Result };
+    }
+    catch (err) {
+        rollbackSettings();
+        throw err;
+    }
+}

package/dist/core/init.d.ts

@@ -0,0 +1,7 @@
+/**
+ * forgen init — v1 프로젝트 초기화
+ *
+ * 온보딩 기반 프로필 생성 + v1 디렉토리 구조 초기화.
+ * philosophy/pack 시스템은 v1에서 제거됨.
+ */
+export declare function handleInit(_args: string[]): Promise<void>;

package/dist/core/init.js

@@ -0,0 +1,37 @@
+/**
+ * forgen init — v1 프로젝트 초기화
+ *
+ * 온보딩 기반 프로필 생성 + v1 디렉토리 구조 초기화.
+ * philosophy/pack 시스템은 v1에서 제거됨.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { profileExists } from '../store/profile-store.js';
+import { ensureV1Directories } from './v1-bootstrap.js';
+// ── CLI 핸들러 ──
+export async function handleInit(_args) {
+    const cwd = process.cwd();
+    const projectName = path.basename(cwd);
+    console.log(`\n  Forgen Init — ${projectName}\n`);
+    // v1 디렉토리 생성
+    ensureV1Directories();
+    // 프로젝트 .claude/rules 디렉토리 생성
+    const rulesDir = path.join(cwd, '.claude', 'rules');
+    fs.mkdirSync(rulesDir, { recursive: true });
+    // 프로필 존재 확인
+    if (profileExists()) {
+        console.log('  Profile already exists. Your personalization is active.');
+        console.log('  Run `forgen inspect profile` to view your current settings.');
+        console.log('  Run `forgen forge --reset` to re-onboard.\n');
+        return;
+    }
+    console.log('  No profile found. Starting onboarding...\n');
+    // 온보딩 실행
+    const { runOnboarding } = await import('../forge/onboarding-cli.js');
+    await runOnboarding();
+    console.log('  Init complete!');
+    console.log('  Next steps:');
+    console.log('    forgen                     Start Claude Code with personalization');
+    console.log('    forgen inspect profile     View your profile');
+    console.log('    forgen doctor              Check system health\n');
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Forgen v1 — Inspect CLI
+ *
+ * forgen inspect profile|rules|evidence|session
+ * Authoritative: docs/plans/2026-04-03-forgen-rule-renderer-spec.md §6
+ */
+export declare function handleInspect(args: string[]): Promise<void>;