@wooojin/forgen 0.1.0

package/dist/hooks/subagent-tracker.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Forgen — SubagentStart/Stop Hook
+ *
+ * 에이전트 생성/종료 추적.
+ * - 활성 에이전트 수 모니터링
+ * - 에이전트 동시 실행 제한 (10개 초과 시 경고)
+ * - 에이전트 실행 이력 기록
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { readStdinJSON } from './shared/read-stdin.js';
+import { isHookEnabled } from './hook-config.js';
+import { sanitizeId } from './shared/sanitize-id.js';
+import { atomicWriteJSON } from './shared/atomic-write.js';
+import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { STATE_DIR } from '../core/paths.js';
+const MAX_CONCURRENT_AGENTS = 10;
+const AGENT_GC_AGE_MS = 60 * 60 * 1000; // 1시간 이상 종료된 에이전트는 GC
+function getAgentsStatePath(sessionId) {
+    return path.join(STATE_DIR, `active-agents-${sanitizeId(sessionId)}.json`);
+}
+function loadAgentsState(sessionId) {
+    try {
+        const filePath = getAgentsStatePath(sessionId);
+        if (fs.existsSync(filePath)) {
+            return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+    }
+    catch { /* agent state parse failure — starting fresh, active agent count history for this session is lost */ }
+    return { sessionId, agents: [] };
+}
+function saveAgentsState(state) {
+    // GC: 1시간 이상 종료된 에이전트 제거
+    const now = Date.now();
+    state.agents = state.agents.filter(a => {
+        if (!a.stoppedAt)
+            return true; // 활성 에이전트는 유지
+        return now - new Date(a.stoppedAt).getTime() < AGENT_GC_AGE_MS;
+    });
+    atomicWriteJSON(getAgentsStatePath(state.sessionId), state);
+}
+async function main() {
+    const data = await readStdinJSON();
+    // hook-registry에서는 subagent-tracker-start/stop으로 분리 등록됨
+    const suffix = process.argv[2] === 'stop' ? 'stop' : 'start';
+    if (!isHookEnabled(`subagent-tracker-${suffix}`)) {
+        console.log(approve());
+        return;
+    }
+    if (!data) {
+        console.log(approve());
+        return;
+    }
+    const sessionId = data.session_id ?? 'default';
+    // 이벤트 타입은 argv[2] 또는 data 필드에서 판별
+    const action = process.argv[2] ?? data.action ?? '';
+    const agentId = data.agent_id ?? data.agentId ?? `agent-${Date.now()}`;
+    const agentType = data.agent_type ?? data.agentType ?? data.subagent_type ?? '';
+    const state = loadAgentsState(sessionId);
+    if (action === 'start') {
+        const model = data.model ?? data.agentModel ?? undefined;
+        state.agents.push({
+            agentId,
+            agentType: agentType || undefined,
+            model,
+            startedAt: new Date().toISOString(),
+        });
+        saveAgentsState(state);
+        // 활성 에이전트 수 체크
+        const activeCount = state.agents.filter(a => !a.stoppedAt).length;
+        if (activeCount > MAX_CONCURRENT_AGENTS) {
+            console.log(approveWithWarning(`<compound-tool-warning>\n[Forgen] ⚠ ${activeCount} active agents — too many concurrent executions. Watch resource usage.\n</compound-tool-warning>`));
+            return;
+        }
+    }
+    else if (action === 'stop') {
+        // 해당 에이전트 종료 표시
+        const agent = state.agents.find(a => a.agentId === agentId && !a.stoppedAt);
+        if (agent) {
+            agent.stoppedAt = new Date().toISOString();
+        }
+        saveAgentsState(state);
+    }
+    console.log(approve());
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpen());
+});

package/dist/i18n/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Forgen — i18n (English / Korean)
+ *
+ * 내부 타입은 한글 유지 (QualityPack = '보수형' | ...).
+ * 사용자 대면 출력만 로케일에 따라 전환.
+ */
+import type { QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, TrustPolicy } from '../store/types.js';
+export type Locale = 'en' | 'ko';
+export declare function qualityName(pack: QualityPack, locale: Locale): string;
+export declare function autonomyName(pack: AutonomyPack, locale: Locale): string;
+export declare function judgmentName(pack: JudgmentPack, locale: Locale): string;
+export declare function communicationName(pack: CommunicationPack, locale: Locale): string;
+export declare function trustName(policy: TrustPolicy, locale: Locale): string;
+export interface OnboardingStrings {
+    header: string;
+    subtitle: string;
+    q1: string;
+    q2: string;
+    q3: string;
+    q4: string;
+    resultHeader: string;
+    profileSaved: string;
+    invalidChoice: string;
+}
+export declare const ONBOARDING: Record<Locale, OnboardingStrings>;
+export interface RuleRendererStrings {
+    trustGuardrails: string;
+    trustRelaxed: string;
+    trustFullTrust: string;
+    evidenceCollectionHeader: string;
+    evidenceCollectionRules: string[];
+    judgmentMinimalChange: string[];
+    judgmentBalanced: string[];
+    judgmentStructural: string[];
+    commConcise: string[];
+    commBalanced: string[];
+    commDetailed: string[];
+}
+export declare const RULE_RENDERER: Record<Locale, RuleRendererStrings>;
+export declare function setLocale(locale: Locale): void;
+export declare function getLocale(): Locale;
+/** GlobalConfig에서 locale을 읽어 설정. 없으면 'en' 기본값. */
+export declare function initLocaleFromConfig(): void;

package/dist/i18n/index.js

@@ -0,0 +1,224 @@
+/**
+ * Forgen — i18n (English / Korean)
+ *
+ * 내부 타입은 한글 유지 (QualityPack = '보수형' | ...).
+ * 사용자 대면 출력만 로케일에 따라 전환.
+ */
+// ── Pack Display Names ──
+const QUALITY_NAMES = {
+    ko: { '보수형': '보수형', '균형형': '균형형', '속도형': '속도형' },
+    en: { '보수형': 'Conservative', '균형형': 'Balanced', '속도형': 'Speed-first' },
+};
+const AUTONOMY_NAMES = {
+    ko: { '확인 우선형': '확인 우선형', '균형형': '균형형', '자율 실행형': '자율 실행형' },
+    en: { '확인 우선형': 'Confirm-first', '균형형': 'Balanced', '자율 실행형': 'Autonomous' },
+};
+const JUDGMENT_NAMES = {
+    ko: { '최소변경형': '최소변경형', '균형형': '균형형', '구조적접근형': '구조적접근형' },
+    en: { '최소변경형': 'Minimal-change', '균형형': 'Balanced', '구조적접근형': 'Structural' },
+};
+const COMMUNICATION_NAMES = {
+    ko: { '간결형': '간결형', '균형형': '균형형', '상세형': '상세형' },
+    en: { '간결형': 'Concise', '균형형': 'Balanced', '상세형': 'Detailed' },
+};
+const TRUST_NAMES = {
+    ko: { '가드레일 우선': '가드레일 우선', '승인 완화': '승인 완화', '완전 신뢰 실행': '완전 신뢰 실행' },
+    en: { '가드레일 우선': 'Guardrails-first', '승인 완화': 'Relaxed-approval', '완전 신뢰 실행': 'Full-trust' },
+};
+export function qualityName(pack, locale) { return QUALITY_NAMES[locale][pack]; }
+export function autonomyName(pack, locale) { return AUTONOMY_NAMES[locale][pack]; }
+export function judgmentName(pack, locale) { return JUDGMENT_NAMES[locale][pack]; }
+export function communicationName(pack, locale) { return COMMUNICATION_NAMES[locale][pack]; }
+export function trustName(policy, locale) { return TRUST_NAMES[locale][policy]; }
+export const ONBOARDING = {
+    ko: {
+        header: '  Forgen — 개인화 온보딩',
+        subtitle: '  4개의 상황 질문으로 당신의 작업 스타일을 파악합니다.\n  이 결과는 임시 추천이며, 첫 세션 이후 확정됩니다.',
+        q1: `
+  ─────────────────────────────────────────
+  질문 1: 애매한 구현 요청
+
+  "로그인 기능을 개선해줘"라는 요청을 받았습니다.
+  요구사항이 명확하지 않고, 인접 모듈에 영향을 줄 수 있습니다.
+
+  A) 먼저 요구사항/범위를 확인하고, 범위 확대 가능성이 있으면 물어본다
+  B) 같은 흐름 안이면 진행하되, 큰 범위 확대가 보이면 확인한다
+  C) 합리적으로 가정하고 인접 파일까지 바로 수정한다
+
+  선택 (A/B/C): `,
+        q2: `
+  ─────────────────────────────────────────
+  질문 2: 검증 강도 vs 완료 속도
+
+  수정이 거의 끝났습니다. 테스트와 타입 검사가 남아 있습니다.
+
+  A) 관련 테스트, 타입, 핵심 검증을 끝내기 전에는 완료라 하지 않는다
+  B) 핵심 검증 1개 이상 하고, 남은 리스크를 요약해서 끝낸다
+  C) 최소 smoke만 보고 빠르게 결과와 리스크만 보고한다
+
+  선택 (A/B/C): `,
+        q3: `
+  ─────────────────────────────────────────
+  질문 3: 코드 수정 접근법
+
+  레거시 코드에서 반복 패턴을 발견했습니다. 동작은 하지만 구조가 좋지 않습니다.
+
+  A) 현재 동작을 깨뜨리지 않도록 최소한만 수정한다
+  B) 관련된 부분만 정리하되, 전체 구조 변경은 하지 않는다
+  C) 이왕 손대는 거 주변 코드까지 구조적으로 정리한다
+
+  선택 (A/B/C): `,
+        q4: `
+  ─────────────────────────────────────────
+  질문 4: 설명/보고 스타일
+
+  복잡한 버그를 수정했습니다. 결과를 보고해야 합니다.
+
+  A) 무엇을 왜 바꿨는지, 영향 범위, 대안까지 상세하게 설명한다
+  B) 핵심 변경과 이유를 요약하고, 필요하면 추가 질문을 유도한다
+  C) 변경 사항만 간결하게 보고한다
+
+  선택 (A/B/C): `,
+        resultHeader: '  추천 결과 (임시)',
+        profileSaved: '  Profile 저장 완료. 첫 세션을 시작하면 이 추천이 적용됩니다.',
+        invalidChoice: '  A, B, C 중 하나를 입력해주세요.',
+    },
+    en: {
+        header: '  Forgen — Personalization Onboarding',
+        subtitle: '  4 scenario questions to understand your work style.\n  Results are provisional and confirmed after your first session.',
+        q1: `
+  ─────────────────────────────────────────
+  Q1: Ambiguous implementation request
+
+  You receive "improve the login feature." Requirements are
+  unclear and adjacent modules may be affected.
+
+  A) Clarify requirements/scope first. Ask if scope expansion is possible.
+  B) Proceed if within same flow. Check when major scope expansion appears.
+  C) Make reasonable assumptions and fix adjacent files directly.
+
+  Choice (A/B/C): `,
+        q2: `
+  ─────────────────────────────────────────
+  Q2: Verification depth vs completion speed
+
+  Your fix is almost done. Tests and type checks remain.
+
+  A) Don't call it done until all tests, types, and key checks pass.
+  B) Run at least one key check, then summarize remaining risks.
+  C) Quick smoke test, report results and risks.
+
+  Choice (A/B/C): `,
+        q3: `
+  ─────────────────────────────────────────
+  Q3: Code modification approach
+
+  You found a repeated pattern in legacy code. It works but
+  the structure is poor.
+
+  A) Make minimal changes. Don't break what works.
+  B) Clean up related parts only. No full restructuring.
+  C) Restructure surrounding code too. Reduce tech debt.
+
+  Choice (A/B/C): `,
+        q4: `
+  ─────────────────────────────────────────
+  Q4: Explanation/reporting style
+
+  You fixed a complex bug. Time to report.
+
+  A) Explain what, why, impact scope, and alternatives in detail.
+  B) Summarize key changes and reasons. Invite follow-up questions.
+  C) Report changes concisely. Explain only if asked.
+
+  Choice (A/B/C): `,
+        resultHeader: '  Recommendation (provisional)',
+        profileSaved: '  Profile saved. Personalization will apply from your next session.',
+        invalidChoice: '  Please enter A, B, or C.',
+    },
+};
+export const RULE_RENDERER = {
+    ko: {
+        trustGuardrails: '위험 우회 비활성. 파괴적 명령, 민감 경로 접근 시 항상 확인.',
+        trustRelaxed: '일반 파일 쓰기는 승인 없이 진행 가능. 위험 우회는 기본 제한.',
+        trustFullTrust: '런타임 마찰 최소화. 명시적 금지와 파괴적 명령 외에는 자유 실행.',
+        evidenceCollectionHeader: 'Evidence Collection',
+        evidenceCollectionRules: [
+            '사용자가 행동을 교정하면("하지마", "그렇게 말고", "앞으로는 이렇게") 반드시 correction-record MCP 도구를 호출하여 evidence로 기록하라.',
+            'kind 선택: fix-now(즉시 수정), prefer-from-now(앞으로 이렇게), avoid-this(하지 마라)',
+            'axis_hint: quality_safety(품질/검증), autonomy(자율/확인), judgment_philosophy(변경 접근법), communication_style(설명 스타일)',
+            '교정이 아닌 일반 피드백은 기록하지 않는다.',
+        ],
+        judgmentMinimalChange: [
+            '기존 코드 구조를 최대한 유지하라. 동작하는 코드를 불필요하게 리팩토링하지 마라.',
+            '수정 범위를 최소한으로 유지하라. 인접 파일 변경은 꼭 필요한 경우에만.',
+            '변경 전 근거(테스트, 에러 로그)를 먼저 확보하라.',
+        ],
+        judgmentBalanced: ['현재 작업 범위에 집중하되, 명확한 개선 기회가 보이면 제안하라.'],
+        judgmentStructural: [
+            '반복되는 패턴이나 기술 부채를 발견하면 적극적으로 구조 개선을 제안하라.',
+            '추상화와 재사용 가능한 설계를 선호하라. 단, 과도한 추상화는 피한다.',
+            '변경 시 전체 아키텍처 관점에서 일관성을 유지하라.',
+        ],
+        commConcise: [
+            '응답은 짧고 핵심만. 코드와 결과 위주로 보고하라.',
+            '부연 설명은 물어볼 때만. 선제적으로 길게 설명하지 마라.',
+        ],
+        commBalanced: ['핵심 변경과 이유를 요약하고, 필요하면 추가 설명을 유도하라.'],
+        commDetailed: [
+            '변경 이유, 대안 검토, 영향 범위를 함께 설명하라.',
+            '교육적 맥락을 제공하라 — 왜 이 접근이 좋은지, 다른 방법과 비교.',
+            '보고는 구조화하라 (변경 사항, 이유, 영향, 다음 단계).',
+        ],
+    },
+    en: {
+        trustGuardrails: 'Dangerous bypass disabled. Always confirm before destructive commands or sensitive path access.',
+        trustRelaxed: 'Regular file writes proceed without approval. Dangerous bypass restricted by default.',
+        trustFullTrust: 'Minimal runtime friction. Free execution except explicit bans and destructive commands.',
+        evidenceCollectionHeader: 'Evidence Collection',
+        evidenceCollectionRules: [
+            'When the user corrects your behavior ("don\'t do that", "always do X", "stop doing Y"), call the correction-record MCP tool to record it as evidence.',
+            'kind: fix-now (immediate fix), prefer-from-now (going forward), avoid-this (never do this)',
+            'axis_hint: quality_safety, autonomy, judgment_philosophy, communication_style',
+            'Do not record general feedback — only explicit behavioral corrections.',
+        ],
+        judgmentMinimalChange: [
+            'Preserve existing code structure. Do not refactor working code unnecessarily.',
+            'Keep modification scope minimal. Change adjacent files only when strictly necessary.',
+            'Secure evidence (tests, error logs) before making changes.',
+        ],
+        judgmentBalanced: ['Focus on current task scope, but suggest improvements when clearly beneficial.'],
+        judgmentStructural: [
+            'Proactively suggest structural improvements when you spot repeated patterns or tech debt.',
+            'Prefer abstraction and reusable design, but avoid over-abstraction.',
+            'Maintain architectural consistency across changes.',
+        ],
+        commConcise: [
+            'Keep responses short and to the point. Focus on code and results.',
+            'Only elaborate when asked. Do not proactively write long explanations.',
+        ],
+        commBalanced: ['Summarize key changes and reasons. Invite follow-up questions when needed.'],
+        commDetailed: [
+            'Explain what changed, why, impact scope, and alternatives considered.',
+            'Provide educational context — why this approach is better, compare with alternatives.',
+            'Structure reports: changes, reasoning, impact, next steps.',
+        ],
+    },
+};
+// ── Locale Detection ──
+let _currentLocale = 'en';
+export function setLocale(locale) { _currentLocale = locale; }
+export function getLocale() { return _currentLocale; }
+/** GlobalConfig에서 locale을 읽어 설정. 없으면 'en' 기본값. */
+export function initLocaleFromConfig() {
+    try {
+        const { loadGlobalConfig } = require('../core/global-config.js');
+        const config = loadGlobalConfig();
+        if (config.locale === 'ko' || config.locale === 'en') {
+            _currentLocale = config.locale;
+        }
+    }
+    catch {
+        // config 로드 실패 시 기본값 유지
+    }
+}

package/dist/lib.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Forgen public library API.
+ * Import via `import { ... } from 'forgen'` or `import { ... } from 'forgen/lib'`
+ *
+ * Separates library exports from CLI entrypoint (cli.ts)
+ * so forgen can be used programmatically.
+ */
+export type { Philosophy, Principle, HarnessContext, ScopeInfo, } from './core/types.js';
+export type { Profile, Rule, Evidence, PackRecommendation, SessionEffectiveState, QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, TrustPolicy, QualityFacets, AutonomyFacets, JudgmentFacets, CommunicationFacets, } from './store/types.js';
+export { SECURITY_PATTERNS, PROMPT_INJECTION_PATTERNS, normalizeForInjectionCheck, containsPromptInjection, filterSolutionContent, } from './hooks/prompt-injection-filter.js';
+export type { ScanFinding, ScanResult, } from './hooks/prompt-injection-filter.js';
+export { loadProfile, saveProfile, createProfile } from './store/profile-store.js';
+export { loadActiveRules } from './store/rule-store.js';
+export { ForgenError, HookError, ConfigError, ForgeError, NonRetryableError } from './core/errors.js';

package/dist/lib.js

@@ -0,0 +1,14 @@
+/**
+ * Forgen public library API.
+ * Import via `import { ... } from 'forgen'` or `import { ... } from 'forgen/lib'`
+ *
+ * Separates library exports from CLI entrypoint (cli.ts)
+ * so forgen can be used programmatically.
+ */
+// ── Hooks (utilities) ──
+export { SECURITY_PATTERNS, PROMPT_INJECTION_PATTERNS, normalizeForInjectionCheck, containsPromptInjection, filterSolutionContent, } from './hooks/prompt-injection-filter.js';
+// ── v1 stores ──
+export { loadProfile, saveProfile, createProfile } from './store/profile-store.js';
+export { loadActiveRules } from './store/rule-store.js';
+// ── Errors ──
+export { ForgenError, HookError, ConfigError, ForgeError, NonRetryableError } from './core/errors.js';

package/dist/mcp/server.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Forgen — MCP Compound Knowledge Server
+ *
+ * Pull 모델: Claude가 필요할 때 compound-search/read를 직접 호출.
+ * instructions 필드로 Claude에게 compound 도구 사용법을 안내.
+ */
+export {};

package/dist/mcp/server.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * Forgen — MCP Compound Knowledge Server
+ *
+ * Pull 모델: Claude가 필요할 때 compound-search/read를 직접 호출.
+ * instructions 필드로 Claude에게 compound 도구 사용법을 안내.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerTools } from './tools.js';
+if (!process.env.FORGEN_CWD && !process.env.COMPOUND_CWD) {
+    process.env.FORGEN_CWD = process.cwd();
+    process.env.COMPOUND_CWD = process.cwd(); // legacy compat
+}
+const INSTRUCTIONS = [
+    'Forgen compound knowledge — accumulated patterns and solutions from past sessions.',
+    '',
+    'When to use:',
+    '- Before starting a task: search for similar past patterns with compound-search',
+    '- When encountering an error: search for troubleshooting solutions',
+    '- When making architectural decisions: check if a similar decision was documented',
+    '- After completing work: user may run /compound to extract new patterns',
+    '',
+    'Usage flow: compound-search (find relevant) → compound-read (get full content)',
+    'compound-stats gives an overview of accumulated knowledge.',
+    '',
+    'Evidence collection:',
+    '- When the user corrects your behavior, use correction-record to record it as evidence',
+    '- This enables forgen to learn from corrections and adapt personalization over time',
+].join('\n');
+const server = new McpServer({ name: 'forgen-compound', version: '1.0.0' }, { instructions: INSTRUCTIONS });
+registerTools(server);
+try {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+catch (err) {
+    process.stderr.write(`[forgen-mcp] Failed to start: ${err instanceof Error ? err.message : err}\n`);
+    process.exit(1);
+}

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

@@ -0,0 +1,90 @@
+/**
+ * Forgen — MCP Solution Reader
+ *
+ * MCP 도구 핸들러를 위한 비즈니스 로직 파사드.
+ * 기존 solution-index, solution-matcher, solution-format 모듈을 조합하여
+ * 검색/목록/읽기/통계 기능을 제공합니다.
+ *
+ * 설계 결정:
+ *   - MCP 도구 핸들러가 직접 fs/path를 다루지 않도록 격리
+ *   - Hook injection(push)과 독립: 세션 캐시/버짓 적용 안 함
+ *   - compound-read는 전문 반환 (축약 없음), compound-search는 요약만
+ *   - prompt injection 필터는 동일하게 적용 (보안 일관성)
+ *   - 인덱스 캐시는 isIndexStale()에 의존 (resetIndexCache 미사용)
+ *     → 디렉토리 mtime이 변하지 않으면 캐시 재사용 (성능)
+ */
+import type { SolutionDirConfig } from '../engine/solution-index.js';
+import type { SolutionStatus, SolutionType } from '../engine/solution-format.js';
+export interface SearchOptions {
+    dirs?: SolutionDirConfig[];
+    type?: SolutionType;
+    status?: SolutionStatus;
+    limit?: number;
+}
+export interface ListOptions {
+    dirs?: SolutionDirConfig[];
+    status?: SolutionStatus;
+    type?: SolutionType;
+    scope?: 'me' | 'team' | 'project';
+    sort?: 'confidence' | 'updated' | 'name';
+}
+export interface SolutionSummary {
+    name: string;
+    status: SolutionStatus;
+    confidence: number;
+    type: SolutionType;
+    scope: 'me' | 'team' | 'project';
+    tags: string[];
+}
+export interface SearchResult extends SolutionSummary {
+    relevance: number;
+    matchedTags: string[];
+}
+export interface SolutionDetail {
+    name: string;
+    status: SolutionStatus;
+    confidence: number;
+    type: SolutionType;
+    scope: 'me' | 'team' | 'project';
+    tags: string[];
+    identifiers: string[];
+    context: string;
+    content: string;
+}
+export interface SolutionStats {
+    total: number;
+    byStatus: Record<SolutionStatus, number>;
+    byType: Record<SolutionType, number>;
+    byScope: Record<'me' | 'team' | 'project', number>;
+}
+/**
+ * 기본 솔루션 디렉토리 목록 생성.
+ * MCP 서버에서 cwd를 전달받으면 project 스코프도 포함.
+ */
+export declare function defaultSolutionDirs(cwd?: string): SolutionDirConfig[];
+/**
+ * 쿼리 텍스트로 솔루션을 검색합니다.
+ * 태그 기반 Jaccard 매칭 + confidence 가중치.
+ * Hook injection과 달리 세션 캐시/버짓 없이 순수 검색.
+ *
+ * 인덱스 캐시: getOrBuildIndex() 내부의 isIndexStale()이
+ * 디렉토리 mtime을 비교하여 변경 시에만 재구축합니다.
+ */
+export declare function searchSolutions(query: string, options?: SearchOptions): SearchResult[];
+/** 솔루션 요약 목록을 반환합니다 (필터/정렬 지원). */
+export declare function listSolutions(options?: ListOptions): SolutionSummary[];
+/**
+ * 이름으로 솔루션 전문을 읽습니다.
+ *
+ * MCP는 온디맨드이므로 truncation 없이 전문을 반환합니다.
+ * 이것이 hook injection(1500자 캡)과의 핵심 차이입니다.
+ * Prompt injection 필터만 적용합니다.
+ */
+export declare function readSolution(name: string, options?: {
+    dirs?: SolutionDirConfig[];
+    skipEvidence?: boolean;
+}): SolutionDetail | null;
+/** 솔루션 통계 (status별, type별, scope별 카운트). */
+export declare function getSolutionStats(options?: {
+    dirs?: SolutionDirConfig[];
+}): SolutionStats;