@wooojin/forgen 0.1.0

package/dist/core/paths.d.ts

@@ -0,0 +1,85 @@
+/** ~/.claude/ — Claude Code 설정 디렉토리 */
+export declare const CLAUDE_DIR: string;
+/** ~/.claude/settings.json — Claude Code 설정 파일 */
+export declare const SETTINGS_PATH: string;
+/**
+ * ~/.compound/ — LEGACY harness home (pre-v5).
+ *
+ * @deprecated A5 (2026-04-09): this path must NEVER be used for WRITES.
+ * It exists solely as the source path for `migrateToForgen()`.
+ * All new writes must target `FORGEN_HOME`-based paths. Consumers that
+ * read from this path should prefer the FORGEN_HOME equivalent first
+ * and fall back here only during migration.
+ *
+ * Pre-A5, `harness.ts:ensureDirectories` and several hooks actively
+ * created directories under this path, causing a dual-reality where
+ * state could diverge between `~/.compound/` and `~/.forgen/` when the
+ * migration symlink was broken (sudo install, SIP, CI, manual delete).
+ */
+export declare const COMPOUND_HOME: string;
+/** ~/.forgen/ — v1 하네스 홈 디렉토리 */
+export declare const FORGEN_HOME: string;
+/** ~/.forgen/me/ — 개인 공간 (v5.1: ~/.compound/ → ~/.forgen/ 통합) */
+export declare const ME_DIR: string;
+/** ~/.forgen/me/philosophy.json — 개인 철학 */
+export declare const ME_PHILOSOPHY: string;
+/** ~/.forgen/me/solutions/ — 개인 솔루션 */
+export declare const ME_SOLUTIONS: string;
+/** ~/.forgen/me/behavior/ — 개인 행동 패턴 */
+export declare const ME_BEHAVIOR: string;
+/** ~/.forgen/me/rules/ — 개인 규칙 */
+export declare const ME_RULES: string;
+/** ~/.forgen/me/skills/ — 개인 스킬 (promoted solutions) */
+export declare const ME_SKILLS: string;
+/** ~/.forgen/packs/ — 팀 팩 저장소 */
+export declare const PACKS_DIR: string;
+/** ~/.forgen/handoffs/ — 세션 간 핸드오프 데이터 */
+export declare const HANDOFFS_DIR: string;
+/** ~/.forgen/state/ — 상태 파일 디렉토리 */
+export declare const STATE_DIR: string;
+/**
+ * ~/.forgen/state/match-eval-log.jsonl — JSONL ranking-decision log for the
+ * bootstrap evaluator and offline matcher debugging. Written best-effort by
+ * `src/engine/match-eval-log.ts`; never on the hook critical path.
+ */
+export declare const MATCH_EVAL_LOG_PATH: string;
+/** ~/.forgen/sessions/ — 세션 로그 */
+export declare const SESSIONS_DIR: string;
+/** ~/.forgen/config.json — 글로벌 설정 */
+export declare const GLOBAL_CONFIG: string;
+/** ~/.forgen/lab/ — Lab 적응형 최적화 엔진 데이터 */
+export declare const LAB_DIR: string;
+/** ~/.forgen/lab/events.jsonl — Lab 이벤트 로그 (JSONL) */
+export declare const LAB_EVENTS: string;
+/** ~/.forgen/me/forge-profile.json — 글로벌 Forge 프로필 */
+export declare const FORGE_PROFILE: string;
+/** @deprecated use ME_DIR */
+export declare const V1_ME_DIR: string;
+/** @deprecated use FORGE_PROFILE */
+export declare const V1_PROFILE: string;
+/** @deprecated use ME_RULES */
+export declare const V1_RULES_DIR: string;
+/** @deprecated use ME_BEHAVIOR */
+export declare const V1_EVIDENCE_DIR: string;
+/** ~/.forgen/me/recommendations/ — Pack Recommendation */
+export declare const V1_RECOMMENDATIONS_DIR: string;
+/** @deprecated use ME_SOLUTIONS */
+export declare const V1_SOLUTIONS_DIR: string;
+/** @deprecated use STATE_DIR */
+export declare const V1_STATE_DIR: string;
+/** ~/.forgen/state/sessions/ — Session Effective State */
+export declare const V1_SESSIONS_DIR: string;
+/** ~/.forgen/state/raw-logs/ — Raw Log */
+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"];
+/** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
+export declare function projectDir(cwd: string): string;
+/** {repo}/.compound/pack.link — 팀 팩 연결 파일 */
+export declare function packLinkPath(cwd: string): string;
+/** {repo}/.compound/philosophy.json — 프로젝트별 철학 */
+export declare function projectPhilosophyPath(cwd: string): string;
+/** {repo}/.compound/forge-profile.json — 프로젝트별 Forge 프로필 */
+export declare function projectForgeProfilePath(cwd: string): string;

package/dist/core/paths.js

@@ -0,0 +1,101 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+const HOME = os.homedir();
+/** ~/.claude/ — Claude Code 설정 디렉토리 */
+export const CLAUDE_DIR = path.join(HOME, '.claude');
+/** ~/.claude/settings.json — Claude Code 설정 파일 */
+export const SETTINGS_PATH = path.join(CLAUDE_DIR, 'settings.json');
+/**
+ * ~/.compound/ — LEGACY harness home (pre-v5).
+ *
+ * @deprecated A5 (2026-04-09): this path must NEVER be used for WRITES.
+ * It exists solely as the source path for `migrateToForgen()`.
+ * All new writes must target `FORGEN_HOME`-based paths. Consumers that
+ * read from this path should prefer the FORGEN_HOME equivalent first
+ * and fall back here only during migration.
+ *
+ * Pre-A5, `harness.ts:ensureDirectories` and several hooks actively
+ * created directories under this path, causing a dual-reality where
+ * state could diverge between `~/.compound/` and `~/.forgen/` when the
+ * migration symlink was broken (sudo install, SIP, CI, manual delete).
+ */
+export const COMPOUND_HOME = path.join(HOME, '.compound');
+/** ~/.forgen/ — v1 하네스 홈 디렉토리 */
+export const FORGEN_HOME = path.join(HOME, '.forgen');
+/** ~/.forgen/me/ — 개인 공간 (v5.1: ~/.compound/ → ~/.forgen/ 통합) */
+export const ME_DIR = path.join(FORGEN_HOME, 'me');
+/** ~/.forgen/me/philosophy.json — 개인 철학 */
+export const ME_PHILOSOPHY = path.join(ME_DIR, 'philosophy.json');
+/** ~/.forgen/me/solutions/ — 개인 솔루션 */
+export const ME_SOLUTIONS = path.join(ME_DIR, 'solutions');
+/** ~/.forgen/me/behavior/ — 개인 행동 패턴 */
+export const ME_BEHAVIOR = path.join(ME_DIR, 'behavior');
+/** ~/.forgen/me/rules/ — 개인 규칙 */
+export const ME_RULES = path.join(ME_DIR, 'rules');
+/** ~/.forgen/me/skills/ — 개인 스킬 (promoted solutions) */
+export const ME_SKILLS = path.join(ME_DIR, 'skills');
+/** ~/.forgen/packs/ — 팀 팩 저장소 */
+export const PACKS_DIR = path.join(FORGEN_HOME, 'packs');
+/** ~/.forgen/handoffs/ — 세션 간 핸드오프 데이터 */
+export const HANDOFFS_DIR = path.join(FORGEN_HOME, 'handoffs');
+/** ~/.forgen/state/ — 상태 파일 디렉토리 */
+export const STATE_DIR = path.join(FORGEN_HOME, 'state');
+/**
+ * ~/.forgen/state/match-eval-log.jsonl — JSONL ranking-decision log for the
+ * bootstrap evaluator and offline matcher debugging. Written best-effort by
+ * `src/engine/match-eval-log.ts`; never on the hook critical path.
+ */
+export const MATCH_EVAL_LOG_PATH = path.join(STATE_DIR, 'match-eval-log.jsonl');
+/** ~/.forgen/sessions/ — 세션 로그 */
+export const SESSIONS_DIR = path.join(FORGEN_HOME, 'sessions');
+/** ~/.forgen/config.json — 글로벌 설정 */
+export const GLOBAL_CONFIG = path.join(FORGEN_HOME, 'config.json');
+/** ~/.forgen/lab/ — Lab 적응형 최적화 엔진 데이터 */
+export const LAB_DIR = path.join(FORGEN_HOME, 'lab');
+/** ~/.forgen/lab/events.jsonl — Lab 이벤트 로그 (JSONL) */
+export const LAB_EVENTS = path.join(LAB_DIR, 'events.jsonl');
+/** ~/.forgen/me/forge-profile.json — 글로벌 Forge 프로필 */
+export const FORGE_PROFILE = path.join(ME_DIR, 'forge-profile.json');
+// ── v1 호환 경로 (ME_*와 동일 — 점진 제거 예정) ──
+/** @deprecated use ME_DIR */
+export const V1_ME_DIR = ME_DIR;
+/** @deprecated use FORGE_PROFILE */
+export const V1_PROFILE = FORGE_PROFILE;
+/** @deprecated use ME_RULES */
+export const V1_RULES_DIR = ME_RULES;
+/** @deprecated use ME_BEHAVIOR */
+export const V1_EVIDENCE_DIR = ME_BEHAVIOR;
+/** ~/.forgen/me/recommendations/ — Pack Recommendation */
+export const V1_RECOMMENDATIONS_DIR = path.join(ME_DIR, 'recommendations');
+/** @deprecated use ME_SOLUTIONS */
+export const V1_SOLUTIONS_DIR = ME_SOLUTIONS;
+/** @deprecated use STATE_DIR */
+export const V1_STATE_DIR = STATE_DIR;
+/** ~/.forgen/state/sessions/ — Session Effective State */
+export const V1_SESSIONS_DIR = path.join(STATE_DIR, 'sessions');
+/** ~/.forgen/state/raw-logs/ — Raw Log */
+export const V1_RAW_LOGS_DIR = path.join(STATE_DIR, 'raw-logs');
+/** @deprecated use GLOBAL_CONFIG */
+export const V1_GLOBAL_CONFIG = GLOBAL_CONFIG;
+// ── 레거시 ──
+/** 모든 실행 모드 이름 (cancel/recovery 시 사용) */
+export const ALL_MODES = [
+    'ralph', 'autopilot', 'ultrawork', 'team', 'pipeline',
+    'ccg', 'ralplan', 'deep-interview', 'ecomode',
+];
+/** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
+export function projectDir(cwd) {
+    return path.join(cwd, '.compound');
+}
+/** {repo}/.compound/pack.link — 팀 팩 연결 파일 */
+export function packLinkPath(cwd) {
+    return path.join(projectDir(cwd), 'pack.link');
+}
+/** {repo}/.compound/philosophy.json — 프로젝트별 철학 */
+export function projectPhilosophyPath(cwd) {
+    return path.join(projectDir(cwd), 'philosophy.json');
+}
+/** {repo}/.compound/forge-profile.json — 프로젝트별 Forge 프로필 */
+export function projectForgeProfilePath(cwd) {
+    return path.join(projectDir(cwd), 'forge-profile.json');
+}

package/dist/core/plugin-detector.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Forgen — Plugin Detector
+ *
+ * 다른 Claude Code 플러그인이 설치되어 있는지 감지하고,
+ * forgen와 기능이 중복되는 스킬/훅 목록을 반환합니다.
+ *
+ * 감지 방법:
+ *   1. ~/.claude/plugins/ 디렉토리에서 설치된 플러그인 스캔
+ *   2. 알려진 플러그인의 파일 시그니처 (.omc/, .claude-mem/ 등) 확인
+ *   3. 결과를 ~/.forgen/state/detected-plugins.json에 캐시 (1시간 TTL)
+ *
+ * 설계 결정:
+ *   - 감지는 읽기 전용 — 다른 플러그인의 파일을 수정하지 않음
+ *   - 실패 시 빈 배열 반환 (failure-tolerant) — 감지 실패 = 충돌 없음으로 간주
+ *   - 캐시 TTL 1시간 — 플러그인 설치/제거 빈도가 낮으므로 충분
+ */
+export interface DetectedPlugin {
+    name: string;
+    /** 이 플러그인과 중복되는 forgen 스킬 이름 */
+    overlappingSkills: string[];
+    /** 이 플러그인과 중복되는 forgen 훅 이름 */
+    overlappingHooks: string[];
+    /** 감지 방법 (디버깅용) */
+    detectedBy: 'plugin-dir' | 'signature' | 'both';
+}
+/**
+ * 설치된 다른 플러그인을 감지합니다.
+ * 캐시가 유효하면 캐시를 반환합니다 (1시간 TTL).
+ */
+export declare function detectInstalledPlugins(cwd?: string): DetectedPlugin[];
+/** forgen와 중복되는 스킬 이름 → 충돌 플러그인 이름 매핑 */
+export declare function getSkillConflicts(cwd?: string): Map<string, string>;
+/** forgen와 중복되는 훅 이름 → 충돌 플러그인 이름 매핑 */
+export declare function getHookConflicts(cwd?: string): Map<string, string>;
+/**
+ * 컨텍스트를 상시 주입하는 다른 플러그인이 있는지 확인합니다.
+ *
+ * 판정 기준: overlappingHooks가 있는 플러그인만 "컨텍스트 주입" 간주.
+ * MCP 기반 플러그인(claude-mem 등)이나 스킬만 중복되는 플러그인은
+ * 온디맨드 호출이므로 상시 컨텍스트를 점유하지 않아 제외합니다.
+ */
+export declare function hasContextInjectingPlugins(cwd?: string): boolean;
+/** 감지 캐시를 무효화합니다 (플러그인 설치/제거 후 호출) */
+export declare function invalidatePluginCache(): void;

package/dist/core/plugin-detector.js

@@ -0,0 +1,226 @@
+/**
+ * Forgen — Plugin Detector
+ *
+ * 다른 Claude Code 플러그인이 설치되어 있는지 감지하고,
+ * forgen와 기능이 중복되는 스킬/훅 목록을 반환합니다.
+ *
+ * 감지 방법:
+ *   1. ~/.claude/plugins/ 디렉토리에서 설치된 플러그인 스캔
+ *   2. 알려진 플러그인의 파일 시그니처 (.omc/, .claude-mem/ 등) 확인
+ *   3. 결과를 ~/.forgen/state/detected-plugins.json에 캐시 (1시간 TTL)
+ *
+ * 설계 결정:
+ *   - 감지는 읽기 전용 — 다른 플러그인의 파일을 수정하지 않음
+ *   - 실패 시 빈 배열 반환 (failure-tolerant) — 감지 실패 = 충돌 없음으로 간주
+ *   - 캐시 TTL 1시간 — 플러그인 설치/제거 빈도가 낮으므로 충분
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { STATE_DIR } from './paths.js';
+const KNOWN_PLUGINS = {
+    'oh-my-claudecode': {
+        signatures: ['.omc'],
+        localSignatures: ['.omc'],
+        overlappingSkills: [
+            'autopilot', 'team', 'code-review', 'tdd', 'debug-detective',
+            'refactor', 'security-review', 'git-master', 'migrate',
+            'pipeline', 'ultrawork',
+        ],
+        overlappingHooks: ['intent-classifier', 'keyword-detector'],
+    },
+    'claude-mem': {
+        signatures: ['.claude-mem'],
+        localSignatures: [],
+        // claude-mem은 MCP 기반이라 스킬 충돌은 없지만 컨텍스트 주입 경쟁 있음
+        overlappingSkills: [],
+        overlappingHooks: [],
+    },
+    'macrodata': {
+        signatures: ['.macrodata'],
+        localSignatures: ['.macrodata'],
+        overlappingSkills: [],
+        overlappingHooks: [],
+    },
+    'superpowers': {
+        signatures: ['.codex/superpowers'], // Superpowers installs to ~/.codex/superpowers/
+        localSignatures: [],
+        overlappingSkills: [
+            'tdd', 'debug-detective', 'refactor', 'code-review',
+        ],
+        overlappingHooks: [], // Superpowers uses skills, not conflicting hooks
+    },
+    'feature-dev': {
+        signatures: [],
+        localSignatures: [],
+        overlappingSkills: ['pipeline'],
+        overlappingHooks: [],
+    },
+    'code-review-plugin': {
+        signatures: [],
+        localSignatures: [],
+        overlappingSkills: ['code-review'],
+        overlappingHooks: [],
+    },
+    'commit-commands': {
+        signatures: [],
+        localSignatures: [],
+        overlappingSkills: ['git-master'],
+        overlappingHooks: [],
+    },
+};
+// ── 캐시 ──
+const CACHE_PATH = path.join(STATE_DIR, 'detected-plugins.json');
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1시간
+function loadCache(cwd) {
+    try {
+        if (!fs.existsSync(CACHE_PATH))
+            return null;
+        const data = JSON.parse(fs.readFileSync(CACHE_PATH, 'utf-8'));
+        const age = Date.now() - new Date(data.timestamp).getTime();
+        if (!Number.isFinite(age) || age > CACHE_TTL_MS)
+            return null;
+        // cwd가 다르면 캐시 무효 (프로젝트별 로컬 시그니처가 다를 수 있음)
+        if (data.cwd && cwd && data.cwd !== cwd)
+            return null;
+        return data.plugins;
+    }
+    catch {
+        return null;
+    }
+}
+function saveCache(plugins, cwd) {
+    try {
+        fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+        fs.writeFileSync(CACHE_PATH, JSON.stringify({
+            plugins,
+            timestamp: new Date().toISOString(),
+            cwd: cwd ?? undefined,
+        }));
+    }
+    catch {
+        // 캐시 저장 실패는 무시
+    }
+}
+// ── 감지 로직 ──
+/** ~/.claude/plugins/ 디렉토리에서 설치된 플러그인 이름 추출 */
+function scanPluginDirectory() {
+    const names = new Set();
+    const pluginsDir = path.join(os.homedir(), '.claude', 'plugins');
+    try {
+        if (!fs.existsSync(pluginsDir))
+            return names;
+        for (const entry of fs.readdirSync(pluginsDir)) {
+            const pluginJsonPath = path.join(pluginsDir, entry, 'plugin.json');
+            if (fs.existsSync(pluginJsonPath)) {
+                try {
+                    const manifest = JSON.parse(fs.readFileSync(pluginJsonPath, 'utf-8'));
+                    names.add(manifest.name ?? entry);
+                }
+                catch {
+                    names.add(entry);
+                }
+            }
+        }
+    }
+    catch {
+        // 디렉토리 접근 실패
+    }
+    return names;
+}
+/** 파일 시그니처로 알려진 플러그인 감지 */
+function detectBySignature(cwd) {
+    const detected = new Map();
+    const home = os.homedir();
+    const effectiveCwd = cwd ?? process.cwd();
+    for (const [pluginName, entry] of Object.entries(KNOWN_PLUGINS)) {
+        // 홈 디렉토리 시그니처
+        for (const sig of entry.signatures) {
+            if (fs.existsSync(path.join(home, sig))) {
+                detected.set(pluginName, 'signature');
+                break;
+            }
+        }
+        // 프로젝트 로컬 시그니처
+        if (!detected.has(pluginName)) {
+            for (const sig of entry.localSignatures) {
+                if (fs.existsSync(path.join(effectiveCwd, sig))) {
+                    detected.set(pluginName, 'signature');
+                    break;
+                }
+            }
+        }
+    }
+    return detected;
+}
+// ── 공개 API ──
+/**
+ * 설치된 다른 플러그인을 감지합니다.
+ * 캐시가 유효하면 캐시를 반환합니다 (1시간 TTL).
+ */
+export function detectInstalledPlugins(cwd) {
+    // 캐시 확인 (cwd별로 분리)
+    const cached = loadCache(cwd);
+    if (cached)
+        return cached;
+    const result = [];
+    // 방법 1: 플러그인 디렉토리 스캔
+    const dirPlugins = scanPluginDirectory();
+    // 방법 2: 파일 시그니처 감지
+    const sigPlugins = detectBySignature(cwd);
+    // 병합
+    const allNames = new Set([...dirPlugins, ...sigPlugins.keys()]);
+    for (const name of allNames) {
+        const known = KNOWN_PLUGINS[name];
+        const inDir = dirPlugins.has(name);
+        const inSig = sigPlugins.has(name);
+        result.push({
+            name,
+            overlappingSkills: known?.overlappingSkills ?? [],
+            overlappingHooks: known?.overlappingHooks ?? [],
+            detectedBy: inDir && inSig ? 'both' : inDir ? 'plugin-dir' : 'signature',
+        });
+    }
+    saveCache(result, cwd);
+    return result;
+}
+/** forgen와 중복되는 스킬 이름 → 충돌 플러그인 이름 매핑 */
+export function getSkillConflicts(cwd) {
+    const conflicts = new Map();
+    for (const plugin of detectInstalledPlugins(cwd)) {
+        for (const skill of plugin.overlappingSkills) {
+            conflicts.set(skill, plugin.name);
+        }
+    }
+    return conflicts;
+}
+/** forgen와 중복되는 훅 이름 → 충돌 플러그인 이름 매핑 */
+export function getHookConflicts(cwd) {
+    const conflicts = new Map();
+    for (const plugin of detectInstalledPlugins(cwd)) {
+        for (const hook of plugin.overlappingHooks) {
+            conflicts.set(hook, plugin.name);
+        }
+    }
+    return conflicts;
+}
+/**
+ * 컨텍스트를 상시 주입하는 다른 플러그인이 있는지 확인합니다.
+ *
+ * 판정 기준: overlappingHooks가 있는 플러그인만 "컨텍스트 주입" 간주.
+ * MCP 기반 플러그인(claude-mem 등)이나 스킬만 중복되는 플러그인은
+ * 온디맨드 호출이므로 상시 컨텍스트를 점유하지 않아 제외합니다.
+ */
+export function hasContextInjectingPlugins(cwd) {
+    return detectInstalledPlugins(cwd).some(p => p.overlappingHooks.length > 0);
+}
+/** 감지 캐시를 무효화합니다 (플러그인 설치/제거 후 호출) */
+export function invalidatePluginCache() {
+    try {
+        if (fs.existsSync(CACHE_PATH))
+            fs.unlinkSync(CACHE_PATH);
+    }
+    catch {
+        // 무시
+    }
+}

package/dist/core/runtime-detector.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Forgen v1 — Runtime Capability Detection
+ *
+ * 현재 Claude Code 권한 상태를 감지.
+ * Authoritative: docs/plans/2026-04-03-forgen-component-interface-design.md §4
+ */
+import type { RuntimeCapabilityState } from '../store/types.js';
+export declare function detectRuntimeCapability(): RuntimeCapabilityState;

package/dist/core/runtime-detector.js

@@ -0,0 +1,49 @@
+/**
+ * Forgen v1 — Runtime Capability Detection
+ *
+ * 현재 Claude Code 권한 상태를 감지.
+ * Authoritative: docs/plans/2026-04-03-forgen-component-interface-design.md §4
+ */
+import { SETTINGS_PATH } from './paths.js';
+import { safeReadJSON } from '../hooks/shared/atomic-write.js';
+export function detectRuntimeCapability() {
+    // 1. CLI 플래그 확인
+    const args = process.argv.join(' ');
+    const dangerousSkip = args.includes('--dangerously-skip-permissions')
+        || process.env.CLAUDE_DANGEROUS_SKIP_PERMISSIONS === 'true';
+    if (dangerousSkip) {
+        return {
+            permission_mode: 'bypassed',
+            dangerous_skip_permissions: true,
+            auto_accept_scope: ['all'],
+            detected_from: 'cli-flag',
+        };
+    }
+    // 2. settings.json에서 permission 관련 설정 확인
+    const settings = safeReadJSON(SETTINGS_PATH, {});
+    const autoApprove = settings.autoApprovePermissions;
+    if (autoApprove === true) {
+        return {
+            permission_mode: 'relaxed',
+            dangerous_skip_permissions: false,
+            auto_accept_scope: ['auto-approve'],
+            detected_from: 'settings',
+        };
+    }
+    // 3. 환경변수 확인
+    if (process.env.CLAUDE_AUTO_ACCEPT === 'true') {
+        return {
+            permission_mode: 'relaxed',
+            dangerous_skip_permissions: false,
+            auto_accept_scope: ['env-auto-accept'],
+            detected_from: 'env',
+        };
+    }
+    // 4. 기본값: guarded
+    return {
+        permission_mode: 'guarded',
+        dangerous_skip_permissions: false,
+        auto_accept_scope: [],
+        detected_from: 'default',
+    };
+}

package/dist/core/scope-resolver.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Forgen v1 — Scope Resolver (simplified)
+ *
+ * v1에서는 scope = me only. 팀 팩 시스템 제거.
+ * compound-loop, solution-injector 호환을 위해 유지.
+ */
+import type { ScopeInfo } from './types.js';
+export declare function resolveScope(cwd: string, _philosophySource?: 'project' | 'global' | 'default'): ScopeInfo;

package/dist/core/scope-resolver.js

@@ -0,0 +1,45 @@
+/**
+ * Forgen v1 — Scope Resolver (simplified)
+ *
+ * v1에서는 scope = me only. 팀 팩 시스템 제거.
+ * compound-loop, solution-injector 호환을 위해 유지.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_DIR, ME_SOLUTIONS, ME_RULES, projectDir } from './paths.js';
+import { createLogger } from './logger.js';
+const log = createLogger('scope-resolver');
+/** 디렉토리 내 .md 파일 수 카운트 */
+function countFiles(dir, ext = '.md') {
+    if (!fs.existsSync(dir))
+        return 0;
+    try {
+        return fs.readdirSync(dir).filter((f) => f.endsWith(ext)).length;
+    }
+    catch (e) {
+        log.debug(`countFiles 실패: ${dir}`, e);
+        return 0;
+    }
+}
+export function resolveScope(cwd, _philosophySource) {
+    const meSolutions = countFiles(ME_SOLUTIONS);
+    const meRules = countFiles(ME_RULES);
+    const projDir = projectDir(cwd);
+    const projSolutions = countFiles(path.join(projDir, 'solutions'));
+    const parts = [`Me(${meSolutions})`];
+    if (projSolutions > 0)
+        parts.push(`Project(${projSolutions})`);
+    return {
+        me: {
+            philosophyPath: path.join(ME_DIR, 'philosophy.json'),
+            solutionCount: meSolutions,
+            ruleCount: meRules,
+        },
+        // v1: team scope 제거
+        project: {
+            path: projDir,
+            solutionCount: projSolutions,
+        },
+        summary: parts.join(' + '),
+    };
+}

package/dist/core/session-logger.d.ts

@@ -0,0 +1,6 @@
+import type { HarnessContext } from './types.js';
+/**
+ * 세션 로그를 ~/.forgen/sessions/{date}_{sessionId}.json 에 기록
+ * harness.ts의 prepareHarness() 완료 후 호출
+ */
+export declare function startSessionLog(context: HarnessContext): void;