@wooojin/forgen 0.1.0

package/dist/core/config-injector.js

@@ -0,0 +1,455 @@
+/**
+ * Forgen v1 — Config Injector
+ *
+ * v1 설계: Rule Renderer + Profile 기반 규칙 생성.
+ * philosophy/scope/pack ��반 직접 규칙 생성은 제거됨.
+ *
+ * Authoritative: docs/plans/2026-04-03-forgen-rule-renderer-spec.md
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_BEHAVIOR, ME_DIR, ME_RULES } from './paths.js';
+import { createLogger } from './logger.js';
+import { parseSolutionV3 } from '../engine/solution-format.js';
+import { containsPromptInjection } from '../hooks/prompt-injection-filter.js';
+import { RULE_FILE_CAPS, truncateContent } from '../hooks/shared/injection-caps.js';
+const log = createLogger('config-injector');
+/**
+ * 디렉토리의 .md 파일에서 규칙 첫 줄(요약)을 추출.
+ * trusted=false일 때 프롬프트 인젝션 스캔 적용.
+ */
+function loadRulesFromDir(dir, trusted = true) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs.readdirSync(dir)
+            .filter(f => f.endsWith('.md'))
+            .map(f => {
+            const filePath = path.join(dir, f);
+            if (fs.lstatSync(filePath).isSymbolicLink())
+                return null;
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const parsed = parseSolutionV3(content);
+            const body = parsed ? parsed.content : stripFrontmatter(content);
+            if (!trusted) {
+                if (containsPromptInjection(body)) {
+                    log.debug(`규칙 파일 인젝션 감지 — 차단: ${filePath}`);
+                    return null;
+                }
+            }
+            const firstLine = firstMeaningfulLine(body);
+            return firstLine ?? f.replace('.md', '');
+        })
+            .filter((rule) => Boolean(rule));
+    }
+    catch (e) {
+        log.debug(`규칙 디렉토리 읽기 실패: ${dir}`, e);
+        return [];
+    }
+}
+function stripFrontmatter(content) {
+    const trimmed = content.trimStart();
+    if (!trimmed.startsWith('---'))
+        return content;
+    const endIdx = trimmed.indexOf('---', 3);
+    if (endIdx === -1)
+        return content;
+    return trimmed.slice(endIdx + 3);
+}
+function firstMeaningfulLine(content) {
+    for (const rawLine of content.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (line === '## Context' || line === '## Content')
+            continue;
+        return line.replace(/^#+\s*/, '').trim();
+    }
+    return null;
+}
+/** 프로젝트 맵에서 에이전트용 요약 생성 */
+function loadProjectMapSummary(cwd) {
+    const mapPath = path.join(cwd, '.compound', 'project-map.json');
+    if (!fs.existsSync(mapPath))
+        return null;
+    try {
+        const map = JSON.parse(fs.readFileSync(mapPath, 'utf-8'));
+        const { summary } = map;
+        const lines = [];
+        lines.push(`- Project: ${summary.name} (${summary.totalFiles} files, ${summary.totalLines.toLocaleString()} lines)`);
+        if (summary.framework)
+            lines.push(`- Framework: ${summary.framework}`);
+        if (summary.packageManager)
+            lines.push(`- Package manager: ${summary.packageManager}`);
+        const topLangs = Object.entries(summary.languages)
+            .sort((a, b) => b[1] - a[1])
+            .filter(([l]) => l !== 'other')
+            .slice(0, 3);
+        if (topLangs.length > 0) {
+            lines.push(`- Languages: ${topLangs.map(([l, n]) => `${l}(${n} lines)`).join(', ')}`);
+        }
+        if (map.entryPoints.length > 0) {
+            lines.push(`- Entry points: ${map.entryPoints.slice(0, 5).join(', ')}`);
+        }
+        const topDirs = map.directories
+            .filter(d => d.purpose && !d.path.includes('/'))
+            .slice(0, 8);
+        if (topDirs.length > 0) {
+            lines.push('- Directories:');
+            for (const dir of topDirs) {
+                lines.push(`  - \`${dir.path}/\` — ${dir.purpose}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    catch {
+        return null;
+    }
+}
+// ── v1 Static Rules ──
+/** 보안 규칙 (정적 — v1 GLOBAL_SAFETY_RULES와 동일 맥락) */
+export function generateSecurityRules() {
+    return [
+        '# Forgen — Security Rules',
+        '',
+        '## Dangerous Command Warning',
+        '- Always confirm before executing destructive commands like `rm -rf`, `git push --force`, `DROP TABLE`',
+        '- Double confirmation required for production environment access',
+        '',
+        '## Secret Key Protection',
+        '- Do not commit sensitive information such as `.env`, `credentials.json`, API keys',
+        '- Manage through environment variables or a secrets manager',
+        '- Detect hardcoded secrets during code review',
+        '',
+    ].join('\n');
+}
+/** 안티패턴 감지 규칙 (정적) */
+export function generateAntiPatternRules() {
+    return [
+        '# Forgen — Anti-Pattern Detection',
+        '',
+        '## Repeated Edit Warning',
+        '- Stop immediately when editing the same file 3+ times → full structure redesign required',
+        '- For 5+ edits, always check current state with Read before replacing with a single Write',
+        '',
+        '## Error Suppression Warning',
+        '- No empty catch blocks — at minimum log or re-throw',
+        '- Minimize suppression comments like eslint-disable, @ts-ignore',
+        '',
+        '## Excessive Complexity Warning',
+        '- Consider splitting single functions exceeding 50 lines',
+        '- Apply early return pattern when nesting depth exceeds 4',
+        '- No unnecessary abstraction — implement only what is currently needed',
+        '',
+    ].join('\n');
+}
+/** compound loop + 개인 규칙 (me/rules) 로드 */
+export function generateCompoundRules(cwd) {
+    const lines = [
+        '# Forgen — Compound Loop',
+        '',
+    ];
+    // 프로젝트 맵 요약 주입
+    const mapSummary = loadProjectMapSummary(cwd);
+    if (mapSummary) {
+        lines.push('## Project Structure (auto-generated)');
+        lines.push(mapSummary);
+        lines.push('');
+    }
+    // 개인 규칙 로드
+    //
+    // B7 security hardening (2026-04-09): ME_RULES is user-owned but still
+    // writable by any process the user runs (including auto-compound and
+    // skill-injector). An attacker who can write a single file into
+    // `~/.forgen/me/rules/` via a crafted prompt/skill promotion can
+    // inject instructions into every Claude session. Run the same
+    // injection filter the behavior directory already uses for
+    // consistency. The previous `trusted=true` default was safe only
+    // under the assumption that ME_RULES was exclusively human-authored,
+    // which isn't the case in practice.
+    const meRules = loadRulesFromDir(ME_RULES, false);
+    if (meRules.length > 0) {
+        lines.push('## Personal Rules (Me)');
+        for (const rule of meRules) {
+            lines.push(`- ${rule}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Phrases that indicate a "pattern" is actually echoing a Claude response
+ * rather than a genuine user-behavior signal. Observed in production:
+ * auto-compound was picking up snippets of its own output ("다음 대화에서
+ * 분석하겠습니다", "3개 패턴을 메모리에 추가했습니다", "Step 1 완료") and
+ * treating them as learned user patterns.
+ *
+ * C5 fix (2026-04-09): filter these at render time so they never reach
+ * `~/.claude/rules/forge-behavioral.md`. The source files under
+ * `~/.forgen/me/behavior/` are left in place — this is a display-time
+ * filter, not a data-mutation step, so a bad filter regex here can't
+ * destroy legitimate history.
+ *
+ * Anchoring rules (H-2 fix):
+ *   1. Every regex is either START-anchored (`^`) or requires a narrow
+ *      prefix context. A bare `/분석하겠습니다/` would false-positive on
+ *      a legit user pattern like "관련 문서를 분석하겠습니다" (the user
+ *      stating their preference to analyze docs). Anchoring prevents
+ *      this by requiring the phrase to be the *beginning* of the line,
+ *      which is the actual Claude-response failure mode.
+ *   2. Self-reference to the tool itself (`forgen`/`compound`) is
+ *      narrowed to meta-announcement shapes like "N개 패턴을 …에 추가"
+ *      — a legit user rule like "use compound when refactoring" is
+ *      NOT filtered. The earlier bare `/forgen|compound/i` would have
+ *      dropped any user pattern that happened to name the tool.
+ *   3. English Claude-response templates are covered too. Auto-compound
+ *      will eventually process mixed-language transcripts and the
+ *      filter must catch English leakage as well as Korean.
+ */
+const SELF_REFERENTIAL_PATTERNS = Object.freeze([
+    // Korean — Claude-voice announcements at line start.
+    // Note: we deliberately DO NOT filter bare `/분석하겠습니다/` because
+    // a user rule like "관련 문서를 분석하겠습니다" is a legitimate
+    // user-voice statement. The "다음/이번/현재 (대화|세션|작업)에서"
+    // prefix + "분석하겠습니다" suffix is Claude-voice; the prefix alone
+    // is enough of a discriminator.
+    /^관찰된 새로운 패턴 없습니다/,
+    /^\d+개 패턴을.*(메모리|compound|forgen).*(추가|기록)/,
+    /^계획이 진행 중/,
+    /^(다음|이번|현재) (대화|세션|작업)에서/,
+    /^Step \d/,
+    // Claude permission/proceed flow markers — observed in auto-captured
+    // behavior file `auto-2026-04-07-preference.md`. These are specific
+    // Korean phrases an assistant uses when asking the user to approve
+    // an action. A user writing their own preference would not phrase
+    // it as "승인하면 다음을 확인합니다" or end with "진행할까요?".
+    /권한\s*(확인|요청)이?\s*필요합니다/,
+    /^승인하(면|시면)/,
+    /진행할까요\??/,
+    // English — Claude response templates at line start.
+    /^I['\u2019]?ll\s+(analyze|review|check|update|add|create|run|fix)/i,
+    /^Let me\s+(analyze|check|look|verify|update|add)/i,
+    /^I['\u2019]?ve\s+(added|updated|created|fixed|completed)/i,
+    // Object.freeze is defense-in-depth: the readonly type is compile-time
+    // only. Freezing prevents runtime mutation by any other module loaded
+    // in the same process from silently disabling the filter by pushing
+    // an over-broad pattern or emptying the array.
+]);
+/**
+ * Strip formatting that already exists in the source line BEFORE the
+ * renderer adds its own prefix/suffix. Without this, a behavior file
+ * whose content begins with `- **[의사결정]** ... (3회 관찰)` ends up
+ * rendered as `- - **[의사결정]** ... (3회 관찰) (1회 관찰)` — double
+ * bullet + double count observed in production.
+ *
+ * Exported under `__testOnly` below for C5 regression coverage.
+ */
+function normalizeDescription(raw) {
+    let desc = raw.trim();
+    // Strip any number of leading bullet markers: `- `, `* `, `• `
+    desc = desc.replace(/^(?:[-*•]\s+)+/, '');
+    // Strip trailing inline "N회 관찰" suffixes (can be chained from
+    // earlier render passes). Note the space before the paren.
+    desc = desc.replace(/(?:\s*\(\d+회 관찰\))+$/, '');
+    return desc.trim();
+}
+/**
+ * 학습된 선호/사고 패턴을 규칙으로 변환.
+ */
+function generateBehavioralRules() {
+    const lines = ['# Forgen — Learned Patterns', '# auto-generated from observed interactions', ''];
+    try {
+        if (!fs.existsSync(ME_BEHAVIOR))
+            return lines.join('\n');
+        const files = fs.readdirSync(ME_BEHAVIOR).filter(f => f.endsWith('.md'));
+        const categories = {
+            'Thinking Style': [],
+            'Response Preferences': [],
+            'Workflow': [],
+        };
+        for (const file of files) {
+            const filePath = path.join(ME_BEHAVIOR, file);
+            if (fs.lstatSync(filePath).isSymbolicLink())
+                continue;
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const trimmed = raw.trimStart();
+            if (!trimmed.startsWith('---'))
+                continue;
+            const endIdx = trimmed.indexOf('---', 3);
+            if (endIdx === -1)
+                continue;
+            const fm = trimmed.slice(3, endIdx);
+            const body = trimmed.slice(endIdx + 3).trim();
+            const kindMatch = fm.match(/^kind:\s*(.+)$/m);
+            const countMatch = fm.match(/^observedCount:\s*(\d+)/m);
+            const kind = kindMatch?.[1]?.trim().replace(/^["']|["']$/g, '') ?? '';
+            const observedCount = countMatch ? parseInt(countMatch[1], 10) : 0;
+            const contentIdx = body.indexOf('## Content');
+            const contentBody = contentIdx >= 0 ? body.slice(contentIdx + '## Content'.length) : body;
+            const rawDesc = contentBody.split('\n').find(l => {
+                const t = l.trim();
+                return t.length >= 5 && !t.startsWith('##');
+            });
+            if (!rawDesc)
+                continue;
+            // C5: strip any pre-existing bullet/count formatting so we don't
+            // stack `- -` and `(3회 관찰) (1회 관찰)` on re-render.
+            const desc = normalizeDescription(rawDesc);
+            if (desc.length < 5)
+                continue;
+            // C5 edge case (2026-04-09): if the description text already
+            // contains an inline "N회 관찰" marker ANYWHERE (not just at the
+            // trailing-suffix position normalizeDescription strips), don't
+            // append another count from frontmatter. Observed data: source
+            // files like `auto-2026-04-02.md` have descriptions ending in
+            // `(compound-engineering-plugin, ohmyopencode 등과 반복 비교 요청 — 3회 관찰)`,
+            // where the `3회 관찰` is embedded inside a long parenthetical —
+            // normalizeDescription's tail regex can't strip it because the
+            // outer paren is not right before the count. Without this check,
+            // the renderer appends its own `(1회 관찰)` (from frontmatter
+            // observedCount) and produces `... 3회 관찰) (1회 관찰)`.
+            const hasInlineCount = /\d+회 관찰/.test(desc);
+            // C5: filter self-referential noise (Claude's own responses
+            // captured as "user patterns").
+            if (SELF_REFERENTIAL_PATTERNS.some(re => re.test(desc)))
+                continue;
+            // C5 security hardening (MEDIUM-1 from review): reject any
+            // behavior-file content that looks like a prompt injection
+            // payload. `generateCompoundRules`'s `loadRulesFromDir` already
+            // runs this check with `trusted=false` — this mirrors it for
+            // the auto-compound-populated behavior directory, which is a
+            // higher-risk input source because payloads can be injected
+            // indirectly via transcripts/commit messages that auto-compound
+            // observes. Without this filter, a crafted user prompt could
+            // cause a malicious instruction to be written into
+            // `forge-behavioral.md` and re-injected on every session.
+            if (containsPromptInjection(desc))
+                continue;
+            const countStr = observedCount > 0 && !hasInlineCount
+                ? ` (${observedCount}회 관찰)`
+                : '';
+            if (kind === 'thinking') {
+                categories['Thinking Style'].push(`- ${desc}${countStr}`);
+            }
+            else if (kind === 'workflow') {
+                // observedCount >= 3인 워크플로우는 directive 형태로 렌더링
+                if (observedCount >= 3) {
+                    categories.Workflow.push(`- **[적용]** ${desc}${countStr}`);
+                }
+                else {
+                    categories.Workflow.push(`- ${desc}${countStr}`);
+                }
+            }
+            else if (kind === 'preference') {
+                categories['Response Preferences'].push(`- ${desc}${countStr}`);
+            }
+        }
+        for (const [cat, items] of Object.entries(categories)) {
+            if (items.length === 0)
+                continue;
+            lines.push(`## ${cat}`);
+            if (cat === 'Workflow') {
+                lines.push('> Items marked **[적용]** are confirmed patterns (3+ observations). Follow these as default workflow unless the user overrides.');
+            }
+            lines.push(...items);
+            lines.push('');
+        }
+    }
+    catch {
+        // 행동 디렉토리 접근 실패 시 빈 규칙
+    }
+    return lines.length <= 3 ? '' : lines.join('\n');
+}
+/** 모든 규칙 파일을 생성하여 반환. v1RenderedRules가 있으면 포함. */
+export function generateClaudeRuleFiles(cwd, v1RenderedRules) {
+    const v1Rules = v1RenderedRules
+        ? `# Forgen v1 — Rendered Rules\n# auto-generated from profile + rule store\n\n${v1RenderedRules}`
+        : null;
+    // 정적 규칙 + compound
+    const coreSections = [
+        generateSecurityRules(),
+        generateAntiPatternRules(),
+        generateCompoundRules(cwd),
+    ].filter(s => s.trim().length > 0);
+    const rules = {
+        'project-context.md': coreSections.join('\n\n---\n\n'),
+    };
+    // v1 rendered rules (profile 기반 개인화 규칙)
+    if (v1Rules) {
+        rules['v1-rules.md'] = v1Rules;
+    }
+    // 학습된 행동 패턴
+    const behavioral = generateBehavioralRules();
+    if (behavioral) {
+        rules['forge-behavioral.md'] = behavioral;
+    }
+    // USER.md → 사용자 프로필 주입
+    const userMdPath = path.join(ME_DIR, 'USER.md');
+    try {
+        if (fs.existsSync(userMdPath) && !fs.lstatSync(userMdPath).isSymbolicLink()) {
+            const raw = fs.readFileSync(userMdPath, 'utf-8').trim();
+            if (raw.length > 0) {
+                const truncated = truncateContent(raw, RULE_FILE_CAPS.perRuleFile);
+                rules['user-profile.md'] = [
+                    '# Forgen — User Profile',
+                    '# auto-injected from ~/.forgen/me/USER.md',
+                    '',
+                    truncated,
+                    '',
+                ].join('\n');
+            }
+        }
+    }
+    catch (e) {
+        log.debug('USER.md 로드 실���', e);
+    }
+    return rules;
+}
+/** 하위 호환: 단일 규칙 문자열 생성 */
+export function generateClaudeRules(cwd, v1RenderedRules) {
+    const files = generateClaudeRuleFiles(cwd, v1RenderedRules);
+    return Object.values(files).join('\n');
+}
+/** tmux 키바인딩 등록 */
+export async function registerTmuxBindings() {
+    const { execFileSync } = await import('node:child_process');
+    try {
+        execFileSync('tmux', ['bind-key', 'T', 'run-shell', 'forgen me'], { stdio: 'ignore' });
+    }
+    catch (e) {
+        log.debug('tmux 키바인딩 등��� 실패', e);
+    }
+}
+/**
+ * B10 (2026-04-09): environment variables for the harness context.
+ *
+ * The canonical namespace is now `FORGEN_*`. The legacy `COMPOUND_*`
+ * names are set alongside for one transition period (third-party hooks
+ * or user scripts may still read them). When all consumers have been
+ * migrated and a major version ships, remove the `COMPOUND_*` lines.
+ */
+export function buildEnv(cwd, v1SessionId) {
+    const env = {
+        // New canonical names
+        FORGEN_HARNESS: '1',
+        FORGEN_CWD: cwd,
+        FORGEN_V1: '1',
+        // Legacy compat (remove in next major)
+        COMPOUND_HARNESS: '1',
+        COMPOUND_CWD: cwd,
+    };
+    if (v1SessionId) {
+        env.FORGEN_SESSION_ID = v1SessionId;
+    }
+    return env;
+}
+/**
+ * Test-only exports for the C5 rendering pipeline. The ergonomic choice
+ * over `export function normalizeDescription` is intentional: anything
+ * reached via `__testOnly` is explicitly flagged as "not for production
+ * callers" and easy to grep for in future refactors.
+ */
+export const __testOnly = {
+    normalizeDescription,
+    SELF_REFERENTIAL_PATTERNS,
+};

package/dist/core/doctor.d.ts

@@ -0,0 +1 @@
+export declare function runDoctor(): Promise<void>;

package/dist/core/doctor.js

@@ -0,0 +1,163 @@
+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 } from './paths.js';
+/** ~/.claude/projects/ — Claude Code 세션 저장 경로 */
+const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
+function check(label, condition, hint) {
+    const icon = condition ? '✓' : '✗';
+    const hintStr = !condition && hint ? ` — ${hint}` : '';
+    console.log(`  ${icon} ${label}${hintStr}`);
+}
+function exists(p) {
+    return fs.existsSync(p);
+}
+function commandExists(cmd) {
+    try {
+        const checker = process.platform === 'win32' ? 'where' : 'which';
+        execFileSync(checker, [cmd], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runDoctor() {
+    console.log('\n  Forgen — Diagnostics\n');
+    console.log('  [Tools]');
+    check('claude CLI', commandExists('claude'));
+    check('tmux', commandExists('tmux'));
+    check('git', commandExists('git'));
+    check('gh (GitHub CLI)', commandExists('gh'), 'Required for team PR features: brew install gh');
+    console.log();
+    console.log('  [Plugins]');
+    const ralphLoopInstalled = exists(path.join(os.homedir(), '.claude', 'plugins', 'cache', 'claude-plugins-official', 'ralph-loop'));
+    check('ralph-loop plugin', ralphLoopInstalled, 'Required for ralph mode auto-iteration. Install: claude plugins install ralph-loop');
+    // forgen 플러그인 캐시 디렉토리 확인 — 훅 실행의 필수 전제
+    const pluginCacheBase = path.join(os.homedir(), '.claude', 'plugins', 'cache', 'forgen-local', 'forgen');
+    let forgenPluginCacheOk = false;
+    if (exists(pluginCacheBase)) {
+        const versions = fs.readdirSync(pluginCacheBase).filter(f => {
+            try {
+                const lstat = fs.lstatSync(path.join(pluginCacheBase, f));
+                return lstat.isDirectory() || lstat.isSymbolicLink();
+            }
+            catch {
+                return false;
+            }
+        });
+        forgenPluginCacheOk = versions.length > 0;
+    }
+    check('forgen plugin cache', forgenPluginCacheOk, 'Hook execution requires plugin cache. Fix: npm run build && node scripts/postinstall.js');
+    // installed_plugins.json 정합성 확인
+    const installedPluginsPath = path.join(os.homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    let pluginRegistered = false;
+    if (exists(installedPluginsPath)) {
+        try {
+            const installed = JSON.parse(fs.readFileSync(installedPluginsPath, 'utf-8'));
+            const entry = installed?.plugins?.['forgen@forgen-local'];
+            if (Array.isArray(entry) && entry.length > 0) {
+                const installPath = entry[0]?.installPath;
+                pluginRegistered = !!installPath && exists(installPath);
+            }
+        }
+        catch { /* ignore */ }
+    }
+    check('forgen plugin registered & installPath exists', pluginRegistered, 'Plugin registered but installPath missing on disk. Fix: npm run build && node scripts/postinstall.js');
+    console.log();
+    console.log('  [Directories]');
+    check('~/.forgen/', exists(FORGEN_HOME));
+    check('~/.forgen/me/', exists(ME_DIR));
+    check('~/.forgen/me/solutions/', exists(ME_SOLUTIONS));
+    check('~/.forgen/me/behavior/', exists(ME_BEHAVIOR));
+    check('~/.forgen/me/rules/', exists(ME_RULES));
+    check('~/.forgen/packs/', exists(PACKS_DIR));
+    check('~/.forgen/sessions/', exists(SESSIONS_DIR));
+    console.log();
+    console.log('  [Philosophy]');
+    check('philosophy.json', exists(ME_PHILOSOPHY));
+    console.log();
+    console.log('  [Environment]');
+    check('Inside tmux session', !!process.env.TMUX);
+    check('FORGEN_HARNESS env var', (process.env.FORGEN_HARNESS ?? process.env.COMPOUND_HARNESS) === '1');
+    console.log();
+    // 솔루션/규칙 수
+    if (exists(ME_SOLUTIONS)) {
+        const solutions = fs.readdirSync(ME_SOLUTIONS).filter((f) => f.endsWith('.md')).length;
+        console.log(`  Personal solutions: ${solutions}`);
+    }
+    if (exists(ME_BEHAVIOR)) {
+        const behavior = fs.readdirSync(ME_BEHAVIOR).filter((f) => f.endsWith('.md')).length;
+        console.log(`  Behavioral patterns: ${behavior}`);
+    }
+    if (exists(ME_RULES)) {
+        const rules = fs.readdirSync(ME_RULES).filter((f) => f.endsWith('.md')).length;
+        console.log(`  Personal rules: ${rules}`);
+    }
+    console.log();
+    console.log('  [Log Locations]');
+    console.log(`  Session logs: ${SESSIONS_DIR}`);
+    if (exists(SESSIONS_DIR)) {
+        const sessionCount = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith('.json')).length;
+        console.log(`  Saved sessions: ${sessionCount}`);
+    }
+    console.log(`  Claude Code sessions: ${CLAUDE_PROJECTS_DIR}`);
+    console.log();
+    console.log();
+    // v1: 팀 팩 시스템 제거. 개인 모드만 지원.
+    console.log('  [Pack Connections]');
+    console.log('  v1: Personal mode only (team packs removed)');
+    console.log();
+    // Lab 데이터 정리
+    const labExpDir = path.join(LAB_DIR, 'experiments');
+    if (exists(labExpDir)) {
+        const expFiles = fs.readdirSync(labExpDir).filter(f => f.endsWith('.json'));
+        // 1차 필터: 0바이트 또는 50바이트 미만 파일 (빠른 stat 기반)
+        const emptyFiles = expFiles.filter(f => {
+            try {
+                const stat = fs.statSync(path.join(labExpDir, f));
+                if (stat.size < 50)
+                    return true;
+                // --clean-experiments 플래그가 있을 때만 내용 파싱 (성능 보호)
+                if (!process.argv.includes('--clean-experiments'))
+                    return false;
+                const content = JSON.parse(fs.readFileSync(path.join(labExpDir, f), 'utf-8'));
+                return content.variants?.every((v) => !v.sessionIds?.length);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (emptyFiles.length > 0) {
+            console.log(`  [Lab Cleanup]`);
+            console.log(`  Empty experiment files: ${emptyFiles.length} / ${expFiles.length}`);
+            if (process.argv.includes('--clean-experiments')) {
+                let cleaned = 0;
+                for (const f of emptyFiles) {
+                    try {
+                        fs.unlinkSync(path.join(labExpDir, f));
+                        cleaned++;
+                    }
+                    catch { /* skip */ }
+                }
+                console.log(`  → Cleaned ${cleaned} empty experiment files`);
+            }
+            else {
+                console.log(`  Run \`forgen doctor --clean-experiments\` to remove them`);
+            }
+            console.log();
+        }
+    }
+    // 현재 디렉토리 git 정보
+    console.log('  [Git]');
+    try {
+        const remote = execFileSync('git', ['remote', 'get-url', 'origin'], { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        console.log(`  remote (origin): ${remote}`);
+    }
+    catch {
+        // git 저장소가 아니거나 origin이 없으면 표시하지 않음
+        console.log('  git remote: (none)');
+    }
+    console.log();
+}