@wooojin/forgen 0.1.0

package/dist/core/types.d.ts

@@ -0,0 +1,108 @@
+export interface Principle {
+    belief: string;
+    /**
+     * generates 항목 유형:
+     * - string: 일반 텍스트 규칙
+     * - routing: 모델 라우팅 지시 (예: "explore → Sonnet, implement → Opus")
+     * - alert: 경고 메시지 (임계값 초과 시 표시)
+     * - step: 단계 설명
+     * - hook: @planned — 향후 자동 훅 등록 기능에서 사용 예정. 현재 소비자 없음.
+     */
+    generates: Array<string | {
+        hook?: string;
+        routing?: string;
+        alert?: string;
+        step?: string;
+    }>;
+}
+export interface Philosophy {
+    name: string;
+    version: string;
+    author: string;
+    description?: string;
+    /** 중앙 관리 팩에서 상속 (예: "pack:emr-standard") */
+    extends?: string;
+    principles: Record<string, Principle>;
+}
+/** 팩이 요구하는 외부 의존성 */
+export interface PackRequirement {
+    /** MCP 서버 */
+    mcpServers?: Array<{
+        name: string;
+        installCmd?: string;
+        npm?: string;
+        pip?: string;
+        description?: string;
+    }>;
+    /** CLI 도구 */
+    tools?: Array<{
+        name: string;
+        installCmd?: string;
+        description?: string;
+    }>;
+    /** 환경변수 */
+    envVars?: Array<{
+        name: string;
+        description?: string;
+        required?: boolean;
+    }>;
+}
+export interface PackMeta {
+    name: string;
+    version: string;
+    remote?: {
+        type: 'github' | 'gdrive' | 's3' | 'local';
+        url: string;
+        auto_sync?: boolean;
+    };
+    provides?: {
+        atoms?: number;
+        manuals?: number;
+        solutions?: number;
+        rules?: number;
+        skills?: number;
+        agents?: number;
+        workflows?: number;
+    };
+    /** 팩이 요구하는 외부 의존성 */
+    requires?: PackRequirement;
+}
+export interface ScopeInfo {
+    me: {
+        philosophyPath: string;
+        solutionCount: number;
+        ruleCount: number;
+    };
+    team?: {
+        name: string;
+        version: string;
+        packPath: string;
+        solutionCount: number;
+        ruleCount: number;
+        syncStatus: 'synced' | 'outdated' | 'unknown';
+    };
+    project: {
+        path: string;
+        solutionCount: number;
+    };
+    summary: string;
+}
+/** 태스크 → 추천 모델 라우팅 테이블 */
+export interface ModelRoutingTable {
+    /** Task type → recommended model */
+    routes: Record<string, 'opus' | 'sonnet' | 'haiku'>;
+}
+export interface HarnessContext {
+    philosophy: Philosophy;
+    /** 철학 로드 소스: project(프로젝트별), global(글로벌), default(기본값) */
+    philosophySource: 'project' | 'global' | 'default';
+    scope: ScopeInfo;
+    cwd: string;
+    inTmux: boolean;
+    /** Philosophy 기반 모델 라우팅 테이블 */
+    modelRouting?: Record<string, string[]>;
+    /** 신호 기반 하이브리드 라우팅 활성 여부 */
+    signalRoutingEnabled?: boolean;
+    /** 모델 라우팅 프리셋 (default, cost-saving, max-quality) */
+    routingPreset?: string;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/uninstall.d.ts

@@ -0,0 +1,4 @@
+/** forgen uninstall 메인 */
+export declare function handleUninstall(cwd: string, options: {
+    force?: boolean;
+}): Promise<void>;

package/dist/core/uninstall.js

@@ -0,0 +1,307 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as readline from 'node:readline';
+import { SETTINGS_PATH, acquireLock, releaseLock, atomicWriteFileSync, } from './settings-lock.js';
+/** 플러그인 제거 (plugin-installer.ts 삭제 후 인라인) */
+function uninstallPlugin() {
+    const pluginDir = path.join(os.homedir(), '.claude', 'plugins', 'forgen');
+    try {
+        if (fs.existsSync(pluginDir)) {
+            fs.rmSync(pluginDir, { recursive: true, force: true });
+        }
+        const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
+        if (fs.existsSync(settingsPath)) {
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (Array.isArray(settings.plugins)) {
+                settings.plugins = settings.plugins.filter(p => !p.includes('forgen'));
+                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 플러그인 관련 아티팩트 정리 */
+function cleanPluginArtifacts() {
+    const claudeDir = path.join(os.homedir(), '.claude');
+    const pluginsDir = path.join(claudeDir, 'plugins');
+    // 1. ~/.claude/plugins/cache/forgen-local/ 삭제
+    try {
+        const cacheDir = path.join(pluginsDir, 'cache', 'forgen-local');
+        if (fs.existsSync(cacheDir)) {
+            fs.rmSync(cacheDir, { recursive: true, force: true });
+            console.log('  ✓ Removed plugin cache (~/.claude/plugins/cache/forgen-local/)');
+        }
+    }
+    catch (e) {
+        console.error('  ✗ Failed to remove plugin cache:', e instanceof Error ? e.message : String(e));
+    }
+    // 2. ~/.claude/plugins/installed_plugins.json에서 forgen@forgen-local 제거
+    try {
+        const installedPluginsPath = path.join(pluginsDir, 'installed_plugins.json');
+        if (fs.existsSync(installedPluginsPath)) {
+            const data = JSON.parse(fs.readFileSync(installedPluginsPath, 'utf-8'));
+            if (data.plugins && 'forgen@forgen-local' in data.plugins) {
+                delete data.plugins['forgen@forgen-local'];
+                fs.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 2));
+                console.log('  ✓ Removed forgen@forgen-local from installed_plugins.json');
+            }
+        }
+    }
+    catch (e) {
+        console.error('  ✗ Failed to update installed_plugins.json:', e instanceof Error ? e.message : String(e));
+    }
+    // 3. ~/.claude/plugins/forgen/ 삭제 (plugin-installer 경로)
+    try {
+        const removed = uninstallPlugin();
+        if (removed) {
+            console.log('  ✓ Removed plugin directory (~/.claude/plugins/forgen/)');
+        }
+    }
+    catch (e) {
+        console.error('  ✗ Failed to remove plugin directory:', e instanceof Error ? e.message : String(e));
+    }
+}
+/** ~/.claude/commands/forgen/ 슬래시 명령 파일 제거 */
+function cleanSlashCommands() {
+    const commandsDir = path.join(os.homedir(), '.claude', 'commands', 'forgen');
+    if (!fs.existsSync(commandsDir)) {
+        console.log('  - No slash command directory found');
+        return;
+    }
+    let removed = 0;
+    for (const file of fs.readdirSync(commandsDir).filter((f) => f.endsWith('.md'))) {
+        const filePath = path.join(commandsDir, file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        if (content.includes('<!-- forgen-managed -->')) {
+            fs.unlinkSync(filePath);
+            removed++;
+        }
+    }
+    // 디렉토리가 비었으면 삭제
+    try {
+        const remaining = fs.readdirSync(commandsDir);
+        if (remaining.length === 0) {
+            fs.rmdirSync(commandsDir);
+        }
+    }
+    catch { /* ignore */ }
+    if (removed > 0) {
+        console.log(`  ✓ Removed ${removed} slash command(s) (~/.claude/commands/forgen/)`);
+    }
+    else {
+        console.log('  - No forgen-managed slash commands found');
+    }
+}
+/** 사용자에게 y/n 확인 */
+function confirm(message) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${message} (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+/** settings.json에서 CH 관련 항목 제거 */
+function cleanSettings() {
+    if (!fs.existsSync(SETTINGS_PATH))
+        return;
+    let settings;
+    try {
+        settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, 'utf-8'));
+    }
+    catch {
+        console.error('[forgen] Failed to parse settings.json — skipping.');
+        return;
+    }
+    // env에서 COMPOUND_ 접두어 키 제거
+    const env = settings.env;
+    if (env) {
+        for (const key of Object.keys(env)) {
+            if (key.startsWith('COMPOUND_'))
+                delete env[key];
+        }
+        if (Object.keys(env).length === 0) {
+            delete settings.env;
+        }
+    }
+    // hooks에서 forgen 관련 엔트리 제거
+    const hookMarkers = ['forgen', 'compound-harness'];
+    function isCHCommand(cmd) {
+        return hookMarkers.some(m => cmd.includes(m));
+    }
+    function isCHHookEntry(entry) {
+        // 직접 형식: { type, command }
+        if (typeof entry.command === 'string' && isCHCommand(entry.command))
+            return true;
+        // 래핑 형식: { matcher, hooks: [{ command }] }
+        const innerHooks = entry.hooks;
+        if (Array.isArray(innerHooks)) {
+            return innerHooks.some(h => typeof h.command === 'string' && isCHCommand(h.command));
+        }
+        return false;
+    }
+    const hooks = settings.hooks;
+    if (hooks) {
+        for (const [hookType, entries] of Object.entries(hooks)) {
+            if (!Array.isArray(entries))
+                continue;
+            const filtered = entries.filter((h) => !isCHHookEntry(h));
+            if (filtered.length === 0) {
+                delete hooks[hookType];
+            }
+            else {
+                hooks[hookType] = filtered;
+            }
+        }
+        if (Object.keys(hooks).length === 0) {
+            delete settings.hooks;
+        }
+    }
+    // statusLine이 forgen status면 제거
+    const statusLine = settings.statusLine;
+    if (statusLine?.command === 'forgen status') {
+        delete settings.statusLine;
+    }
+    // enabledPlugins에서 forgen@forgen-local 제거
+    const enabledPlugins = settings.enabledPlugins;
+    if (enabledPlugins && 'forgen@forgen-local' in enabledPlugins) {
+        delete enabledPlugins['forgen@forgen-local'];
+        if (Object.keys(enabledPlugins).length === 0) {
+            delete settings.enabledPlugins;
+        }
+    }
+    // mcpServers에서 forgen-compound 제거
+    const mcpServers = settings.mcpServers;
+    if (mcpServers && 'forgen-compound' in mcpServers) {
+        delete mcpServers['forgen-compound'];
+        if (Object.keys(mcpServers).length === 0) {
+            delete settings.mcpServers;
+        }
+    }
+    acquireLock();
+    try {
+        atomicWriteFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    }
+    finally {
+        releaseLock();
+    }
+    console.log('  ✓ Removed CH entries from settings.json');
+}
+/** 프로젝트 .claude/agents/ch-*.md 삭제 (커스터마이즈된 파일은 보호) */
+function cleanAgents(cwd) {
+    const agentsDir = path.join(cwd, '.claude', 'agents');
+    if (!fs.existsSync(agentsDir))
+        return;
+    let removed = 0;
+    let preserved = 0;
+    for (const file of fs.readdirSync(agentsDir)) {
+        if (file.startsWith('ch-') && file.endsWith('.md')) {
+            const filePath = path.join(agentsDir, file);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            if (!content.includes('<!-- forgen-managed -->')) {
+                // 사용자가 커스터마이즈한 파일 → 보존
+                preserved++;
+                continue;
+            }
+            fs.unlinkSync(filePath);
+            removed++;
+        }
+    }
+    if (removed > 0) {
+        console.log(`  ✓ Removed ${removed} agent file(s) (.claude/agents/ch-*.md)`);
+    }
+    if (preserved > 0) {
+        console.log(`  ⚠ Preserved ${preserved} customized agent file(s) (manual deletion required)`);
+    }
+    if (removed === 0 && preserved === 0) {
+        console.log('  - No agent files found');
+    }
+}
+/** .claude/rules/ 의 forgen 규칙 파일 및 레거시 compound-rules.md 제거 */
+function cleanCompoundRules(cwd) {
+    const ruleFiles = [
+        // v4.1+ consolidated
+        'project-context.md',
+        'routing.md',
+        // legacy (v4.0 and earlier)
+        'security.md',
+        'golden-principles.md',
+        'anti-pattern.md',
+        'compound.md',
+    ];
+    const rulesDir = path.join(cwd, '.claude', 'rules');
+    let removedCount = 0;
+    for (const file of ruleFiles) {
+        const p = path.join(rulesDir, file);
+        if (fs.existsSync(p)) {
+            fs.unlinkSync(p);
+            removedCount++;
+        }
+    }
+    // 레거시 경로
+    const legacyPath = path.join(cwd, '.claude', 'compound-rules.md');
+    if (fs.existsSync(legacyPath)) {
+        fs.unlinkSync(legacyPath);
+        removedCount++;
+    }
+    if (removedCount > 0) {
+        console.log(`  ✓ Removed ${removedCount} rule file(s)`);
+    }
+    else {
+        console.log('  - No rule files found');
+    }
+}
+/** CLAUDE.md에서 forgen 블록 제거 */
+function cleanClaudeMd(cwd) {
+    const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+    if (!fs.existsSync(claudeMdPath))
+        return;
+    const content = fs.readFileSync(claudeMdPath, 'utf-8');
+    const marker = '<!-- forgen:start -->';
+    const endMarker = '<!-- forgen:end -->';
+    if (!content.includes(marker)) {
+        console.log('  - No CH block found in CLAUDE.md');
+        return;
+    }
+    const regex = new RegExp(`\\n?${marker}[\\s\\S]*?${endMarker}\\n?`, 'g');
+    const cleaned = content.replace(regex, '\n');
+    fs.writeFileSync(claudeMdPath, `${cleaned.replace(/\n{3,}/g, '\n\n').trim()}\n`);
+    console.log('  ✓ Removed CH block from CLAUDE.md');
+}
+/** forgen uninstall 메인 */
+export async function handleUninstall(cwd, options) {
+    console.log('\n[forgen] Uninstalling Forgen\n');
+    console.log('The following items will be cleaned up:');
+    console.log('  1. Remove CH env vars/hooks/statusLine/enabledPlugins from ~/.claude/settings.json');
+    console.log('  2. Delete .claude/agents/ch-*.md agent files');
+    console.log('  3. Delete .claude/rules/ rule files (project-context, routing, forge-*)');
+    console.log('  4. Remove forgen block from CLAUDE.md');
+    console.log('  5. Remove slash commands (~/.claude/commands/forgen/)');
+    console.log('  6. Remove plugin artifacts (cache, installed_plugins.json, plugin directory)');
+    console.log('');
+    console.log('Note: ~/.forgen/ directory is preserved (manual deletion: rm -rf ~/.forgen)\n');
+    if (!options.force) {
+        if (!process.stdin.isTTY) {
+            console.error('[forgen] Use --force flag in non-interactive environments.');
+            process.exit(1);
+        }
+        const ok = await confirm('Do you want to continue?');
+        if (!ok) {
+            console.log('Cancelled.');
+            return;
+        }
+        console.log('');
+    }
+    cleanSettings();
+    cleanAgents(cwd);
+    cleanCompoundRules(cwd);
+    cleanClaudeMd(cwd);
+    cleanSlashCommands();
+    cleanPluginArtifacts();
+    console.log('\n[forgen] Uninstall complete. Restart Claude Code for a clean state.\n');
+}

package/dist/core/v1-bootstrap.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Forgen v1 — Session Bootstrap
+ *
+ * v1 설계의 세션 시작 흐름을 구현.
+ * Authoritative: docs/plans/2026-04-03-forgen-lifecycle-design.md §6
+ *               docs/plans/2026-04-03-forgen-component-interface-design.md §4
+ *
+ * 흐름:
+ * 1. Legacy 감지 → cutover 필요 시 backup + fresh onboarding
+ * 2. Profile 로드 (없으면 onboarding 필요)
+ * 3. Runtime capability 감지
+ * 4. Preset Manager가 SessionEffectiveState 합성
+ * 5. Rule Renderer가 자연어 규칙 세트 생성
+ */
+import { type MismatchResult } from '../forge/mismatch-detector.js';
+import type { SessionEffectiveState, Profile } from '../store/types.js';
+export declare function ensureV1Directories(): void;
+export interface V1BootstrapResult {
+    needsOnboarding: boolean;
+    legacyBackupPath: string | null;
+    session: SessionEffectiveState | null;
+    renderedRules: string | null;
+    profile: Profile | null;
+    mismatch: MismatchResult | null;
+}
+export declare function bootstrapV1Session(): V1BootstrapResult;

package/dist/core/v1-bootstrap.js

@@ -0,0 +1,155 @@
+/**
+ * Forgen v1 — Session Bootstrap
+ *
+ * v1 설계의 세션 시작 흐름을 구현.
+ * Authoritative: docs/plans/2026-04-03-forgen-lifecycle-design.md §6
+ *               docs/plans/2026-04-03-forgen-component-interface-design.md §4
+ *
+ * 흐름:
+ * 1. Legacy 감지 → cutover 필요 시 backup + fresh onboarding
+ * 2. Profile 로드 (없으면 onboarding 필요)
+ * 3. Runtime capability 감지
+ * 4. Preset Manager가 SessionEffectiveState 합성
+ * 5. Rule Renderer가 자연어 규칙 세트 생성
+ */
+import * as fs from 'node:fs';
+import * as crypto from 'node:crypto';
+import { FORGEN_HOME, V1_ME_DIR, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_SESSIONS_DIR, V1_STATE_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR } from './paths.js';
+import { checkLegacyProfile, runLegacyCutover } from './legacy-detector.js';
+import { detectRuntimeCapability } from './runtime-detector.js';
+import { loadProfile, profileExists } from '../store/profile-store.js';
+import { loadActiveRules } from '../store/rule-store.js';
+import { composeSession } from '../preset/preset-manager.js';
+import { renderRules, DEFAULT_CONTEXT } from '../renderer/rule-renderer.js';
+import { saveSessionState, loadRecentSessions } from '../store/session-state-store.js';
+import { loadEvidenceBySession } from '../store/evidence-store.js';
+import { computeSessionSignals, detectMismatch } from '../forge/mismatch-detector.js';
+import { createRecommendation, saveRecommendation } from '../store/recommendation-store.js';
+// ── Directory Initialization ──
+const V1_DIRS = [FORGEN_HOME, V1_ME_DIR, V1_RULES_DIR, V1_EVIDENCE_DIR, V1_RECOMMENDATIONS_DIR, V1_STATE_DIR, V1_SESSIONS_DIR, V1_RAW_LOGS_DIR, V1_SOLUTIONS_DIR];
+export function ensureV1Directories() {
+    for (const dir of V1_DIRS) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+// ── Main Bootstrap ──
+export function bootstrapV1Session() {
+    // 0. 디렉토리 준비
+    ensureV1Directories();
+    // 1. Legacy 감지
+    const legacyCheck = checkLegacyProfile();
+    let legacyBackupPath = null;
+    if (legacyCheck.isLegacy) {
+        legacyBackupPath = runLegacyCutover();
+    }
+    // 2. Profile 로드
+    if (!profileExists()) {
+        return {
+            needsOnboarding: true,
+            legacyBackupPath,
+            session: null,
+            renderedRules: null,
+            profile: null,
+            mismatch: null,
+        };
+    }
+    const profile = loadProfile();
+    if (!profile) {
+        return { needsOnboarding: true, legacyBackupPath, session: null, renderedRules: null, profile: null, mismatch: null };
+    }
+    // 3. Runtime capability 감지
+    const runtime = detectRuntimeCapability();
+    // 4. Rules 로드 + Session 합성
+    const personalRules = loadActiveRules();
+    const sessionId = crypto.randomUUID();
+    const session = composeSession({
+        session_id: sessionId,
+        profile,
+        personalRules,
+        sessionOverlays: [],
+        runtime,
+    });
+    // 5. Session state 저장
+    saveSessionState(session);
+    // 6. Rule 렌더링
+    const allRules = [...personalRules];
+    const renderedRules = renderRules(allRules, session, profile, DEFAULT_CONTEXT);
+    // 7. Mismatch 감지 (최근 3세션 rolling)
+    let mismatchResult = null;
+    try {
+        const recentSessions = loadRecentSessions(3);
+        if (recentSessions.length >= 2) {
+            const allSignals = [];
+            for (const prevSession of recentSessions) {
+                const sessionEvidence = loadEvidenceBySession(prevSession.session_id);
+                const corrections = sessionEvidence.filter(e => e.type === 'explicit_correction');
+                const summaries = sessionEvidence.filter(e => e.type === 'session_summary');
+                const strongRules = personalRules.filter(r => r.strength === 'strong' && r.evidence_refs.some(ref => sessionEvidence.some(e => e.evidence_id === ref)));
+                const signals = computeSessionSignals(prevSession.session_id, corrections, summaries, strongRules, profile.base_packs.quality_pack, profile.base_packs.autonomy_pack);
+                allSignals.push(...signals);
+            }
+            if (allSignals.length > 0) {
+                mismatchResult = detectMismatch(allSignals);
+                // mismatch 감지 시 재추천 생성
+                if (mismatchResult.quality_mismatch || mismatchResult.autonomy_mismatch) {
+                    session.warnings.push(`Pack mismatch 감지: quality=${mismatchResult.quality_score}, autonomy=${mismatchResult.autonomy_score}. forgen forge --reset soft 로 재설정하거나 forgen onboarding 으로 재추천을 받으세요.`);
+                    const rec = createRecommendation({
+                        source: 'mismatch_recommendation',
+                        quality_pack: mismatchResult.quality_mismatch
+                            ? (profile.base_packs.quality_pack === '보수형' ? '속도형' : '보수형')
+                            : profile.base_packs.quality_pack,
+                        autonomy_pack: mismatchResult.autonomy_mismatch
+                            ? (profile.base_packs.autonomy_pack === '확인 우선형' ? '자율 실행형' : '확인 우선형')
+                            : profile.base_packs.autonomy_pack,
+                        suggested_trust_policy: profile.trust_preferences.desired_policy,
+                        confidence: 0.6,
+                        reason_summary: `Rolling 3세션 mismatch: quality=${mismatchResult.quality_score}, autonomy=${mismatchResult.autonomy_score}`,
+                    });
+                    saveRecommendation(rec);
+                }
+            }
+        }
+    }
+    catch {
+        // mismatch 감지 실패는 세션 시작을 막지 않음
+    }
+    // 8. Raw Log 기록 + TTL sweep (7일)
+    try {
+        // 세션 시작 로그
+        const rawLogPath = require('node:path').join(V1_RAW_LOGS_DIR, `${sessionId}.jsonl`);
+        fs.appendFileSync(rawLogPath, JSON.stringify({
+            event: 'session-started',
+            session_id: sessionId,
+            timestamp: new Date().toISOString(),
+            quality_pack: profile.base_packs.quality_pack,
+            autonomy_pack: profile.base_packs.autonomy_pack,
+            judgment_pack: profile.base_packs.judgment_pack,
+            communication_pack: profile.base_packs.communication_pack,
+            effective_trust: session.effective_trust_policy,
+        }) + '\n');
+        // TTL sweep: 7일 이상 된 raw log 파일 삭제
+        const TTL_MS = 7 * 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        for (const file of fs.readdirSync(V1_RAW_LOGS_DIR)) {
+            const filePath = require('node:path').join(V1_RAW_LOGS_DIR, file);
+            try {
+                const stat = fs.statSync(filePath);
+                if (now - stat.mtimeMs > TTL_MS) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch {
+        // raw log 실패는 세션 시작을 막지 않음
+    }
+    return {
+        needsOnboarding: false,
+        legacyBackupPath,
+        session,
+        renderedRules,
+        profile,
+        mismatch: mismatchResult,
+    };
+}

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

@@ -0,0 +1,24 @@
+/** List all solutions with status summary */
+export declare function listSolutions(): void;
+/** Inspect a single saved entry in detail */
+export declare function inspectSolution(name: string): void;
+/** Remove a saved entry by name */
+export declare function removeSolution(name: string): void;
+/**
+ * Retire solutions whose names match extractors that have been removed
+ * from the compound pipeline. Retired solutions are excluded from the
+ * index (see `solution-index.ts:142`) so they stop being surfaced in
+ * MCP search and hook injection, but the file stays on disk for
+ * audit / undo purposes.
+ *
+ * M-3 (2026-04-09): the C4 extractor cleanup left orphaned files in
+ * users' `~/.forgen/me/solutions/` directories. Without this migration,
+ * files like `recurring-task-pattern.md` (which had injected=113 on
+ * the author's own machine at fix time) continue to pollute matching
+ * results until the user manually deletes them.
+ */
+export declare function cleanStaleSolutions(): void;
+/** Retag all solutions using improved extractTags */
+export declare function retagSolutions(): void;
+/** Rollback auto-extracted solutions since a given date */
+export declare function rollbackSolutions(sinceDate: string): void;