@wooojin/forgen 0.4.9 → 0.4.11

package/dist/engine/compound-extractor.js

@@ -1,649 +1,32 @@
 /**
- * Forgen — Compound Knowledge Extractor
+ * Forgen — Compound Knowledge Extractor (facade)
  *
- * Extracts reusable patterns and decisions from git history and session context.
- * Runs quality gates (structure, toxicity, trivial, dedup) before persisting solutions.
+ * Orchestrates extraction pipeline: git analysis → quality gates →
+ * pattern extraction → persistence. Re-exports from decomposed modules.
  *
- * Module Structure:
- * - Lines 1-50: Imports, constants, SHA validation, LastExtraction/ExtractedSolution interfaces
- * - Lines 50-115: Git helpers — getNewCommits, getCommitMessages, getGitDiff, getDiffStats
- * - Lines 115-190: Quality Gates — gate0 (worth extracting), gate1 (structure), gate2 (toxicity),
- *     gateTrivial (trivial rejection), gate3 (dedup)
- * - Lines 190-275: extractFromDiff — pattern extraction from git diff (modules, errors, imports, commits)
- * - Lines 275-395: extractFromSessionContext — prompt/write history analysis (actions, hotspots, tech)
- * - Lines 396-475: saveExtractedSolution, updateReExtractedCounter — solution persistence
- * - Lines 477-555: runExtraction — main entry point orchestrating gates + extraction + state
- * - Lines 557-634: processExtractionResults, isExtractionPaused, pauseExtraction, resumeExtraction
+ * Module layout (post-decomposition):
+ *   extraction-git.ts         — getNewCommits, getCommitMessages, getGitDiff, getDiffStats
+ *   extraction-gates.ts       — gate0-gate3, gateTrivial, evaluateExtractedSolution, ExtractedSolution
+ *   extraction-diff.ts        — extractFromDiff, findCommonPrefix
+ *   extraction-session.ts     — extractFromSessionContext, loadClaudeProjectSessionContext
+ *   extraction-persistence.ts — saveExtractedSolution, updateReExtractedCounter, LastExtraction
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { execHost } from '../host/exec-host.js';
-import { serializeSolutionV3, DEFAULT_EVIDENCE, extractTags } from './solution-format.js';
 import { createLogger } from '../core/logger.js';
-import { emitSolutionEvent } from '../core/observability-store.js';
+import { STATE_DIR } from '../core/paths.js';
+import { getNewCommits, getCommitMessages, getGitDiff, getDiffStats } from './extraction-git.js';
+import { gate0, evaluateExtractedSolution } from './extraction-gates.js';
+import { extractFromDiff } from './extraction-diff.js';
+import { extractFromSessionContext } from './extraction-session.js';
+import { loadLastExtraction, saveLastExtraction, saveExtractedSolution, updateReExtractedCounter, emitCompoundExtractActedOn, } from './extraction-persistence.js';
 const log = createLogger('compound-extractor');
-import { CLAUDE_DIR, ME_SOLUTIONS, STATE_DIR } from '../core/paths.js';
-import { atomicWriteJSON, atomicWriteText } from '../hooks/shared/atomic-write.js';
-import { mutateSolutionFile } from './solution-writer.js';
-const LAST_EXTRACTION_PATH = path.join(STATE_DIR, 'last-extraction.json');
 const MAX_EXTRACTIONS_PER_DAY = 5;
-const MAX_DIFF_LENGTH = 3000;
-/** Validate that a string is a valid git SHA (7-64 hex chars) */
-function isValidSha(sha) {
-    return /^[a-f0-9]{7,64}$/.test(sha);
-}
-/** Load last extraction state */
-function loadLastExtraction() {
-    try {
-        if (fs.existsSync(LAST_EXTRACTION_PATH)) {
-            return JSON.parse(fs.readFileSync(LAST_EXTRACTION_PATH, 'utf-8'));
-        }
-    }
-    catch (e) {
-        log.debug('last extraction state read failed — may cause duplicate extractions', e);
-    }
-    return { lastCommitSha: '', lastExtractedAt: '', extractionsToday: 0, todayDate: '' };
-}
-/** Save last extraction state */
-function saveLastExtraction(state) {
-    fs.mkdirSync(STATE_DIR, { recursive: true });
-    atomicWriteJSON(LAST_EXTRACTION_PATH, state);
-}
-/** Get new commits since last extraction — uses execFileSync to prevent injection */
-function getNewCommits(cwd, lastSha) {
-    try {
-        if (!lastSha || !isValidSha(lastSha)) {
-            return execFileSync('git', ['log', '--oneline', '-5'], { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
-        }
-        return execFileSync('git', ['log', '--oneline', `${lastSha}..HEAD`], { cwd, encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
-    }
-    catch {
-        return '';
-    }
-}
-/** Get commit messages for "why" context enrichment */
-function getCommitMessages(cwd, lastSha) {
-    try {
-        const args = lastSha && isValidSha(lastSha)
-            ? ['log', '--format=%B', `${lastSha}..HEAD`]
-            : ['log', '--format=%B', '-5'];
-        const msgs = execFileSync('git', args, { cwd, encoding: 'utf-8', timeout: 5000 });
-        return msgs.slice(0, 1000).trim();
-    }
-    catch {
-        return '';
-    }
-}
-/** Get git diff for extraction */
-function getGitDiff(cwd, lastSha) {
-    try {
-        const args = lastSha && isValidSha(lastSha)
-            ? ['diff', `${lastSha}..HEAD`]
-            : ['diff', 'HEAD~1'];
-        const diff = execFileSync('git', args, { cwd, encoding: 'utf-8', timeout: 10000 });
-        return diff.slice(0, MAX_DIFF_LENGTH);
-    }
-    catch {
-        return '';
-    }
-}
-/** Get diff stats for Gate 0 */
-function getDiffStats(cwd, lastSha) {
-    try {
-        const args = lastSha && isValidSha(lastSha)
-            ? ['diff', '--stat', `${lastSha}..HEAD`]
-            : ['diff', '--stat', 'HEAD~1'];
-        const stat = execFileSync('git', args, { cwd, encoding: 'utf-8', timeout: 5000 });
-        const lines = stat.split('\n').filter(l => l.trim());
-        const codeExts = /\.(ts|tsx|js|jsx|py|rs|go|java|rb|c|cpp|h|swift|kt)$/;
-        const hasCodeFiles = lines.some(line => {
-            const filePath = line.split('|')[0]?.trim() ?? '';
-            return codeExts.test(filePath);
-        });
-        const lastLine = lines[lines.length - 1] ?? '';
-        const changedMatch = lastLine.match(/(\d+)\s+files?\s+changed/);
-        const insertMatch = lastLine.match(/(\d+)\s+insertion/);
-        const deleteMatch = lastLine.match(/(\d+)\s+deletion/);
-        const fileCount = parseInt(changedMatch?.[1] ?? '0', 10);
-        const lineCount = parseInt(insertMatch?.[1] ?? '0', 10) + parseInt(deleteMatch?.[1] ?? '0', 10);
-        return { files: fileCount, lines: lineCount, hasCodeFiles };
-    }
-    catch {
-        return { files: 0, lines: 0, hasCodeFiles: false };
-    }
-}
-// --- Blocklist for Gate 2 (Toxicity Filter) ---
-const TOXICITY_PATTERNS = [
-    /@ts-ignore/i, /@ts-nocheck/i, /as\s+any\b/i,
-    /--force\b/i, /--no-verify\b/i, /--skip-ci\b/i,
-    /eslint-disable/i, /prettier-ignore/i, /noqa/i,
-    /\bTODO:/i, /\bFIXME:/i, /\bHACK:/i, /\bXXX:/i,
-    /\/Users\//i, /\/home\//i, /C:\\\\Users/i,
-];
-// --- Quality Gates ---
-/** Gate 0: Is this extraction worth doing? */
-function gate0(stats) {
-    if (stats.files < 1)
-        return false;
-    if (stats.lines < 30)
-        return false;
-    if (!stats.hasCodeFiles)
-        return false;
-    return true;
-}
-/** Gate 1: Structural validation (pure — does not mutate input) */
-function gate1(sol) {
-    if (!sol.name || sol.name.length < 3)
-        return false;
-    if (!sol.tags || sol.tags.length === 0)
-        return false;
-    if (!sol.content || sol.content.length < 50)
-        return false;
-    if (!sol.context)
-        return false;
-    return true;
-}
-/** Gate 2: Toxicity filter */
-function gate2(sol) {
-    const text = `${sol.context} ${sol.content}`;
-    return !TOXICITY_PATTERNS.some(p => p.test(text));
-}
-/**
- * Gate 2.5: Trivial pattern rejection — 자명한 패턴은 축적할 가치 없음.
- * "주로 TypeScript를 작성합니다" 수준의 솔루션은 Claude가 코드를 보면 알 수 있으므로
- * compound에 저장하면 컨텍스트만 낭비됨.
- */
-function gateTrivial(sol) {
-    const content = sol.content.trim();
-    // 내용이 너무 짧으면 자명함 (한 줄짜리)
-    if (content.length < 80)
-        return false;
-    // "주로 X를 Y합니다" 패턴
-    if (/^주로\s/.test(content) && content.split('\n').length < 3)
-        return false;
-    // 식별자가 하나도 없으면 구체적인 기술 패턴이 아님
-    if (sol.identifiers.length === 0 && sol.tags.length < 3)
-        return false;
-    return true;
-}
-/** Gate 3: Dedup check against existing solutions */
-function gate3(sol) {
-    if (!fs.existsSync(ME_SOLUTIONS))
-        return 'new';
-    try {
-        const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
-        for (const file of files) {
-            const content = fs.readFileSync(path.join(ME_SOLUTIONS, file), 'utf-8');
-            const tagMatch = content.match(/tags:\s*\[([^\]]*)\]/);
-            if (!tagMatch)
-                continue;
-            const existingTags = tagMatch[1].split(',').map(t => t.trim().replace(/"/g, ''));
-            const overlap = sol.tags.filter(t => existingTags.includes(t));
-            const overlapRatio = overlap.length / Math.max(sol.tags.length, existingTags.length, 1);
-            if (overlapRatio >= 0.7) {
-                if (content.includes('status: "experiment"') || content.includes("status: 'experiment'") || content.includes('status: experiment')) {
-                    return 're-extract';
-                }
-                return 'duplicate';
-            }
-        }
-    }
-    catch (e) {
-        log.debug('gate3 기존 솔루션 파일 읽기 실패 — new로 간주', e);
-    }
-    return 'new';
-}
-/** Simple local extraction from git diff (no LLM needed) */
-function extractFromDiff(gitLog, gitDiff) {
-    const solutions = [];
-    // 1. Detect new files/modules created
-    const newFiles = gitDiff.match(/^\+\+\+ b\/(.+)$/gm);
-    if (newFiles && newFiles.length >= 2) {
-        const fileNames = newFiles.map(f => f.replace('+++ b/', ''));
-        const ext = path.extname(fileNames[0]);
-        const dir = path.dirname(fileNames[0]).split('/').pop() ?? '';
-        if (ext && dir) {
-            const basenames = fileNames.map(f => path.basename(f, ext));
-            const commonPrefix = findCommonPrefix(basenames);
-            if (commonPrefix.length >= 3) {
-                solutions.push({
-                    name: `module-${commonPrefix}-pattern`,
-                    type: 'pattern',
-                    tags: extractTags(`${fileNames.join(' ')} ${dir}`),
-                    identifiers: basenames.filter(b => b.length >= 4).slice(0, 5),
-                    context: `File organization pattern in ${dir}/`,
-                    content: `Files follow the naming pattern: ${commonPrefix}*${ext} in ${dir}/`,
-                });
-            }
-        }
-    }
-    // 2. Detect error handling patterns from diff
-    const errorPatterns = gitDiff.match(/^\+.*(?:try\s*\{|catch\s*[({]|\.catch\(|throw new|Error\()/gm);
-    if (errorPatterns && errorPatterns.length >= 3) {
-        const sample = errorPatterns.slice(0, 3).map(l => l.replace(/^\+\s*/, '').trim());
-        solutions.push({
-            name: 'error-handling-pattern',
-            type: 'pattern',
-            tags: ['error', 'handling', 'try-catch', 'pattern'],
-            identifiers: sample.filter(s => s.length >= 4).slice(0, 3),
-            context: 'Error handling approach used in this codebase',
-            content: `Consistent error handling: ${sample.join('; ')}`.slice(0, 500),
-        });
-    }
-    // 3. Detect import/dependency patterns
-    const imports = gitDiff.match(/^\+\s*import\s+.+from\s+['"]([^'"]+)['"]/gm);
-    if (imports && imports.length >= 3) {
-        const packages = imports
-            .map(i => i.match(/from\s+['"]([^'"]+)['"]/)?.[1])
-            .filter((p) => !!p && !p.startsWith('.'))
-            .filter((v, i, a) => a.indexOf(v) === i);
-        if (packages.length >= 2) {
-            solutions.push({
-                name: 'dependency-stack',
-                type: 'decision',
-                tags: ['dependency', 'stack', ...packages.slice(0, 3)],
-                identifiers: packages.filter(p => p.length >= 4).slice(0, 5),
-                context: 'Technology stack and dependency choices',
-                content: `Project uses: ${packages.join(', ')}`,
-            });
-        }
-    }
-    // 4. Detect from commit messages
-    const commitKeywords = {
-        'fix': { type: 'troubleshoot', tags: ['bugfix', 'troubleshoot'] },
-        'refactor': { type: 'pattern', tags: ['refactor', 'cleanup'] },
-        'test': { type: 'pattern', tags: ['testing', 'tdd'] },
-        'security': { type: 'pattern', tags: ['security', 'hardening'] },
-    };
-    for (const [keyword, meta] of Object.entries(commitKeywords)) {
-        const re = new RegExp(`^[a-f0-9]+\\s+${keyword}[:\\s](.+)$`, 'gim');
-        const matches = [...gitLog.matchAll(re)];
-        if (matches.length >= 2) {
-            const descriptions = matches.map(m => m[1].trim()).slice(0, 3);
-            // commit 메시지에서 identifier 후보 추출 (camelCase, PascalCase, snake_case, 6자 이상)
-            const commitIdentifiers = descriptions
-                .join(' ')
-                .match(/\b[a-zA-Z][a-zA-Z0-9]*(?:[A-Z][a-z]+)+\b|\b[a-z]+(?:_[a-z]+)+\b/g)
-                ?.filter(id => id.length >= 6)
-                ?.filter((v, i, a) => a.indexOf(v) === i)
-                ?.slice(0, 5) ?? [];
-            solutions.push({
-                name: `${keyword}-pattern`,
-                type: meta.type,
-                tags: [...meta.tags, keyword],
-                identifiers: commitIdentifiers,
-                context: `Recurring ${keyword} pattern from commit history`,
-                content: descriptions.join('. ').slice(0, 500),
-            });
-        }
-    }
-    return solutions.slice(0, 3); // max 3
-}
-/** Extract patterns from accumulated session context (prompts + writes + diff) */
-function extractFromSessionContext(gitDiff, cwd, lastExtractedAt) {
-    const solutions = [];
-    const claudeContext = loadClaudeProjectSessionContext(cwd, lastExtractedAt);
-    // Load recent prompts (still consumed by tech-stack-decision below).
-    let prompts = claudeContext.prompts;
-    if (prompts.length === 0) {
-        prompts = loadPromptHistoryFallback();
-    }
-    // C4 removal (2026-04-09): `recurring-task-pattern` and `modification-
-    // hotspot` extractors were deleted here. They produced word-frequency
-    // histograms and directory counts masquerading as "patterns", with
-    // generic "consider automating/refactoring" advice that applied to
-    // any project. Observed in production: one `recurring-task-pattern`
-    // solution whose entire content was `User frequently requests:
-    // test(39회), 테스트(36회), 추가(32회). Consider automating...` was
-    // injected into 105 sessions before the quality problem was spotted.
-    // The `extractFromSessionContext` function now only emits the
-    // tech-stack-decision pattern below, which at least cross-validates
-    // against both prompts and diff before writing. If session-level
-    // extraction needs to come back, the replacement MUST pass a
-    // content-level sniff test: does the extracted solution teach
-    // something a new developer wouldn't already infer from `git log`?
-    //
-    // M-1 (review follow-up): the `writes` loader was removed from this
-    // function as dead code. Pre-M-1 `loadWriteHistoryFallback()` ran on
-    // every extraction, touching the filesystem to load data no
-    // downstream extractor consumed. If a future extractor needs writes,
-    // restore `claudeContext.writes` (already loaded above) or reintroduce
-    // the fallback loader at that point.
-    // 3. Detect decision patterns from prompt + diff correlation
-    // When user asks about X and diff shows Y, the decision is "for X, use Y"
-    const techDecisions = [];
-    const techTerms = ['react', 'vue', 'next', 'express', 'fastify', 'prisma', 'drizzle', 'zustand', 'redux', 'tailwind', 'styled', 'vitest', 'jest', 'playwright', 'cypress'];
-    for (const term of techTerms) {
-        const inPrompts = prompts.some(p => p.toLowerCase().includes(term));
-        const inDiff = gitDiff.toLowerCase().includes(term);
-        if (inPrompts && inDiff) {
-            techDecisions.push(term);
-        }
-    }
-    if (techDecisions.length >= 2) {
-        solutions.push({
-            name: 'tech-stack-decision',
-            type: 'decision',
-            tags: ['stack', 'technology', ...techDecisions.slice(0, 5)],
-            identifiers: techDecisions.filter(t => t.length >= 4).slice(0, 5),
-            context: 'Technology choices confirmed by both discussion and implementation',
-            content: `Active technology stack: ${techDecisions.join(', ')}. Both discussed in prompts and present in code changes.`,
-        });
-    }
-    return solutions;
-}
-function normalizeProjectPath(cwd) {
-    const resolved = path.resolve(cwd);
-    try {
-        return typeof fs.realpathSync.native === 'function'
-            ? fs.realpathSync.native(resolved)
-            : fs.realpathSync(resolved);
-    }
-    catch {
-        return resolved;
-    }
-}
-function getProjectPathCandidates(cwd) {
-    const resolved = path.resolve(cwd);
-    const candidates = new Set([resolved, normalizeProjectPath(cwd)]);
-    try {
-        if (fs.lstatSync(resolved).isSymbolicLink()) {
-            candidates.add(path.resolve(path.dirname(resolved), fs.readlinkSync(resolved)));
-        }
-    }
-    catch {
-        // Ignore lstat/readlink failures; raw + realpath candidates are enough.
-    }
-    for (const candidate of [...candidates]) {
-        candidates.add(normalizeProjectPath(candidate));
-    }
-    return [...candidates];
-}
-function getClaudeProjectDirs(cwd) {
-    return getProjectPathCandidates(cwd)
-        .map(candidate => path.join(CLAUDE_DIR, 'projects', candidate.replace(/[:\\/]/g, '-')));
-}
-function listClaudeSessionFiles(projectDirs, maxFiles) {
-    // Symlink hardening (INFO from security review, 2026-04-09):
-    // `~/.claude/projects/` is inside the user's HOME so in the normal
-    // threat model it's trusted, but we mirror the `solution-index.ts:135`
-    // defensive posture and refuse to follow symlinks. A local attacker
-    // with HOME write access could otherwise plant a symlink pointing at
-    // arbitrary JSONL files on disk and cause `collectClaudeProjectSessionContext`
-    // to ingest their contents as "Claude session prompts".
-    return projectDirs
-        .flatMap(projectDir => {
-        let entries;
-        try {
-            entries = fs.readdirSync(projectDir);
-        }
-        catch {
-            return [];
-        }
-        const out = [];
-        for (const file of entries) {
-            if (!file.endsWith('.jsonl'))
-                continue;
-            const filePath = path.join(projectDir, file);
-            try {
-                if (fs.lstatSync(filePath).isSymbolicLink())
-                    continue;
-                out.push({ filePath, mtimeMs: fs.statSync(filePath).mtimeMs });
-            }
-            catch {
-                // unreadable / vanished between readdir and stat — skip
-            }
-        }
-        return out;
-    })
-        .sort((a, b) => b.mtimeMs - a.mtimeMs)
-        .slice(0, maxFiles);
-}
-function getAllClaudeProjectDirs() {
-    const projectsRoot = path.join(CLAUDE_DIR, 'projects');
-    if (!fs.existsSync(projectsRoot))
-        return [];
-    return fs.readdirSync(projectsRoot)
-        .map(name => path.join(projectsRoot, name))
-        .filter(dir => {
-        try {
-            return fs.statSync(dir).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    });
-}
-function collectClaudeProjectSessionContext(files, cwdCandidates, cutoffMs) {
-    const prompts = [];
-    const writes = [];
-    for (const file of files) {
-        // Defense in depth: even though listClaudeSessionFiles already
-        // rejects symlinks, re-check here in case a caller bypasses the
-        // lister. A TOCTOU race between lister's lstat and this read is
-        // theoretically possible but requires local HOME write access,
-        // at which point the attacker already has easier vectors.
-        try {
-            if (fs.lstatSync(file.filePath).isSymbolicLink())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        let lines;
-        try {
-            lines = fs.readFileSync(file.filePath, 'utf-8').split('\n').filter(Boolean);
-        }
-        catch {
-            continue;
-        }
-        for (const line of lines) {
-            let entry;
-            try {
-                entry = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            const entryCandidates = typeof entry.cwd === 'string' ? getProjectPathCandidates(entry.cwd) : [];
-            if (!entryCandidates.some(candidate => cwdCandidates.has(candidate)))
-                continue;
-            const timestamp = typeof entry.timestamp === 'string' ? new Date(entry.timestamp).getTime() : Number.NaN;
-            if (cutoffMs && Number.isFinite(timestamp) && timestamp <= cutoffMs)
-                continue;
-            if (entry.type === 'user') {
-                const message = entry.message;
-                if (message?.role === 'user' && typeof message.content === 'string') {
-                    prompts.push(message.content);
-                }
-                continue;
-            }
-            if (entry.type !== 'assistant')
-                continue;
-            const message = entry.message;
-            if (message?.role !== 'assistant' || !Array.isArray(message.content))
-                continue;
-            for (const item of message.content) {
-                if (typeof item !== 'object' || item === null)
-                    continue;
-                const toolUse = item;
-                if (toolUse.type !== 'tool_use')
-                    continue;
-                if (toolUse.name !== 'Write' && toolUse.name !== 'Edit')
-                    continue;
-                const filePath = String(toolUse.input?.file_path ?? toolUse.input?.filePath ?? '');
-                const content = String(toolUse.input?.content ?? toolUse.input?.new_string ?? '');
-                if (!filePath || !content)
-                    continue;
-                writes.push({
-                    filePath: filePath.slice(-100),
-                    contentSnippet: content.slice(0, 200),
-                    fileExtension: path.extname(filePath).toLowerCase(),
-                });
-            }
-        }
-    }
-    return {
-        prompts: prompts.slice(-50),
-        writes: writes.slice(-30),
-    };
-}
-function loadPromptHistoryFallback() {
-    const promptHistoryPath = path.join(STATE_DIR, 'prompt-history.jsonl');
-    try {
-        if (!fs.existsSync(promptHistoryPath))
-            return [];
-        const lines = fs.readFileSync(promptHistoryPath, 'utf-8').split('\n').filter(Boolean);
-        return lines.slice(-50).map(l => {
-            try {
-                return JSON.parse(l).prompt;
-            }
-            catch {
-                return '';
-            }
-        }).filter(Boolean);
-    }
-    catch (e) {
-        log.debug('prompt-history.jsonl 읽기 실패 — session context fallback 건너뜀', e);
-        return [];
-    }
-}
-// M-1 follow-up (2026-04-09): `loadWriteHistoryFallback` was removed
-// alongside the C4 extractor cleanup. Its only caller was the now-deleted
-// session-context loader for writes, so keeping it would be dead code on
-// the extraction hot path (per-session I/O against a file that nobody
-// reads). If a future write-based extractor is reintroduced, either
-// restore this loader or call it via `claudeContext.writes` once session
-// correlation picks writes up.
-/**
- * Load Claude session prompts + writes correlated to `cwd`.
- *
- * Exported primarily for test assertions (the `claude-session-context`
- * tests need to verify that correlation picks the right project's
- * sessions and ignores unrelated ones). Before C4 the tests could
- * observe this indirectly via the now-removed `recurring-task-pattern`
- * extractor; now they check this loader directly. Not intended for
- * production callers outside the extractor pipeline.
- */
-export function loadClaudeProjectSessionContext(cwd, lastExtractedAt) {
-    const cwdCandidates = new Set(getProjectPathCandidates(cwd));
-    const projectDirs = getClaudeProjectDirs(cwd).filter(dir => fs.existsSync(dir));
-    const cutoffMs = lastExtractedAt ? new Date(lastExtractedAt).getTime() : 0;
-    try {
-        if (projectDirs.length > 0) {
-            const primary = collectClaudeProjectSessionContext(listClaudeSessionFiles(projectDirs, 5), cwdCandidates, cutoffMs);
-            if (primary.prompts.length > 0 || primary.writes.length > 0)
-                return primary;
-        }
-        const fallbackDirs = getAllClaudeProjectDirs().filter(dir => !projectDirs.includes(dir));
-        if (fallbackDirs.length === 0)
-            return { prompts: [], writes: [] };
-        return collectClaudeProjectSessionContext(listClaudeSessionFiles(fallbackDirs, 20), cwdCandidates, cutoffMs);
-    }
-    catch (e) {
-        log.debug('Claude project session context 로드 실패 — fallback 사용', e);
-        return { prompts: [], writes: [] };
-    }
-}
-function findCommonPrefix(strings) {
-    if (strings.length === 0)
-        return '';
-    let prefix = strings[0];
-    for (const s of strings.slice(1)) {
-        while (!s.startsWith(prefix) && prefix.length > 0) {
-            prefix = prefix.slice(0, -1);
-        }
-    }
-    return prefix.replace(/-$/, '');
-}
-/** Save an extracted solution as experiment */
-function saveExtractedSolution(sol, _sessionId) {
-    const today = new Date().toISOString().split('T')[0];
-    const slugName = sol.name.toLowerCase()
-        .replace(/[^a-z0-9가-힣\s-]/g, '')
-        .replace(/\s+/g, '-')
-        .replace(/-+/g, '-')
-        .replace(/^-|-$/g, '')
-        .slice(0, 60) || `untitled-${Date.now()}`;
-    const solution = {
-        frontmatter: {
-            name: slugName,
-            version: 1,
-            status: 'experiment',
-            confidence: 0.3,
-            type: sol.type,
-            scope: 'me',
-            tags: sol.tags.slice(0, 5),
-            identifiers: sol.identifiers.filter(id => id.length >= 4),
-            evidence: { ...DEFAULT_EVIDENCE },
-            created: today,
-            updated: today,
-            supersedes: null,
-            extractedBy: 'auto',
-        },
-        context: sol.context,
-        content: sol.content,
-    };
-    const filePath = path.join(ME_SOLUTIONS, `${slugName}.md`);
-    if (fs.existsSync(filePath))
-        return null;
-    fs.mkdirSync(ME_SOLUTIONS, { recursive: true });
-    // PR2b: 새 파일 create는 atomicWriteText로. O_EXCL이 race를 차단한다.
-    atomicWriteText(filePath, serializeSolutionV3(solution));
-    return slugName;
-}
-/**
- * Increment reExtracted counter on existing solution that matches given tags.
- * PR2b 라운드 2 (M-2 fix): mutateSolutionFile로 통합. parse → 카운터 증가 →
- * serialize. 이전 regex in-place mutation은 frontmatter 외 body의 우연 매칭
- * 위험이 있었고 다른 mutator와 일관성이 깨졌다.
- */
-function updateReExtractedCounter(tags) {
-    if (!fs.existsSync(ME_SOLUTIONS))
-        return;
-    const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
-    for (const file of files) {
-        const filePath = path.join(ME_SOLUTIONS, file);
-        // PR2c-4 (security L-1): symlink을 통한 임의 파일 read 차단.
-        try {
-            if (fs.lstatSync(filePath).isSymbolicLink())
-                continue;
-        }
-        catch {
-            continue;
-        }
-        // 사전 필터 (lock 없이 read) — frontmatter parse가 더 정확하지만,
-        // 70% overlap 조건은 frontmatter 안의 tags만 보는 게 의도라
-        // tagMatch regex가 frontmatter에 우선 매칭됨 (frontmatter가 항상 앞).
-        let preview;
-        try {
-            preview = fs.readFileSync(filePath, 'utf-8');
-        }
-        catch {
-            continue;
-        }
-        const tagMatch = preview.match(/tags:\s*\[([^\]]*)\]/);
-        if (!tagMatch)
-            continue;
-        const existingTags = tagMatch[1].split(',').map(t => t.trim().replace(/"/g, ''));
-        const overlap = tags.filter(t => existingTags.includes(t));
-        if (overlap.length / Math.max(tags.length, existingTags.length, 1) < 0.7)
-            continue;
-        // lock + fresh re-read + parse-modify-serialize
-        mutateSolutionFile(filePath, sol => {
-            sol.frontmatter.evidence.reExtracted = (sol.frontmatter.evidence.reExtracted ?? 0) + 1;
-            return true;
-        });
-        return;
-    }
-}
-/**
- * Optional LLM enrichment for thin solution content.
- * Uses execFileSync (synchronous) to keep callers synchronous.
- * Completely fail-open: any error returns null and the regex-extracted content is kept.
- * Budget: max 2 calls per extraction run, 15s timeout each.
- */
+// ── Re-exports (backward compatibility) ──
+export { loadClaudeProjectSessionContext } from './extraction-session.js';
+// ── LLM enrichment (kept inline — ~30 lines, not worth a separate file) ──
 function enrichSolutionContent(solution, diffSnippet) {
     try {
         const prompt = [
@@ -657,100 +40,53 @@ function enrichSolutionContent(solution, diffSnippet) {
             '코드 변경 (일부):',
             diffSnippet.slice(0, 2000),
         ].join('\n');
-        // feat/codex-support P2-2 — host-aware exec via profile.default_host.
-        // Codex 메인 사용자도 자동 추출 enrichment 가능 (해당 host CLI 호출).
-        // fail-open 정책 유지 — LLM enrichment 실패는 추출 자체를 막지 않음.
         const { message } = execHost({ prompt, model: 'haiku', timeout: 15000 });
         if (message.length > 30 && message.length < 1000)
             return message;
         return null;
     }
     catch {
-        // fail-open: LLM enrichment failure should never block extraction
         return null;
     }
 }
-/** Main extraction function — called from SessionStart or CLI */
+// ── Orchestration ──
 function analyzeExtraction(cwd, options) {
     const state = loadLastExtraction();
     const today = new Date().toISOString().split('T')[0];
-    // Reset daily counter if new day
     if (state.todayDate !== today) {
         state.extractionsToday = 0;
         state.todayDate = today;
     }
-    // Daily limit check
     if (options?.enforceDailyLimit !== false && state.extractionsToday >= MAX_EXTRACTIONS_PER_DAY) {
         return {
-            state,
-            today,
-            headSha: '',
-            extracted: [],
+            state, today, headSha: '', extracted: [],
             reason: `일일 추출 한도 도달 (${MAX_EXTRACTIONS_PER_DAY}/일)`,
             persistStateWithoutSaving: false,
         };
     }
-    // Check for new commits
     const gitLog = getNewCommits(cwd, state.lastCommitSha);
     if (!gitLog.trim()) {
-        return {
-            state,
-            today,
-            headSha: '',
-            extracted: [],
-            reason: '새 커밋 없음',
-            persistStateWithoutSaving: false,
-        };
+        return { state, today, headSha: '', extracted: [], reason: '새 커밋 없음', persistStateWithoutSaving: false };
     }
-    // Get current HEAD sha
     let headSha = '';
     try {
         headSha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd, encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
     }
     catch {
-        return {
-            state,
-            today,
-            headSha: '',
-            extracted: [],
-            reason: 'git HEAD 조회 실패',
-            persistStateWithoutSaving: false,
-        };
+        return { state, today, headSha: '', extracted: [], reason: 'git HEAD 조회 실패', persistStateWithoutSaving: false };
     }
-    // Gate 0: Worth extracting?
     const stats = getDiffStats(cwd, state.lastCommitSha);
     if (!gate0(stats)) {
         return {
-            state,
-            today,
-            headSha,
-            extracted: [],
+            state, today, headSha, extracted: [],
             reason: `Gate 0: 추출 가치 부족 (${stats.files} files, ${stats.lines} lines)`,
-            stats,
-            persistStateWithoutSaving: true,
+            stats, persistStateWithoutSaving: true,
         };
     }
-    // Get diff for extraction prompt
     const gitDiff = getGitDiff(cwd, state.lastCommitSha);
-    // Get commit messages for "why" context (addresses feedback: auto-extraction loses reasoning)
     const commitMessages = getCommitMessages(cwd, state.lastCommitSha);
-    // Combine git diff analysis + session context analysis.
-    // C3 fix: track provenance so commit context is only attached to
-    // solutions that were actually derived from the diff. Pre-C3 the commit
-    // message was blindly copy-pasted onto every extracted solution —
-    // including session-context-derived patterns (word frequency
-    // histograms, recurring task stats) that had nothing to do with the
-    // commit. Observed failure mode: a "recurring-task-pattern" solution
-    // about `test/테스트/추가` word counts was annotated with a completely
-    // unrelated `Phase 1.5 + 2.5 — surprise detection + contextual bandit`
-    // commit message, producing a misleading audit trail + noise in the
-    // MCP context returned to Claude.
     const diffPatterns = extractFromDiff(gitLog, gitDiff);
     const contextPatterns = extractFromSessionContext(gitDiff, cwd, state.lastExtractedAt);
-    // Attach commit context ONLY to diff-derived patterns (they're
-    // genuinely about the commit). Session-context patterns keep their
-    // own context unchanged — if they don't have a context, they don't
-    // get a fake one.
     if (commitMessages) {
         for (const sol of diffPatterns) {
             sol.context = sol.context
@@ -758,31 +94,10 @@ function analyzeExtraction(cwd, options) {
                 : `Commit context:\n${commitMessages.slice(0, 300)}`;
         }
     }
-    const extracted = [...diffPatterns, ...contextPatterns].slice(0, 3); // max 3 total
-    return {
-        state,
-        today,
-        headSha,
-        extracted,
-        stats,
-        persistStateWithoutSaving: false,
-        gitDiff,
-    };
-}
-function evaluateExtractedSolution(sol) {
-    if (!gate1(sol))
-        return { action: 'skip', message: `${sol.name ?? 'unnamed'}: Gate 1 실패 (구조 검증)` };
-    if (!gate2(sol))
-        return { action: 'skip', message: `${sol.name}: Gate 2 실패 (독성 필터)` };
-    if (!gateTrivial(sol))
-        return { action: 'skip', message: `${sol.name}: Gate 2.5 실패 (자명한 패턴)` };
-    const dupResult = gate3(sol);
-    if (dupResult === 'duplicate')
-        return { action: 'duplicate', message: `${sol.name}: Gate 3 중복` };
-    if (dupResult === 're-extract')
-        return { action: 're-extract', message: `${sol.name}: 재추출 (기존 솔루션 강화)` };
-    return { action: 'accept' };
+    const extracted = [...diffPatterns, ...contextPatterns].slice(0, 3);
+    return { state, today, headSha, extracted, stats, persistStateWithoutSaving: false, gitDiff };
 }
+// ── Public API ──
 export async function previewExtraction(cwd) {
     const analysis = analyzeExtraction(cwd, { enforceDailyLimit: false });
     if (analysis.reason) {
@@ -804,7 +119,6 @@ export async function previewExtraction(cwd) {
     }
     return { preview, skipped };
 }
-/** Main extraction function — called from SessionStart or CLI */
 export async function runExtraction(cwd, sessionId) {
     const result = { extracted: [], skipped: [] };
     const analysis = analyzeExtraction(cwd);
@@ -819,7 +133,6 @@ export async function runExtraction(cwd, sessionId) {
         return { ...result, reason: analysis.reason };
     }
     if (analysis.extracted.length > 0) {
-        // Enrich thin solutions with LLM context — max 2 per run, fail-open
         let enrichCount = 0;
         for (const sol of analysis.extracted) {
             if (enrichCount >= 2)
@@ -836,7 +149,6 @@ export async function runExtraction(cwd, sessionId) {
         result.extracted = saved;
         result.skipped = skipped;
     }
-    // Update extraction state
     analysis.state.lastCommitSha = analysis.headSha;
     analysis.state.lastExtractedAt = new Date().toISOString();
     analysis.state.extractionsToday++;
@@ -846,42 +158,6 @@ export async function runExtraction(cwd, sessionId) {
     }
     return result;
 }
-/**
- * Observability P2: 새 솔루션 본문/supersedes 에서 기존 솔루션 참조 감지 → acted_on emit.
- * fail-open.
- */
-function emitCompoundExtractActedOn(sessionId, newSolutionName, newContent, newSupersedes) {
-    try {
-        if (!fs.existsSync(ME_SOLUTIONS))
-            return;
-        const bodyLower = newContent.toLowerCase();
-        const supersedes = newSupersedes ?? '';
-        const files = fs.readdirSync(ME_SOLUTIONS).filter(f => f.endsWith('.md'));
-        for (const file of files) {
-            const existingName = path.basename(file, '.md');
-            if (existingName === newSolutionName)
-                continue;
-            const referenced = (supersedes && existingName === supersedes)
-                || bodyLower.includes(existingName.toLowerCase());
-            if (!referenced)
-                continue;
-            emitSolutionEvent({
-                sessionId,
-                solutionId: existingName,
-                eventType: 'acted_on',
-                signalSource: 'compound-extract',
-                signalScore: 0.20,
-                meta: {
-                    new_solution: newSolutionName,
-                    via: (supersedes && existingName === supersedes) ? 'supersedes' : 'body-mention',
-                },
-            });
-        }
-    }
-    catch (e) {
-        log.debug('emitCompoundExtractActedOn 실패', e);
-    }
-}
 /** Process LLM extraction results (called after LLM returns) */
 export function processExtractionResults(rawJson, sessionId) {
     const saved = [];
@@ -895,7 +171,6 @@ export function processExtractionResults(rawJson, sessionId) {
     catch {
         return { saved, skipped };
     }
-    // Max 3 per extraction
     for (const sol of solutions.slice(0, 3)) {
         const evaluation = evaluateExtractedSolution(sol);
         if (evaluation.action === 'skip' || evaluation.action === 'duplicate') {
@@ -903,7 +178,6 @@ export function processExtractionResults(rawJson, sessionId) {
             continue;
         }
         if (evaluation.action === 're-extract') {
-            // Increment reExtracted counter on existing solution
             try {
                 updateReExtractedCounter(sol.tags);
             }
@@ -913,13 +187,10 @@ export function processExtractionResults(rawJson, sessionId) {
             skipped.push(evaluation.message ?? `${sol.name}: 재추출`);
             continue;
         }
-        // Clean identifiers before saving (short identifiers are noise)
         sol.identifiers = sol.identifiers.filter(id => id.length >= 4);
-        // Save as experiment
         const savedName = saveExtractedSolution(sol, sessionId);
         if (savedName) {
             saved.push(savedName);
-            // Observability P2: compound-extract acted_on signal
             emitCompoundExtractActedOn(sessionId, savedName, sol.content, null);
         }
         else {