@wooojin/forgen 0.2.1 → 0.3.0

package/dist/fgx.js

@@ -3,14 +3,17 @@
  * fgx — forgen --dangerously-skip-permissions 의 단축 명령
  * 모든 인자를 그대로 전달하되, --dangerously-skip-permissions 를 자동 주입
  */
+import { resolveLaunchContext } from './services/session.js';
+import { prepareHarness, isFirstRun } from './core/harness.js';
+import { spawnClaude } from './core/spawn.js';
 const args = process.argv.slice(2);
 // 이미 포함되어 있으면 중복 추가하지 않음
-if (!args.includes('--dangerously-skip-permissions')) {
-    args.unshift('--dangerously-skip-permissions');
+const launchContext = resolveLaunchContext(args);
+const runtime = launchContext.runtime;
+const launchArgs = [...launchContext.args];
+if (!launchArgs.includes('--dangerously-skip-permissions')) {
+    launchArgs.unshift('--dangerously-skip-permissions');
 }
-// cli.ts 의 main 로직을 재사용
-import { prepareHarness, isFirstRun } from './core/harness.js';
-import { spawnClaude } from './core/spawn.js';
 async function main() {
     // Security warning — fgx bypasses all Claude Code permission checks
     console.warn('\n  ⚠  fgx: ALL permission checks are disabled (--dangerously-skip-permissions)');
@@ -23,7 +26,7 @@ async function main() {
         console.log('  Creating ~/.forgen/ directory and default philosophy.');
         console.log('  Run `forgen onboarding` afterwards to complete personalization.\n');
     }
-    const context = await prepareHarness(process.cwd());
+    const context = await prepareHarness(process.cwd(), { runtime });
     if (firstRun) {
         console.log('  [Done] Initial setup complete.\n');
     }
@@ -33,8 +36,9 @@ async function main() {
         console.log(`[forgen] Trust: ${v1.session.effective_trust_policy}`);
     }
     console.log('[forgen] Mode: dangerously-skip-permissions');
-    console.log('[forgen] Starting Claude Code...\n');
-    await spawnClaude(args, context);
+    const runtimeLabel = runtime === 'codex' ? 'Codex' : 'Claude';
+    console.log(`[forgen] Starting ${runtimeLabel}...\n`);
+    await spawnClaude(launchArgs, context, runtime);
 }
 main().catch((err) => {
     console.error('[forgen] Error:', err instanceof Error ? err.message : err);

package/dist/hooks/context-guard.d.ts

@@ -32,3 +32,8 @@ export declare function buildAutoCompactMessage(totalChars: number): string;
 /** 경고 메시지 생성 (순수 함수) */
 export declare function buildContextWarningMessage(promptCount: number, totalChars: number): string;
 export declare function main(): Promise<void>;
+/**
+ * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
+ * OMC의 persistent-mode.cjs 패턴 참고.
+ */
+export declare function checkForgeLoopActive(): string | null;

package/dist/hooks/context-guard.js

@@ -89,6 +89,12 @@ export async function main() {
         // Stop 훅: stop_hook_type이 있으면 처리
         if (input.stop_hook_type) {
             _hookEvent = 'Stop';
+            // forge-loop 활성 시 미완료 스토리 감지 → 지속 메시지 주입 (polite-stop 방지)
+            const forgeLoopBlock = checkForgeLoopActive();
+            if (forgeLoopBlock) {
+                console.log(forgeLoopBlock);
+                return;
+            }
             // 에러가 포함된 경우: context limit 감지
             if (input.error) {
                 const errorMsg = input.error;
@@ -119,12 +125,14 @@ export async function main() {
                         fs.writeFileSync(path.join(STATE_DIR, 'pending-compound.json'), JSON.stringify(marker));
                     }
                     catch { /* fail-open: marker write failure is non-critical */ }
-                    console.log(approveWithWarning(`[Forgen] Session with ${state.promptCount} prompts ended. Compound loop will auto-trigger on next session start.`));
+                    const summary = buildSessionSummary(sessionId, state.promptCount);
+                    console.log(approveWithWarning(`[Forgen] Session with ${state.promptCount} prompts ended.\n${summary}\nCompound loop will auto-trigger on next session start.`));
                     return;
                 }
                 if (state.promptCount >= 10) {
                     // 10-19 prompts: suggest /compound manually
-                    console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다. /compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
+                    const summary = buildSessionSummary(sessionId, state.promptCount);
+                    console.log(approveWithWarning(`[Forgen] 이 세션에서 ${state.promptCount}개의 프롬프트를 처리했습니다.\n${summary}/compound 를 실행하면 이 세션의 학습 내용을 축적할 수 있습니다.`));
                     return;
                 }
             }
@@ -166,6 +174,114 @@ export async function main() {
         recordHookTiming('context-guard', Date.now() - _hookStart, _hookEvent);
     }
 }
+/**
+ * 세션 종료 시 "forgen이 도움이 된 정도"를 요약.
+ * solution-cache에서 이번 세션에 주입된 compound 솔루션 수를 집계하여
+ * 카운터팩추얼 "forgen 없었으면 ~N분 더 걸렸을 것" 메시지 생성.
+ */
+function buildSessionSummary(sessionId, promptCount) {
+    try {
+        const cachePath = path.join(STATE_DIR, `solution-cache-${sessionId}.json`);
+        if (!fs.existsSync(cachePath))
+            return '';
+        const cache = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+        const injected = Array.isArray(cache.injected) ? cache.injected : [];
+        if (injected.length === 0)
+            return '';
+        // 카운터팩추얼: 주입된 compound 1건당 평균 8분 절약 가정 (하한 추정)
+        const savedMins = injected.length * 8;
+        const savedStr = savedMins >= 60
+            ? `${Math.floor(savedMins / 60)}시간 ${savedMins % 60}분`
+            : `${savedMins}분`;
+        // 상위 3개 솔루션
+        const topNames = injected.slice(0, 3).map(i => `"${i.name}"`).join(', ');
+        const moreCount = injected.length - 3;
+        const topStr = moreCount > 0 ? `${topNames} 외 ${moreCount}개` : topNames;
+        return [
+            `\n📊 이번 세션 forgen 효과:`,
+            `  주입된 compound: ${injected.length}건 (${topStr})`,
+            `  추정 절약 시간: ${savedStr} (forgen 없었으면 시행착오 필요)`,
+            `  프롬프트 대비 효율: ${(injected.length / promptCount * 100).toFixed(0)}% 의 대화가 축적된 지식의 도움을 받음\n`,
+        ].join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+// forge-loop 상태 파일 경로
+const FORGE_LOOP_STATE_PATH = path.join(STATE_DIR, 'forge-loop.json');
+// forge-loop 차단 안전 상한 (무한 루프 방지)
+const FORGE_LOOP_MAX_BLOCKS = 30;
+const FORGE_LOOP_STALE_MS = 2 * 60 * 60 * 1000; // 2시간
+/**
+ * forge-loop 활성 시 미완료 스토리가 있으면 Stop을 차단하고 지속 메시지 주입.
+ * OMC의 persistent-mode.cjs 패턴 참고.
+ */
+export function checkForgeLoopActive() {
+    try {
+        if (!fs.existsSync(FORGE_LOOP_STATE_PATH))
+            return null;
+        const state = JSON.parse(fs.readFileSync(FORGE_LOOP_STATE_PATH, 'utf-8'));
+        if (!state.active)
+            return null;
+        // Stale 감지: 2시간+ 미활동 → 자동 비활성화
+        const startedAt = new Date(state.startedAt).getTime();
+        if (Number.isFinite(startedAt) && Date.now() - startedAt > FORGE_LOOP_STALE_MS) {
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 확인 대기 중이면 차단하지 않음 (사용자 개입 허용)
+        if (state.awaitingConfirmation)
+            return null;
+        // 안전 상한: 30회 이상 차단 시 무한 루프로 간주하여 해제
+        const blockCount = state.blockCount ?? 0;
+        if (blockCount >= FORGE_LOOP_MAX_BLOCKS) {
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 미완료 스토리 확인
+        const stories = Array.isArray(state.stories) ? state.stories : [];
+        const pending = stories.filter((s) => !s.passes);
+        if (pending.length === 0) {
+            // 모든 스토리 완료 → forge-loop 종료
+            state.active = false;
+            atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+            return null;
+        }
+        // 차단 카운트 증가 + 지속 메시지 주입
+        state.blockCount = blockCount + 1;
+        state.lastBlockAt = new Date().toISOString();
+        atomicWriteJSON(FORGE_LOOP_STATE_PATH, state);
+        const nextStory = pending[0];
+        const message = [
+            `<forgen-forge-loop iteration="${state.blockCount}/${FORGE_LOOP_MAX_BLOCKS}">`,
+            `[FORGE-LOOP] ${pending.length}개 스토리가 미완료입니다.`,
+            `현재 스토리: ${nextStory.id} — ${nextStory.title}`,
+            ``,
+            `계속 진행하세요. 보고는 다음 시점에만 합니다:`,
+            `  1. 모든 스토리 완료 (최종 리포트)`,
+            `  2. 3회 실패 (에스컬레이션)`,
+            `  3. Context limit 접근 (handoff)`,
+            ``,
+            `중간 "완료했습니다" 보고는 polite-stop anti-pattern입니다.`,
+            `취소하려면: "/forge-loop cancel" 또는 "cancelforgen" 입력`,
+            `</forgen-forge-loop>`,
+        ].join('\n');
+        // block 결정으로 Claude가 계속 작업하도록 강제
+        return JSON.stringify({
+            continue: true,
+            decision: 'block',
+            reason: message,
+        });
+    }
+    catch (e) {
+        // fail-open: forge-loop 상태 읽기 실패는 차단하지 않음
+        log.debug('forge-loop 상태 확인 실패', e);
+        return null;
+    }
+}
 function saveHandoff(sessionId, reason, detail) {
     fs.mkdirSync(HANDOFFS_DIR, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-');

package/dist/hooks/hooks-generator.d.ts

@@ -9,6 +9,7 @@
  *   - forgen config hooks (사용자 설정 변경 후)
  *   - forgen install (플러그인 설치 후)
  */
+import { type RuntimeHost } from '../core/types.js';
 interface HookCommand {
     type: 'command';
     command: string;
@@ -27,6 +28,8 @@ interface GenerateOptions {
     cwd?: string;
     /** 훅 실행 스크립트의 루트 경로 */
     pluginRoot?: string;
+    /** 런타임 (claude|codex) */
+    runtime?: RuntimeHost;
 }
 /**
  * 활성 훅만 포함한 hooks.json 객체를 생성합니다.

package/dist/hooks/hooks-generator.js

@@ -14,6 +14,27 @@ import * as path from 'node:path';
 import { HOOK_REGISTRY } from './hook-registry.js';
 import { isHookEnabled } from './hook-config.js';
 import { detectInstalledPlugins, getHookConflicts } from '../core/plugin-detector.js';
+function splitCommand(raw) {
+    const tokens = raw.match(/"([^"]+)"|\S+/g) ?? [];
+    const unquoted = tokens.map(token => token.replace(/^"/, '').replace(/"$/, ''));
+    return { script: unquoted[0] ?? '', args: unquoted.slice(1) };
+}
+function quoteArg(raw) {
+    return `"${raw.replace(/"/g, '\\"')}"`;
+}
+function buildHookCommand(pluginRoot, rawScript, runtime) {
+    const { script, args } = splitCommand(rawScript);
+    const scriptPath = `${pluginRoot}/${script}`;
+    const quotedArgs = args.map(quoteArg).join(' ');
+    if (runtime === 'codex') {
+        const adapterPath = `${pluginRoot}/host/codex-adapter.js`;
+        const baseCommand = `node ${quoteArg(adapterPath)} ${quoteArg(scriptPath)}`;
+        return `${baseCommand}${quotedArgs ? ` ${quotedArgs}` : ''}`;
+    }
+    return quotedArgs
+        ? `node ${quoteArg(scriptPath)} ${quotedArgs}`
+        : `node ${quoteArg(scriptPath)}`;
+}
 /**
  * 활성 훅만 포함한 hooks.json 객체를 생성합니다.
  *
@@ -27,6 +48,7 @@ export function generateHooksJson(options) {
     const cwd = options?.cwd;
     // biome-ignore lint/suspicious/noTemplateCurlyInString: CLAUDE_PLUGIN_ROOT is a Claude Code Plugin SDK variable resolved at runtime
     const pluginRoot = options?.pluginRoot ?? '${CLAUDE_PLUGIN_ROOT}/dist';
+    const runtime = options?.runtime ?? 'claude';
     // 다른 플러그인의 충돌 훅 감지
     const hookConflicts = getHookConflicts(cwd);
     const detectedPlugins = detectInstalledPlugins(cwd);
@@ -64,12 +86,7 @@ export function generateHooksJson(options) {
         hooks[event] = [...byMatcher.entries()].map(([matcher, matcherEntries]) => ({
             matcher,
             hooks: matcherEntries.map(h => {
-                // script에 인자가 포함된 경우 (예: "hooks/subagent-tracker.js start")
-                // 파일 경로와 인자를 분리해야 셸에서 ENOENT를 방지
-                const spaceIdx = h.script.indexOf(' ');
-                const command = spaceIdx === -1
-                    ? `node "${pluginRoot}/${h.script}"`
-                    : `node "${pluginRoot}/${h.script.slice(0, spaceIdx)}" ${h.script.slice(spaceIdx + 1)}`;
+                const command = buildHookCommand(pluginRoot, h.script, runtime);
                 return { type: 'command', command, timeout: h.timeout };
             }),
         }));

package/dist/hooks/keyword-detector.js

@@ -29,7 +29,7 @@ import { recordHookTiming } from './shared/hook-timing.js';
 function escapeXmlAttr(s) {
     return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
-const WORKFLOW_TRACKED_INJECTS = new Set(['benchmark']);
+const WORKFLOW_TRACKED_INJECTS = new Set();
 export function shouldTrackWorkflowActivation(match) {
     if (match.type === 'inject')
         return WORKFLOW_TRACKED_INJECTS.has(match.keyword);
@@ -51,21 +51,17 @@ export const KEYWORD_PATTERNS = [
     { pattern: /\bccg\b/i, keyword: 'ccg', type: 'skill', skill: 'ccg' },
     { pattern: /\bralplan\b/i, keyword: 'ralplan', type: 'skill', skill: 'ralplan' },
     { pattern: /\bdeep[- ]?interview\b/i, keyword: 'deep-interview', type: 'skill', skill: 'deep-interview' },
-    { pattern: /\bspecify\b|(?:^|\s)(명세|요구사항\s*정리|스펙\s*정리)(?:\s|$)/im, keyword: 'specify', type: 'skill', skill: 'specify' },
     { pattern: /\bpipeline\b/i, keyword: 'pipeline', type: 'skill', skill: 'pipeline' },
-    { pattern: /\becomode\b|(?:^|\s)(에코\s*모드|토큰\s*절약)(?:\s|$)/im, keyword: 'ecomode', type: 'skill', skill: 'ecomode' },
     // 인젝션 모드
     { pattern: /\bultrathink\b/i, keyword: 'ultrathink', type: 'inject' },
     { pattern: /\bdeepsearch\b/i, keyword: 'deepsearch', type: 'inject' },
-    { pattern: /(?:^|\s)tdd(?:\s+(?:모드|mode|방식|으로|해|해줘|시작|적용)|\s*$)/im, keyword: 'tdd', type: 'skill', skill: 'tdd' },
     { pattern: /(?:code[- ]?review|코드\s*리뷰)\s*(?:해|해줘|시작|해봐|부탁|mode|모드)/i, keyword: 'code-review', type: 'skill', skill: 'code-review' },
-    { pattern: /(?:security[- ]?review|보안\s*리뷰|보안\s*검토)\s*(?:해|해줘|시작|해봐|부탁|mode|모드)/i, keyword: 'security-review', type: 'skill', skill: 'security-review' },
-    // 실용 스킬 — 명시적 모드 호출만 매칭 (일상 단어 false positive 방지)
-    { pattern: /\bgit[- ]?master\b/i, keyword: 'git-master', type: 'skill', skill: 'git-master' },
-    { pattern: /\b(benchmark)\s*(?:mode|모드|해|해줘|시작|실행|돌려)|(?:^|\s)(벤치마크)\s*(?:mode|모드|해|해줘|시작|실행|돌려)|(?:^|\s)성능\s*측정/im, keyword: 'benchmark', type: 'inject' },
-    { pattern: /\b(migrate)\s*(?:mode|모드|해|해줘|시작|실행|진행)|(?:^|\s)(마이그레이션)\s*(?:mode|모드|해|해줘|시작|실행|진행)/im, keyword: 'migrate', type: 'skill', skill: 'migrate' },
-    { pattern: /\b(debug[- ]?detective)\b|(?:^|\s)(디버그\s*탐정|체계적\s*디버깅)(?:\s|$)/im, keyword: 'debug-detective', type: 'skill', skill: 'debug-detective' },
-    { pattern: /\b(refactor)\s*(?:mode|모드|해|해줘|시작|실행|진행)|(?:^|\s)(리팩토링|리팩터)\s*(?:mode|모드|해|해줘|시작|실행|진행)/im, keyword: 'refactor', type: 'skill', skill: 'refactor' },
+    // forgen 핵심 스킬
+    { pattern: /\b(forge[- ]?loop|포지[- ]?루프)\b|(?:^|\s)(끝까지|don'?t\s*stop)(?:\s|$)/im, keyword: 'forge-loop', type: 'skill', skill: 'forge-loop' },
+    { pattern: /(?:^|\s)ship(?:\s|$)|(?:^|\s)(배포|릴리스)\s*(?:해|해줘|하자|시작|진행)/im, keyword: 'ship', type: 'skill', skill: 'ship' },
+    { pattern: /\bretro\b|(?:^|\s)(회고|돌아보기)(?:\s|$)/im, keyword: 'retro', type: 'skill', skill: 'retro' },
+    { pattern: /(?:^|\s)learn\s+(?:search|prune|stats|export)|(?:^|\s)(학습\s*관리|compound\s*정리|솔루션\s*정리)/im, keyword: 'learn', type: 'skill', skill: 'learn' },
+    { pattern: /\bcalibrate\b|(?:^|\s)(캘리브|프로필\s*보정|프로필\s*조정|프로필\s*확인)(?:\s|$)/im, keyword: 'calibrate', type: 'skill', skill: 'calibrate' },
 ];
 // ── 인젝션 메시지 ──
 const INJECT_MESSAGES = {
@@ -84,98 +80,12 @@ Perform comprehensive codebase exploration before answering:
 4. Cross-reference findings across files
 5. Present a complete, evidence-based analysis
 </compound-deepsearch>`,
-    tdd: `<compound-tdd>
-TDD MODE ACTIVATED.
-Follow strict Test-Driven Development:
-1. Write the failing test FIRST (Red)
-2. Write the minimum code to pass (Green)
-3. Refactor while keeping tests green (Refactor)
-4. Repeat for each requirement
-Never write implementation before tests.
-</compound-tdd>`,
-    'code-review': `<compound-code-review>
-CODE REVIEW MODE ACTIVATED.
-Perform thorough code review with severity ratings:
-- 🔴 CRITICAL: Security vulnerabilities, data loss risks, crashes
-- 🟡 MAJOR: Logic errors, performance issues, missing error handling
-- 🔵 MINOR: Style, naming, documentation improvements
-- 💡 SUGGESTION: Optional enhancements
-Provide file:line references for every finding.
-</compound-code-review>`,
-    'security-review': `<compound-security-review>
-SECURITY REVIEW MODE ACTIVATED.
-Check for OWASP Top 10 and common vulnerabilities:
-1. Injection (SQL, XSS, Command)
-2. Broken Authentication / Authorization
-3. Sensitive Data Exposure
-4. Security Misconfiguration
-5. Insecure Dependencies
-6. Secrets in code (API keys, tokens, passwords)
-7. Input validation gaps
-8. Unsafe deserialization
-Rate each finding: CRITICAL / HIGH / MEDIUM / LOW
-</compound-security-review>`,
-    'git-master': `<compound-git-master>
-GIT MASTER MODE ACTIVATED.
-Apply atomic commit strategy and clean history management:
-1. One commit = one logical change (atomic)
-2. Follow Conventional Commits: feat/fix/refactor/docs/chore(<scope>): <subject>
-3. Use interactive rebase (git rebase -i) to clean up WIP commits before pushing
-4. Never force-push to shared branches (main, develop)
-5. Use git bisect for systematic bug hunt across commits
-Commit message format: <type>(<scope>): <subject> — imperative, 50 chars max
-</compound-git-master>`,
-    benchmark: `<compound-benchmark>
-BENCHMARK MODE ACTIVATED.
-Measure performance with statistical rigor:
-1. Collect baseline metrics FIRST (before any changes)
-2. Run minimum 30 iterations (skip first 5 as warmup)
-3. Calculate: avg, p95, p99, min, max
-4. Measure: execution time (performance.now()), memory (process.memoryUsage()), bundle size
-5. Output before/after comparison table with delta percentages
-6. Use same environment for both measurements to ensure validity
-</compound-benchmark>`,
-    migrate: `<compound-migrate>
-MIGRATION MODE ACTIVATED.
-Follow the 5-phase safe migration workflow:
-1. ANALYZE: Document current state, identify breaking changes, map affected files
-2. PLAN: Decompose into atomic steps, define rollback triggers (error rate > N%)
-3. BACKUP: Create DB dump + git tag as restore point before any changes
-4. EXECUTE: Apply Expand-Contract pattern for zero-downtime DB changes
-5. VERIFY: Run E2E tests, check data integrity, validate performance regression
-Rollback criteria: error rate spike, latency > 2x baseline, data inconsistency
-</compound-migrate>`,
-    'debug-detective': `<compound-debug-detective>
-DEBUG DETECTIVE MODE ACTIVATED.
-Follow the Reproduce → Isolate → Fix → Verify loop:
-1. REPRODUCE: Document exact conditions, input, expected vs actual, reproduction rate
-2. ISOLATE: Classify error type (runtime/type/logic/async), use git bisect for regression
-3. FIX: Address root cause (not symptoms), minimize change scope
-4. VERIFY: Add regression test, confirm fix in staging before production
-Error classification:
-- Runtime: TypeError/ReferenceError → trace stack
-- Logic: wrong output → add intermediate logging
-- Async: race condition → check Promise chain, event ordering
-Never guess — always reproduce first.
-</compound-debug-detective>`,
-    refactor: `<compound-refactor>
-REFACTOR MODE ACTIVATED.
-Safe refactoring with test-first approach:
-1. SECURE TESTS: Characterization tests for untested code before touching anything
-2. IDENTIFY SMELLS: Long functions (>50 lines), duplication, deep nesting (>3), magic numbers
-3. APPLY SOLID: Single responsibility, Open-closed, Liskov, Interface segregation, Dependency inversion
-4. REFACTOR CATALOG: Extract Method, Move Method, Replace Conditional with Polymorphism
-5. VERIFY: Run full test suite after each refactoring step
-Rules:
-- Never mix refactoring + feature changes in the same commit
-- One refactoring pattern per commit
-- Keep tests green at all times
-</compound-refactor>`,
 };
 // ── 스킬 파일 로드 ──
 function loadSkillContent(skillName) {
-    // 스킬 파일 검색 순서: 프로젝트 > 연결된 팩 > 글로벌 팩 > 글로벌 > 패키지 내장
+    // 스킬 파일 검색 순서: 프로젝트 .forgen > 프로젝트 .compound > 팩 > 개인 > 글로벌 > 패키지 내장
     const searchPaths = [
+        path.join(process.cwd(), '.forgen', 'skills', `${skillName}.md`),
         path.join(process.cwd(), '.compound', 'skills', `${skillName}.md`),
         path.join(process.cwd(), 'skills', `${skillName}.md`),
     ];
@@ -302,7 +212,7 @@ async function main() {
                 catch { /* 파일 없으면 무시 */ }
             }
             else {
-                // 모든 모드 상태 초기화 (ralplan, deep-interview 포함)
+                // 모든 모드 상태 초기화 (ralplan, deep-interview, forge-loop 등 포함)
                 for (const mode of ALL_MODES) {
                     clearState(`${mode}-state`);
                 }
@@ -311,6 +221,12 @@ async function main() {
                     fs.unlinkSync(ralphLoopState);
                 }
                 catch { /* 파일 없으면 무시 */ }
+                // forge-loop 상태 파일도 명시적으로 삭제 (Stop 훅 차단 해제)
+                const forgeLoopState = path.join(STATE_DIR, 'forge-loop.json');
+                try {
+                    fs.unlinkSync(forgeLoopState);
+                }
+                catch { /* 파일 없으면 무시 */ }
             }
             // skill-cache 파일도 정리 (재주입 가능하도록)
             cleanSkillCaches();

package/dist/hooks/skill-injector.d.ts

@@ -5,10 +5,11 @@
  * Claude Code UserPromptSubmit 훅으로 등록.
  * 프롬프트와 매칭되는 학습된 스킬을 자동으로 컨텍스트에 주입합니다.
  *
- * 스킬 파일 위치:
+ * 스킬 파일 위치 (우선순위):
+ *   0. {project}/.forgen/skills/*.md    (프로젝트 포지 스킬 — 최우선)
  *   1. {project}/.compound/skills/*.md  (프로젝트 스킬)
- *   2. ~/.compound/skills/*.md          (글로벌 스킬)
- *   3. ~/.compound/me/skills/*.md       (개인 학습 스킬)
+ *   2. ~/.forgen/me/skills/*.md         (개인 학습 스킬)
+ *   3. ~/.forgen/skills/*.md            (글로벌 스킬)
  *
  * 스킬 포맷:
  *   ---

package/dist/hooks/skill-injector.js

@@ -5,10 +5,11 @@
  * Claude Code UserPromptSubmit 훅으로 등록.
  * 프롬프트와 매칭되는 학습된 스킬을 자동으로 컨텍스트에 주입합니다.
  *
- * 스킬 파일 위치:
+ * 스킬 파일 위치 (우선순위):
+ *   0. {project}/.forgen/skills/*.md    (프로젝트 포지 스킬 — 최우선)
  *   1. {project}/.compound/skills/*.md  (프로젝트 스킬)
- *   2. ~/.compound/skills/*.md          (글로벌 스킬)
- *   3. ~/.compound/me/skills/*.md       (개인 학습 스킬)
+ *   2. ~/.forgen/me/skills/*.md         (개인 학습 스킬)
+ *   3. ~/.forgen/skills/*.md            (글로벌 스킬)
  *
  * 스킬 포맷:
  *   ---
@@ -181,8 +182,9 @@ function collectSkills() {
     const seen = new Map(); // name → source dir
     // 패키지 내장 스킬 경로 (dist/../skills/)
     const pkgSkillsDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'commands');
-    // v1: 팀 팩 스킬 제거. 프로젝트 > 개인 > 글로벌 > 패키지 내장
+    // 프로젝트 .forgen > 프로젝트 .compound > 개인 > 글로벌 > 패키지 내장
     const dirs = [
+        path.join(process.cwd(), '.forgen', 'skills'),
         path.join(process.cwd(), '.compound', 'skills'),
         path.join(ME_DIR, 'skills'),
         path.join(FORGEN_HOME, 'skills'),

package/dist/host/codex-adapter.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Codex 훅 어댑터
+ *
+ * 목적:
+ * - codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema로 정규화
+ * - continue 누락 또는 codex 특화 판정 필드(approved/decision) 대응
+ * - 파싱 실패/실행 실패 시 fail-open(continue: true)
+ */
+export {};

package/dist/host/codex-adapter.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Codex 훅 어댑터
+ *
+ * 목적:
+ * - codex 런타임에서 실행되는 훅 스크립트 출력을 Claude Hook schema로 정규화
+ * - continue 누락 또는 codex 특화 판정 필드(approved/decision) 대응
+ * - 파싱 실패/실행 실패 시 fail-open(continue: true)
+ */
+import { spawnSync } from 'node:child_process';
+function parseDecision(raw) {
+    if (typeof raw === 'boolean') {
+        return { continueFlag: raw };
+    }
+    if (typeof raw === 'string') {
+        const normalized = raw.toLowerCase();
+        if (normalized === 'continue')
+            return { continueFlag: true };
+        if (normalized === 'stop' || normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
+            return { continueFlag: false, permissionDecision: normalized };
+        }
+        return { continueFlag: true };
+    }
+    if (typeof raw !== 'object' || raw === null)
+        return { continueFlag: true };
+    const value = raw.decision;
+    if (typeof value === 'string') {
+        const normalized = value.toLowerCase();
+        if (normalized === 'deny' || normalized === 'reject' || normalized === 'block') {
+            return { continueFlag: false, permissionDecision: normalized };
+        }
+        if (normalized === 'ask' || normalized === 'prompt' || normalized === 'confirm') {
+            return { continueFlag: true, permissionDecision: normalized };
+        }
+    }
+    if (typeof raw.approved === 'boolean') {
+        const approved = raw.approved;
+        return approved
+            ? { continueFlag: true, permissionDecision: raw.decision || 'approve' }
+            : { continueFlag: false, permissionDecision: 'deny' };
+    }
+    if (typeof raw.continue === 'boolean') {
+        return { continueFlag: raw.continue };
+    }
+    return { continueFlag: true };
+}
+function lastJSONObjectFromText(raw) {
+    const lines = raw.split('\n').map((line) => line.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        try {
+            return JSON.parse(lines[i]);
+        }
+        catch {
+            // continue
+        }
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeOutput(raw, input) {
+    const result = { continue: true };
+    const decision = parseDecision(raw);
+    result.continue = decision.continueFlag;
+    if (typeof raw === 'object' && raw !== null) {
+        const payload = raw;
+        if (typeof payload.continue === 'boolean')
+            result.continue = payload.continue;
+        if (typeof payload.systemMessage === 'string')
+            result.systemMessage = payload.systemMessage;
+        if (typeof payload.suppressOutput === 'boolean')
+            result.suppressOutput = payload.suppressOutput;
+        if (typeof payload.hookSpecificOutput === 'object' && payload.hookSpecificOutput !== null) {
+            result.hookSpecificOutput = { ...payload.hookSpecificOutput };
+        }
+        if (typeof payload.decision === 'string') {
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: payload.decision,
+            };
+        }
+    }
+    const eventName = result.hookSpecificOutput?.hookEventName ?? input.hookEventName ?? input.event;
+    if (eventName) {
+        result.hookSpecificOutput = {
+            hookEventName: eventName,
+            ...(result.hookSpecificOutput ?? {}),
+        };
+    }
+    if (!result.continue && !result.hookSpecificOutput?.permissionDecision) {
+        if (decision.permissionDecision)
+            result.hookSpecificOutput = {
+                ...(result.hookSpecificOutput ?? {}),
+                permissionDecision: decision.permissionDecision,
+            };
+        else
+            result.hookSpecificOutput = { ...(result.hookSpecificOutput ?? {}), permissionDecision: 'deny' };
+    }
+    return result;
+}
+async function main() {
+    const [delegatePath, ...restArgs] = process.argv.slice(2);
+    if (!delegatePath) {
+        console.log(JSON.stringify({ continue: true }));
+        return;
+    }
+    const input = await (async () => {
+        const chunks = [];
+        let totalBytes = 0;
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+            totalBytes += chunk.length;
+            if (totalBytes > 10 * 1024 * 1024)
+                break;
+        }
+        const raw = Buffer.concat(chunks.map(c => typeof c === 'string' ? Buffer.from(c) : c)).toString('utf-8').trim();
+        if (!raw)
+            return {};
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return {};
+        }
+    })();
+    try {
+        const result = spawnSync(process.execPath, [delegatePath, ...restArgs], {
+            encoding: 'utf-8',
+            input: JSON.stringify(input),
+            cwd: process.cwd(),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (result.error) {
+            console.log(JSON.stringify({ continue: true }));
+            return;
+        }
+        const parsed = lastJSONObjectFromText(result.stdout ?? '');
+        if (!parsed) {
+            console.log(JSON.stringify({ continue: true }));
+            return;
+        }
+        const output = normalizeOutput(parsed, input);
+        console.log(JSON.stringify(output));
+    }
+    catch {
+        console.log(JSON.stringify({ continue: true }));
+    }
+}
+main().catch(() => {
+    console.log(JSON.stringify({ continue: true }));
+});