@wooojin/forgen 0.1.0

package/dist/mcp/solution-reader.js

@@ -0,0 +1,273 @@
+/**
+ * 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 * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS, PACKS_DIR } from '../core/paths.js';
+import { getOrBuildIndex } from '../engine/solution-index.js';
+import { extractTags, expandCompoundTags, expandQueryBigrams } from '../engine/solution-format.js';
+import { parseSolutionV3 } from '../engine/solution-format.js';
+import { maskBlockedTokens } from '../engine/phrase-blocklist.js';
+import { mutateSolutionFile } from '../engine/solution-writer.js';
+import { calculateRelevance, shouldRejectByR4T3Rules } from '../engine/solution-matcher.js';
+import { defaultNormalizer } from '../engine/term-normalizer.js';
+import { logMatchDecision } from '../engine/match-eval-log.js';
+import { filterSolutionContent } from '../hooks/prompt-injection-filter.js';
+// ── 디렉토리 해석 ──
+/**
+ * 기본 솔루션 디렉토리 목록 생성.
+ * MCP 서버에서 cwd를 전달받으면 project 스코프도 포함.
+ */
+export function defaultSolutionDirs(cwd) {
+    const dirs = [
+        { dir: ME_SOLUTIONS, scope: 'me' },
+    ];
+    // 팩 디렉토리 스캔 — 하위에 solutions/ 디렉토리가 있는 팩만 포함
+    // PR2c-2 (M7 fix): readdirSync 결과를 정렬해 결정적 순서 보장.
+    // 정렬 안 하면 같은 팩 집합도 파일시스템 순서에 따라 다른 cache key/precedence
+    // 가 생겨 LRU와 인덱스 결정성이 깨진다.
+    try {
+        if (fs.existsSync(PACKS_DIR)) {
+            const packEntries = fs.readdirSync(PACKS_DIR).sort();
+            for (const entry of packEntries) {
+                const solDir = path.join(PACKS_DIR, entry, 'solutions');
+                if (fs.existsSync(solDir)) {
+                    dirs.push({ dir: solDir, scope: 'team' });
+                }
+            }
+        }
+    }
+    catch {
+        // 팩 디렉토리 접근 실패는 무시
+    }
+    if (cwd) {
+        dirs.push({ dir: path.join(cwd, '.compound', 'solutions'), scope: 'project' });
+    }
+    return dirs;
+}
+// ── 검색 ──
+/**
+ * 쿼리 텍스트로 솔루션을 검색합니다.
+ * 태그 기반 Jaccard 매칭 + confidence 가중치.
+ * Hook injection과 달리 세션 캐시/버짓 없이 순수 검색.
+ *
+ * 인덱스 캐시: getOrBuildIndex() 내부의 isIndexStale()이
+ * 디렉토리 mtime을 비교하여 변경 시에만 재구축합니다.
+ */
+export function searchSolutions(query, options) {
+    const dirs = options?.dirs ?? defaultSolutionDirs();
+    const limit = options?.limit ?? 10;
+    const index = getOrBuildIndex(dirs);
+    const queryTagsRaw = extractTags(query);
+    if (queryTagsRaw.length === 0)
+        return [];
+    // R4-T2: mask query tokens that belong to blocked English compounds
+    // ("performance review", "system architecture", etc.) BEFORE bigram
+    // expansion or canonical normalization runs. See `phrase-blocklist.ts`
+    // for the rationale and `solution-matcher.rankCandidates` for the
+    // mirror of this same step in the hook path. If every prompt tag
+    // gets masked, the query carries no dev-context signal and we return
+    // an empty result list.
+    const queryTags = maskBlockedTokens(query.toLowerCase(), queryTagsRaw);
+    if (queryTags.length === 0)
+        return [];
+    // T2: normalize query ONCE outside the per-entry loop and reuse for every
+    // calculateRelevance call. Matches the same hot-path optimization in
+    // solution-matcher.rankCandidates.
+    //
+    // R4-T1: layer adjacent-token bigram expansion BEFORE canonical
+    // normalization so compound query phrases like "api keys" produce the
+    // `api-key`/`apikey`/`api-keys` candidates that hit hyphenated solution
+    // tags via direct intersection. This mirrors the same change in
+    // solution-matcher.rankCandidates so hook and MCP paths stay consistent.
+    const queryTagsWithBigrams = expandQueryBigrams(queryTags);
+    const normalizedPromptTags = defaultNormalizer.normalizeTerms(queryTagsWithBigrams);
+    const results = [];
+    for (const entry of index.entries) {
+        if (options?.type && entry.type !== options.type)
+            continue;
+        if (options?.status && entry.status !== options.status)
+            continue;
+        // R4-T1: solution-side compound expansion. See the matching block in
+        // solution-matcher.rankCandidates for the rationale (separation of
+        // matching set from Jaccard union for normalization stability).
+        const entryTagsExpanded = expandCompoundTags(entry.tags);
+        // R4-T2: pass `queryTags` (already masked above) so the union
+        // denominator inside calculateRelevance uses the post-mask set, in
+        // sync with the matching step.
+        const result = calculateRelevance(queryTags, entry.tags, entry.confidence, { normalizedPromptTags, solutionTagsExpanded: entryTagsExpanded });
+        // 태그 매칭 + 이름 매칭: 솔루션 이름에 쿼리 단어가 포함되면 boost
+        // Compute name match FIRST so R4-T3 cannot silently drop a candidate
+        // with strong name-match evidence.
+        const nameWords = entry.name.toLowerCase().split(/[-_]/);
+        const nameMatchCount = queryTags.filter(t => nameWords.includes(t)).length;
+        const nameBoost = nameMatchCount * 0.1;
+        // R4-T3: orchestration-layer specificity guards (mirror of the
+        // matching block in solution-matcher.rankCandidates). Reject single-
+        // tag matches that lack a corroborating signal. Name-match hits are
+        // the MCP-path equivalent of the hook path's identifier boost and
+        // bypass the R4-T3 gate — a nameMatchCount > 0 is strong evidence.
+        let tagRelevance = result.relevance;
+        let tagMatches = result.matchedTags;
+        if (nameMatchCount === 0
+            && tagMatches.length > 0
+            && shouldRejectByR4T3Rules(queryTags, tagMatches)) {
+            tagRelevance = 0;
+            tagMatches = [];
+        }
+        if (tagMatches.length === 0 && nameMatchCount === 0)
+            continue;
+        results.push({
+            name: entry.name,
+            status: entry.status,
+            confidence: entry.confidence,
+            type: entry.type,
+            scope: entry.scope,
+            tags: entry.tags,
+            relevance: tagRelevance + nameBoost,
+            matchedTags: [...tagMatches, ...queryTags.filter(t => nameWords.includes(t) && !tagMatches.includes(t))],
+        });
+    }
+    results.sort((a, b) => b.relevance - a.relevance);
+    const top = results.slice(0, limit);
+    // T3: ranking-decision log for offline analysis. Fail-open via logger's
+    // own try/catch. `source: 'mcp'` distinguishes this from the hook path.
+    // `rankedTopN` here equals the post-`limit` slice the caller receives —
+    // MCP path has no further filtering, so for this source ranked == returned.
+    // Skip when limit is 0 (caller doesn't care about results).
+    if (limit > 0) {
+        logMatchDecision({
+            source: 'mcp',
+            rawQuery: query,
+            normalizedQuery: normalizedPromptTags,
+            candidates: top.map(r => ({
+                name: r.name,
+                relevance: r.relevance,
+                matchedTerms: r.matchedTags,
+            })),
+            rankedTopN: top.slice(0, 5).map(r => r.name),
+        });
+    }
+    return top;
+}
+// ── 목록 ──
+/** 솔루션 요약 목록을 반환합니다 (필터/정렬 지원). */
+export function listSolutions(options) {
+    const dirs = options?.dirs ?? defaultSolutionDirs();
+    const index = getOrBuildIndex(dirs);
+    let entries = index.entries.map(e => ({
+        name: e.name,
+        status: e.status,
+        confidence: e.confidence,
+        type: e.type,
+        scope: e.scope,
+        tags: e.tags,
+    }));
+    if (options?.status)
+        entries = entries.filter(e => e.status === options.status);
+    if (options?.type)
+        entries = entries.filter(e => e.type === options.type);
+    if (options?.scope)
+        entries = entries.filter(e => e.scope === options.scope);
+    const sort = options?.sort ?? 'confidence';
+    if (sort === 'confidence') {
+        entries.sort((a, b) => b.confidence - a.confidence);
+    }
+    else if (sort === 'name') {
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    return entries;
+}
+// ── 읽기 ──
+/**
+ * 이름으로 솔루션 전문을 읽습니다.
+ *
+ * MCP는 온디맨드이므로 truncation 없이 전문을 반환합니다.
+ * 이것이 hook injection(1500자 캡)과의 핵심 차이입니다.
+ * Prompt injection 필터만 적용합니다.
+ */
+export function readSolution(name, options) {
+    const dirs = options?.dirs ?? defaultSolutionDirs();
+    const index = getOrBuildIndex(dirs);
+    const entry = index.entries.find(e => e.name === name);
+    if (!entry)
+        return null;
+    let fileContent;
+    try {
+        // Security: symlink을 통한 임의 파일 읽기 방지
+        const fstat = fs.lstatSync(entry.filePath);
+        if (fstat.isSymbolicLink())
+            return null;
+        // Safety: 비정상적으로 큰 파일 거부 (100KB)
+        if (fstat.size > 100 * 1024)
+            return null;
+        fileContent = fs.readFileSync(entry.filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    const parsed = parseSolutionV3(fileContent);
+    if (!parsed)
+        return null;
+    // 보안: prompt injection 필터
+    const contentFilter = filterSolutionContent(parsed.content);
+    if (contentFilter.verdict === 'block')
+        return null;
+    const contextFilter = filterSolutionContent(parsed.context);
+    if (contextFilter.verdict === 'block')
+        return null;
+    // Pull(MCP) 경로: evidence에 기여 — sessions + reflected 카운트 증가
+    // PR2b: solution-writer.mutateSolutionFile로 통합. lock + fresh re-read로 race 방지.
+    if (!options?.skipEvidence) {
+        mutateSolutionFile(entry.filePath, sol => {
+            sol.frontmatter.evidence.sessions += 1;
+            sol.frontmatter.evidence.reflected += 1;
+            return true;
+        });
+    }
+    return {
+        name: entry.name,
+        status: entry.status,
+        confidence: entry.confidence,
+        type: entry.type,
+        scope: entry.scope,
+        tags: entry.tags,
+        identifiers: entry.identifiers,
+        context: contextFilter.sanitized,
+        content: contentFilter.sanitized,
+    };
+}
+// ── 통계 ──
+/** 솔루션 통계 (status별, type별, scope별 카운트). */
+export function getSolutionStats(options) {
+    const dirs = options?.dirs ?? defaultSolutionDirs();
+    const index = getOrBuildIndex(dirs);
+    const stats = {
+        total: index.entries.length,
+        // retired는 인덱스에서 제외되므로 항상 0 (solution-index.ts:73)
+        byStatus: { experiment: 0, candidate: 0, verified: 0, mature: 0, retired: 0 },
+        byType: { pattern: 0, solution: 0, decision: 0, troubleshoot: 0, 'anti-pattern': 0, convention: 0 },
+        byScope: { me: 0, team: 0, project: 0 },
+    };
+    for (const entry of index.entries) {
+        if (entry.status in stats.byStatus)
+            stats.byStatus[entry.status]++;
+        if (entry.type in stats.byType)
+            stats.byType[entry.type]++;
+        if (entry.scope in stats.byScope)
+            stats.byScope[entry.scope]++;
+    }
+    return stats;
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Forgen — MCP Tool Definitions
+ *
+ * 4개 도구를 McpServer에 등록합니다:
+ *   - compound-search: 태그 기반 솔루션 검색
+ *   - compound-list: 필터/정렬된 솔루션 목록
+ *   - compound-read: 솔루션 전문 읽기
+ *   - compound-stats: 통계 요약
+ *
+ * 설계 결정:
+ *   - 각 도구는 solution-reader.ts의 순수 함수를 호출
+ *   - cwd는 환경변수 COMPOUND_CWD에서 읽음 (Claude Code가 전달)
+ *   - MCP SDK registerTool API + zod 스키마로 입력 검증
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerTools(server: McpServer): void;

package/dist/mcp/tools.js

@@ -0,0 +1,302 @@
+/**
+ * Forgen — MCP Tool Definitions
+ *
+ * 4개 도구를 McpServer에 등록합니다:
+ *   - compound-search: 태그 기반 솔루션 검색
+ *   - compound-list: 필터/정렬된 솔루션 목록
+ *   - compound-read: 솔루션 전문 읽기
+ *   - compound-stats: 통계 요약
+ *
+ * 설계 결정:
+ *   - 각 도구는 solution-reader.ts의 순수 함수를 호출
+ *   - cwd는 환경변수 COMPOUND_CWD에서 읽음 (Claude Code가 전달)
+ *   - MCP SDK registerTool API + zod 스키마로 입력 검증
+ */
+import { z } from 'zod';
+import { searchSolutions, listSolutions, readSolution, getSolutionStats, defaultSolutionDirs, } from './solution-reader.js';
+import { processCorrection } from '../forge/evidence-processor.js';
+function getCwd() {
+    return process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? undefined;
+}
+export function registerTools(server) {
+    // ── compound-search ──
+    server.registerTool('compound-search', {
+        description: 'Search accumulated compound knowledge (solutions, patterns) by query. Returns relevant matches ranked by tag-based similarity. When multiple results are returned, provide a brief summary of findings.',
+        inputSchema: {
+            query: z.string().describe('Search query — keywords, tech names, or problem description'),
+            type: z.enum(['pattern', 'solution', 'decision', 'troubleshoot', 'anti-pattern', 'convention']).optional()
+                .describe('Filter by solution type'),
+            status: z.enum(['experiment', 'candidate', 'verified', 'mature']).optional()
+                .describe('Filter by lifecycle status'),
+            limit: z.number().min(1).max(20).optional()
+                .describe('Max results to return (default: 10)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ query, type, status, limit }) => {
+        const results = searchSolutions(query, {
+            dirs: defaultSolutionDirs(getCwd()),
+            type,
+            status,
+            limit,
+        });
+        if (results.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No matching solutions found.',
+                    }],
+            };
+        }
+        const text = results.map((r, i) => {
+            let snippet = '';
+            if (i < 5) {
+                try {
+                    const full = readSolution(r.name, { dirs: defaultSolutionDirs(getCwd()), skipEvidence: true });
+                    if (full?.content) {
+                        const firstLines = full.content
+                            .split('\n')
+                            .filter(l => l.trim().length > 0)
+                            .slice(0, 2)
+                            .join(' ')
+                            .slice(0, 150);
+                        snippet = `\n   Preview: ${firstLines}`;
+                    }
+                }
+                catch { /* skip snippet on error */ }
+            }
+            return (`${i + 1}. **${r.name}** (${r.status}, confidence: ${r.confidence.toFixed(2)})\n` +
+                `   Type: ${r.type} | Scope: ${r.scope} | Relevance: ${r.relevance.toFixed(3)}\n` +
+                `   Tags: ${r.tags.join(', ')}\n` +
+                `   Matched: ${r.matchedTags.join(', ')}` +
+                snippet);
+        }).join('\n\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Found ${results.length} matching solution(s):\n\n${text}`,
+                }],
+        };
+    });
+    // ── compound-list ──
+    server.registerTool('compound-list', {
+        description: 'List all accumulated compound solutions with optional filtering and sorting.',
+        inputSchema: {
+            status: z.enum(['experiment', 'candidate', 'verified', 'mature']).optional()
+                .describe('Filter by lifecycle status'),
+            type: z.enum(['pattern', 'solution', 'decision', 'troubleshoot', 'anti-pattern', 'convention']).optional()
+                .describe('Filter by solution type'),
+            scope: z.enum(['me', 'team', 'project']).optional()
+                .describe('Filter by scope'),
+            sort: z.enum(['confidence', 'updated', 'name']).optional()
+                .describe('Sort order (default: confidence)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ status, type, scope, sort }) => {
+        const results = listSolutions({
+            dirs: defaultSolutionDirs(getCwd()),
+            status,
+            type,
+            scope,
+            sort,
+        });
+        if (results.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'No solutions found.',
+                    }],
+            };
+        }
+        const text = results.map(r => `- **${r.name}** [${r.status}] confidence: ${r.confidence.toFixed(2)} | ${r.type} | ${r.scope} | tags: ${r.tags.join(', ')}`).join('\n');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${results.length} solution(s):\n\n${text}`,
+                }],
+        };
+    });
+    // ── compound-read ──
+    server.registerTool('compound-read', {
+        description: 'Read the full content of a specific compound solution by name. Use compound-search or compound-list first to find the name.',
+        inputSchema: {
+            name: z.string().describe('Solution name (slug) to read'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ name }) => {
+        const result = readSolution(name, {
+            dirs: defaultSolutionDirs(getCwd()),
+        });
+        if (!result) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Solution "${name}" not found or filtered by security policy.`,
+                    }],
+            };
+        }
+        const header = `# ${result.name}\n` +
+            `Status: ${result.status} | Confidence: ${result.confidence.toFixed(2)} | Type: ${result.type} | Scope: ${result.scope}\n` +
+            `Tags: ${result.tags.join(', ')}\n` +
+            (result.identifiers.length > 0 ? `Identifiers: ${result.identifiers.join(', ')}\n` : '');
+        const body = (result.context ? `\n## Context\n${result.context}\n` : '') +
+            `\n## Content\n${result.content}`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: header + body,
+                }],
+        };
+    });
+    // ── compound-stats ──
+    server.registerTool('compound-stats', {
+        description: 'Get overview statistics of accumulated compound knowledge (total count, breakdown by status/type/scope).',
+        annotations: { readOnlyHint: true },
+    }, async () => {
+        const stats = getSolutionStats({
+            dirs: defaultSolutionDirs(getCwd()),
+        });
+        const lines = [
+            `Total solutions: ${stats.total}`,
+            '',
+            'By status:',
+            ...Object.entries(stats.byStatus)
+                .filter(([, count]) => count > 0)
+                .map(([status, count]) => `  ${status}: ${count}`),
+            '',
+            'By type:',
+            ...Object.entries(stats.byType)
+                .filter(([, count]) => count > 0)
+                .map(([type, count]) => `  ${type}: ${count}`),
+            '',
+            'By scope:',
+            ...Object.entries(stats.byScope)
+                .filter(([, count]) => count > 0)
+                .map(([scope, count]) => `  ${scope}: ${count}`),
+        ];
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n'),
+                }],
+        };
+    });
+    // ── session-search ──
+    server.registerTool('session-search', {
+        description: 'Search past session conversations by keyword. Returns matching messages from previous Claude Code sessions. When presenting results, summarize key findings for the user.',
+        inputSchema: {
+            query: z.string().describe('Search query — keywords to find in past conversations'),
+            limit: z.number().min(1).max(20).optional()
+                .describe('Max results to return (default: 10)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ query, limit }) => {
+        try {
+            const { searchSessions, extractContextWindow } = await import('../core/session-store.js');
+            const results = searchSessions(query, limit ?? 10);
+            if (results.length === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: 'No matching messages found in past sessions.',
+                        }],
+                };
+            }
+            // 세션별 그루핑 (세션당 최대 3메시지)
+            const grouped = new Map();
+            for (const r of results) {
+                const group = grouped.get(r.sessionId) ?? [];
+                if (group.length < 3) {
+                    group.push(r);
+                    grouped.set(r.sessionId, group);
+                }
+            }
+            const sessionBlocks = [];
+            let msgIndex = 1;
+            for (const [sessionId, msgs] of grouped) {
+                const first = msgs[0];
+                const date = first.timestamp ? first.timestamp.slice(0, 10) : 'unknown date';
+                const project = first.cwd ? first.cwd.split('/').pop() ?? first.cwd : 'unknown project';
+                const msgLines = msgs.map(r => {
+                    const snippet = extractContextWindow(r.content, r.tokens);
+                    return `  ${msgIndex++}. [${r.role}] ${snippet}`;
+                });
+                sessionBlocks.push(`Session: ${sessionId.slice(0, 8)} | Date: ${date} | Project: ${project}\n` +
+                    msgLines.join('\n'));
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Found ${results.length} matching message(s) across ${grouped.size} session(s):\n\n${sessionBlocks.join('\n\n')}`,
+                    }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: 'Session search unavailable (requires Node.js 22+ with SQLite support).',
+                    }],
+            };
+        }
+    });
+    // ── correction-record ──
+    server.registerTool('correction-record', {
+        description: [
+            'Record a user correction as structured evidence.',
+            'Call this when the user explicitly corrects your behavior (e.g., "don\'t do X", "always do Y", "fix this now").',
+            'This creates an Evidence record and optionally a temporary session Rule.',
+            '',
+            'kind values:',
+            '  fix-now — immediate fix needed, creates a session-scoped temporary rule',
+            '  prefer-from-now — long-term preference, records evidence for future promotion',
+            '  avoid-this — strong avoidance, creates a strong temporary rule',
+        ].join('\n'),
+        inputSchema: {
+            session_id: z.string().describe('Current session ID'),
+            kind: z.enum(['fix-now', 'prefer-from-now', 'avoid-this'])
+                .describe('Correction type: fix-now (immediate), prefer-from-now (long-term), avoid-this (strong avoidance)'),
+            message: z.string().describe('What the user wants changed — the correction in natural language'),
+            target: z.string().describe('What is being corrected — the specific behavior, pattern, or output'),
+            axis_hint: z.enum(['quality_safety', 'autonomy', 'judgment_philosophy', 'communication_style']).nullable()
+                .describe('Which personalization axis this correction relates to (null if unclear)'),
+        },
+    }, async ({ session_id, kind, message, target, axis_hint }) => {
+        try {
+            // v1 session_id를 환경변수에서 가져옴 (하네스가 설정)
+            const effectiveSessionId = session_id || process.env.FORGEN_SESSION_ID || 'unknown';
+            const result = processCorrection({
+                session_id: effectiveSessionId,
+                kind: kind,
+                message,
+                target,
+                axis_hint: axis_hint,
+            });
+            const lines = [
+                `Evidence recorded: ${result.evidence_event_id}`,
+            ];
+            if (result.temporary_rule) {
+                lines.push(`Temporary rule created: "${result.temporary_rule.policy}" (${result.temporary_rule.strength}, scope: ${result.temporary_rule.scope})`);
+            }
+            if (result.recompose_required) {
+                lines.push('Session recomposition recommended — the temporary rule should be applied to current session behavior.');
+            }
+            if (result.promotion_candidate) {
+                lines.push('This correction is a candidate for long-term rule promotion at session end.');
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: lines.join('\n'),
+                    }],
+            };
+        }
+        catch (e) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Failed to record correction: ${e instanceof Error ? e.message : String(e)}`,
+                    }],
+            };
+        }
+    });
+}

package/dist/preset/facet-catalog.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Forgen v1 — Facet Catalog
+ *
+ * Authoritative source: docs/plans/2026-04-03-forgen-facet-catalog.md
+ * 모든 facet 값 범위: 0.0 ~ 1.0
+ */
+import type { QualityPack, AutonomyPack, JudgmentPack, CommunicationPack, QualityFacets, AutonomyFacets, JudgmentFacets, CommunicationFacets } from '../store/types.js';
+export declare const QUALITY_CENTROIDS: Record<QualityPack, QualityFacets>;
+export declare const AUTONOMY_CENTROIDS: Record<AutonomyPack, AutonomyFacets>;
+export declare const JUDGMENT_CENTROIDS: Record<JudgmentPack, JudgmentFacets>;
+export declare const COMMUNICATION_CENTROIDS: Record<CommunicationPack, CommunicationFacets>;
+export declare const DEFAULT_JUDGMENT_FACETS: JudgmentFacets;
+export declare const DEFAULT_COMMUNICATION_FACETS: CommunicationFacets;
+export declare function qualityCentroid(pack: QualityPack): QualityFacets;
+export declare function autonomyCentroid(pack: AutonomyPack): AutonomyFacets;
+export declare function judgmentCentroid(pack: JudgmentPack): JudgmentFacets;
+export declare function communicationCentroid(pack: CommunicationPack): CommunicationFacets;

package/dist/preset/facet-catalog.js

@@ -0,0 +1,46 @@
+/**
+ * Forgen v1 — Facet Catalog
+ *
+ * Authoritative source: docs/plans/2026-04-03-forgen-facet-catalog.md
+ * 모든 facet 값 범위: 0.0 ~ 1.0
+ */
+// ── Quality centroids ──
+export const QUALITY_CENTROIDS = {
+    '보수형': { verification_depth: 0.90, stop_threshold: 0.85, change_conservatism: 0.80 },
+    '균형형': { verification_depth: 0.60, stop_threshold: 0.55, change_conservatism: 0.55 },
+    '속도형': { verification_depth: 0.35, stop_threshold: 0.20, change_conservatism: 0.30 },
+};
+// ── Autonomy centroids ──
+export const AUTONOMY_CENTROIDS = {
+    '확인 우선형': { confirmation_independence: 0.15, assumption_tolerance: 0.30, scope_expansion_tolerance: 0.35, approval_threshold: 0.25 },
+    '균형형': { confirmation_independence: 0.50, assumption_tolerance: 0.55, scope_expansion_tolerance: 0.55, approval_threshold: 0.60 },
+    '자율 실행형': { confirmation_independence: 0.80, assumption_tolerance: 0.85, scope_expansion_tolerance: 0.90, approval_threshold: 0.90 },
+};
+// ── Judgment centroids ──
+export const JUDGMENT_CENTROIDS = {
+    '최소변경형': { minimal_change_bias: 0.85, abstraction_bias: 0.20, evidence_first_bias: 0.80 },
+    '균형형': { minimal_change_bias: 0.50, abstraction_bias: 0.50, evidence_first_bias: 0.50 },
+    '구조적접근형': { minimal_change_bias: 0.20, abstraction_bias: 0.85, evidence_first_bias: 0.70 },
+};
+// ── Communication centroids ──
+export const COMMUNICATION_CENTROIDS = {
+    '간결형': { verbosity: 0.15, structure: 0.70, teaching_bias: 0.20 },
+    '균형형': { verbosity: 0.50, structure: 0.50, teaching_bias: 0.50 },
+    '상세형': { verbosity: 0.85, structure: 0.80, teaching_bias: 0.80 },
+};
+// ── Defaults (backward compat) ──
+export const DEFAULT_JUDGMENT_FACETS = JUDGMENT_CENTROIDS['균형형'];
+export const DEFAULT_COMMUNICATION_FACETS = COMMUNICATION_CENTROIDS['균형형'];
+// ── Utilities ──
+export function qualityCentroid(pack) {
+    return { ...QUALITY_CENTROIDS[pack] };
+}
+export function autonomyCentroid(pack) {
+    return { ...AUTONOMY_CENTROIDS[pack] };
+}
+export function judgmentCentroid(pack) {
+    return { ...JUDGMENT_CENTROIDS[pack] };
+}
+export function communicationCentroid(pack) {
+    return { ...COMMUNICATION_CENTROIDS[pack] };
+}