@wooojin/forgen 0.2.1 → 0.3.1

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/post-tool-failure.js

@@ -105,6 +105,13 @@ async function main() {
     saveFailureState(state);
     // 컨텍스트 신호 업데이트
     incrementFailureSignal(sessionId);
+    // Outcome tracking (Phase 1): attribute this tool failure to pending
+    // solution injections in the same session. Fail-open.
+    try {
+        const { attributeError } = await import('../engine/solution-outcomes.js');
+        attributeError(sessionId);
+    }
+    catch { /* ignore */ }
     const failCount = state.failures[toolName].count;
     const suggestion = getRecoverySuggestion(error, toolName);
     // 3회 이상 반복 실패 시 강화된 경고

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/hooks/solution-injector.js

@@ -28,6 +28,7 @@ import { writeSignal } from './shared/plugin-signal.js';
 import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
 import { STATE_DIR } from '../core/paths.js';
 import { recordHookTiming } from './shared/hook-timing.js';
+import { appendPending, flushAccept } from '../engine/solution-outcomes.js';
 const MAX_SOLUTIONS_PER_SESSION = 10;
 /** 세션별 이미 주입된 솔루션 추적 (중복 방지) */
 function getSessionCachePath(sessionId) {
@@ -451,6 +452,25 @@ async function main() {
         catch (e) {
             log.debug('plugin signal 기록 실패', e);
         }
+        // Outcome tracking (Phase 1): flush previous pending as `accept` (silence
+        // = consent), then record this round's injections as new pending. Both
+        // calls are fail-open — a tracking crash must not block injection.
+        try {
+            flushAccept(sessionId);
+        }
+        catch (e) {
+            log.debug('outcome flushAccept 실패', e);
+        }
+        try {
+            appendPending(sessionId, effectiveToInject.map((sol) => ({
+                solution: sol.name,
+                match_score: sol.relevance,
+                injected_chars: (summaries.get(sol.name) ?? sol.name).length,
+            })));
+        }
+        catch (e) {
+            log.debug('outcome appendPending 실패', e);
+        }
         console.log(approveWithContext(fullInjection, 'UserPromptSubmit'));
     }
     finally {

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 }));
+});

package/dist/mcp/solution-reader.d.ts

@@ -13,8 +13,8 @@
  *   - 인덱스 캐시는 isIndexStale()에 의존 (resetIndexCache 미사용)
  *     → 디렉토리 mtime이 변하지 않으면 캐시 재사용 (성능)
  */
-import type { SolutionDirConfig } from '../engine/solution-index.js';
 import type { SolutionStatus, SolutionType } from '../engine/solution-format.js';
+import type { SolutionDirConfig } from '../engine/solution-index.js';
 export interface SearchOptions {
     dirs?: SolutionDirConfig[];
     type?: SolutionType;
@@ -25,7 +25,7 @@ export interface ListOptions {
     dirs?: SolutionDirConfig[];
     status?: SolutionStatus;
     type?: SolutionType;
-    scope?: 'me' | 'team' | 'project';
+    scope?: 'me' | 'team' | 'project' | 'universal';
     sort?: 'confidence' | 'updated' | 'name';
 }
 export interface SolutionSummary {
@@ -33,7 +33,7 @@ export interface SolutionSummary {
     status: SolutionStatus;
     confidence: number;
     type: SolutionType;
-    scope: 'me' | 'team' | 'project';
+    scope: 'me' | 'team' | 'project' | 'universal';
     tags: string[];
 }
 export interface SearchResult extends SolutionSummary {
@@ -45,7 +45,7 @@ export interface SolutionDetail {
     status: SolutionStatus;
     confidence: number;
     type: SolutionType;
-    scope: 'me' | 'team' | 'project';
+    scope: 'me' | 'team' | 'project' | 'universal';
     tags: string[];
     identifiers: string[];
     context: string;
@@ -55,7 +55,7 @@ export interface SolutionStats {
     total: number;
     byStatus: Record<SolutionStatus, number>;
     byType: Record<SolutionType, number>;
-    byScope: Record<'me' | 'team' | 'project', number>;
+    byScope: Record<'me' | 'team' | 'project' | 'universal', number>;
 }
 /**
  * 기본 솔루션 디렉토리 목록 생성.