@wooojin/forgen 0.4.10 → 0.4.12

package/dist/core/watch-cli.js

@@ -0,0 +1,185 @@
+/**
+ * forgen watch — real-time hook event stream.
+ *
+ * Tails hook-timing.jsonl, enforcement/violations.jsonl, and
+ * match-eval-log.jsonl to show live forgen activity in a terminal pane.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from './paths.js';
+const isTTY = process.stdout.isTTY;
+const C = {
+    reset: isTTY ? '\x1b[0m' : '',
+    dim: isTTY ? '\x1b[2m' : '',
+    cyan: isTTY ? '\x1b[36m' : '',
+    yellow: isTTY ? '\x1b[33m' : '',
+    green: isTTY ? '\x1b[32m' : '',
+    red: isTTY ? '\x1b[31m' : '',
+    magenta: isTTY ? '\x1b[35m' : '',
+};
+function formatTimestamp(isoOrMs) {
+    try {
+        const d = typeof isoOrMs === 'number' ? new Date(isoOrMs) : new Date(isoOrMs);
+        return d.toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    }
+    catch {
+        return '??:??:??';
+    }
+}
+function formatHookTiming(e) {
+    const hook = String(e.hook ?? '');
+    const ms = Number(e.ms ?? 0);
+    const event = String(e.event ?? '');
+    const ts = formatTimestamp(e.at);
+    const speedColor = ms > 500 ? C.yellow : ms > 1000 ? C.red : C.dim;
+    return `${C.dim}${ts}${C.reset} ${C.cyan}hook${C.reset} ${hook} ${C.dim}(${event})${C.reset} ${speedColor}${ms}ms${C.reset}`;
+}
+function formatViolation(e) {
+    const rule = String(e.rule ?? e.guard ?? e.source ?? 'unknown');
+    const kind = String(e.kind ?? 'block');
+    const ts = formatTimestamp(String(e.at ?? ''));
+    const icon = kind === 'block' ? `${C.red}BLOCK${C.reset}` : `${C.yellow}${kind}${C.reset}`;
+    return `${C.dim}${ts}${C.reset} ${icon} ${C.magenta}${rule}${C.reset}`;
+}
+function formatMatchEval(e) {
+    const source = String(e.source ?? '');
+    const ranked = e.rankedTopN;
+    const ts = formatTimestamp(String(e.ts ?? ''));
+    if (!ranked || !Array.isArray(ranked) || ranked.length === 0)
+        return null;
+    // rankedTopN entries can be strings (names) or objects {name: ...}
+    const names = ranked.slice(0, 3).map(r => {
+        if (typeof r === 'string')
+            return r;
+        if (typeof r === 'object' && r !== null && 'name' in r) {
+            return String(r.name);
+        }
+        return '?';
+    }).filter(Boolean).join(', ');
+    if (!names)
+        return null;
+    return `${C.dim}${ts}${C.reset} ${C.green}match${C.reset} ${C.dim}(${source})${C.reset} ${names}`;
+}
+function tailFile(filePath, fromEnd) {
+    try {
+        if (!fs.existsSync(filePath))
+            return [];
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.trim().split('\n');
+        const tail = lines.slice(-fromEnd);
+        const out = [];
+        for (const line of tail) {
+            try {
+                out.push(JSON.parse(line));
+            }
+            catch { /* skip */ }
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function watchFile(filePath, onLine) {
+    let lastSize = 0;
+    try {
+        if (fs.existsSync(filePath)) {
+            lastSize = fs.statSync(filePath).size;
+        }
+    }
+    catch { /* ok */ }
+    try {
+        return fs.watch(filePath, () => {
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.size <= lastSize) {
+                    lastSize = stat.size;
+                    return;
+                }
+                const fd = fs.openSync(filePath, 'r');
+                const buf = Buffer.alloc(stat.size - lastSize);
+                fs.readSync(fd, buf, 0, buf.length, lastSize);
+                fs.closeSync(fd);
+                lastSize = stat.size;
+                const chunk = buf.toString('utf-8');
+                for (const line of chunk.split('\n')) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        onLine(JSON.parse(line));
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            catch { /* fail-open */ }
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleWatch() {
+    const sources = [
+        {
+            label: 'hooks',
+            path: path.join(STATE_DIR, 'hook-timing.jsonl'),
+            format: formatHookTiming,
+        },
+        {
+            label: 'enforcement',
+            path: path.join(STATE_DIR, 'enforcement', 'violations.jsonl'),
+            format: formatViolation,
+        },
+        {
+            label: 'matches',
+            path: path.join(STATE_DIR, 'match-eval-log.jsonl'),
+            format: formatMatchEval,
+        },
+    ];
+    console.log(`\n  ${C.cyan}forgen watch${C.reset} — real-time event stream`);
+    console.log(`  ${C.dim}Watching: hook-timing, violations, match-eval-log${C.reset}`);
+    console.log(`  ${C.dim}Press Ctrl+C to stop${C.reset}\n`);
+    // Show recent events (last 10 per source)
+    const recent = [];
+    for (const src of sources) {
+        const entries = tailFile(src.path, 10);
+        for (const e of entries) {
+            const line = src.format(e);
+            if (!line)
+                continue;
+            const ts = typeof e.at === 'number' ? e.at
+                : typeof e.at === 'string' ? Date.parse(e.at)
+                    : typeof e.ts === 'string' ? Date.parse(e.ts)
+                        : 0;
+            recent.push({ ts, line });
+        }
+    }
+    recent.sort((a, b) => a.ts - b.ts);
+    if (recent.length > 0) {
+        console.log(`  ${C.dim}── recent ──${C.reset}`);
+        for (const r of recent.slice(-15)) {
+            console.log(`  ${r.line}`);
+        }
+        console.log(`  ${C.dim}── live ──${C.reset}\n`);
+    }
+    // Watch for new events
+    const watchers = [];
+    for (const src of sources) {
+        const watcher = watchFile(src.path, (entry) => {
+            const line = src.format(entry);
+            if (line)
+                console.log(`  ${line}`);
+        });
+        if (watcher)
+            watchers.push(watcher);
+    }
+    // Keep process alive
+    await new Promise((resolve) => {
+        process.on('SIGINT', () => {
+            for (const w of watchers)
+                w.close();
+            console.log(`\n  ${C.dim}watch stopped${C.reset}\n`);
+            resolve();
+        });
+    });
+}

package/dist/core/workflows-cli.d.ts

@@ -0,0 +1,26 @@
+/**
+ * forgen workflows — dynamic-workflow 템플릿 설치/조회 (ADR-009 §3).
+ *
+ * dynamic workflows 는 플러그인 매니페스트로 번들할 수 없고(research preview,
+ * `.claude/workflows/` 에만 저장됨), forgen 은 철학을 인코딩한 canonical 템플릿을
+ * `assets/claude/workflows/*.js` 로 동봉한다. 이 명령이 그것을 사용자의
+ * `.claude/workflows/` 로 복사한다 → `/<name>` 으로 실행 가능.
+ *
+ * forgen-verify 에이전트(verify 스테이지용)는 플러그인 `agents` 키로 자동 배포되므로
+ * 별도 설치가 필요 없다.
+ *
+ *   forgen workflows install            ~/.claude/workflows/ (개인, 모든 프로젝트)
+ *   forgen workflows install --project  <cwd>/.claude/workflows/ (저장소 공유)
+ *   forgen workflows list               동봉 템플릿 + 설치 여부
+ */
+/** forgen pkg root 의 assets/claude/workflows 디렉토리. invoke-agent 와 동일 walk-up. */
+export declare function findTemplatesDir(): string;
+/** 템플릿 파일명(.js) 목록. 실패 시 []. */
+export declare function listTemplates(templatesDir: string): string[];
+export interface InstallResult {
+    installed: string[];
+    targetDir: string;
+}
+/** 템플릿을 targetDir 로 복사 (DI — 테스트 주입용). 기존 파일은 덮어쓴다. */
+export declare function installWorkflows(templatesDir: string, targetDir: string): InstallResult;
+export declare function handleWorkflows(args: string[]): Promise<void>;

package/dist/core/workflows-cli.js

@@ -0,0 +1,120 @@
+/**
+ * forgen workflows — dynamic-workflow 템플릿 설치/조회 (ADR-009 §3).
+ *
+ * dynamic workflows 는 플러그인 매니페스트로 번들할 수 없고(research preview,
+ * `.claude/workflows/` 에만 저장됨), forgen 은 철학을 인코딩한 canonical 템플릿을
+ * `assets/claude/workflows/*.js` 로 동봉한다. 이 명령이 그것을 사용자의
+ * `.claude/workflows/` 로 복사한다 → `/<name>` 으로 실행 가능.
+ *
+ * forgen-verify 에이전트(verify 스테이지용)는 플러그인 `agents` 키로 자동 배포되므로
+ * 별도 설치가 필요 없다.
+ *
+ *   forgen workflows install            ~/.claude/workflows/ (개인, 모든 프로젝트)
+ *   forgen workflows install --project  <cwd>/.claude/workflows/ (저장소 공유)
+ *   forgen workflows list               동봉 템플릿 + 설치 여부
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const isTTY = process.stdout.isTTY;
+const C = {
+    reset: isTTY ? '\x1b[0m' : '',
+    bold: isTTY ? '\x1b[1m' : '',
+    dim: isTTY ? '\x1b[2m' : '',
+    green: isTTY ? '\x1b[32m' : '',
+    cyan: isTTY ? '\x1b[36m' : '',
+};
+/** forgen pkg root 의 assets/claude/workflows 디렉토리. invoke-agent 와 동일 walk-up. */
+export function findTemplatesDir() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let depth = 0; depth < 8; depth += 1) {
+        const pkgJson = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgJson)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgJson, 'utf-8'));
+                if (pkg.name === '@wooojin/forgen') {
+                    const candidate = path.join(dir, 'assets', 'claude', 'workflows');
+                    if (fs.existsSync(candidate))
+                        return candidate;
+                }
+            }
+            catch { /* fallthrough */ }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    throw new Error('forgen workflows: pkg root + assets/claude/workflows/ not found');
+}
+/** 템플릿 파일명(.js) 목록. 실패 시 []. */
+export function listTemplates(templatesDir) {
+    try {
+        return fs.readdirSync(templatesDir).filter((f) => f.endsWith('.js')).sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** 템플릿을 targetDir 로 복사 (DI — 테스트 주입용). 기존 파일은 덮어쓴다. */
+export function installWorkflows(templatesDir, targetDir) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    const installed = [];
+    for (const file of listTemplates(templatesDir)) {
+        fs.copyFileSync(path.join(templatesDir, file), path.join(targetDir, file));
+        installed.push(file);
+    }
+    return { installed, targetDir };
+}
+function resolveTargetBase(projectScope) {
+    return projectScope ? process.cwd() : os.homedir();
+}
+export async function handleWorkflows(args) {
+    const sub = args[0] ?? 'list';
+    const projectScope = args.includes('--project');
+    let templatesDir;
+    try {
+        templatesDir = findTemplatesDir();
+    }
+    catch {
+        console.log(`\n  ${C.dim}워크플로우 템플릿을 찾을 수 없습니다 (forgen 설치 확인).${C.reset}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (sub === 'install') {
+        const targetDir = path.join(resolveTargetBase(projectScope), '.claude', 'workflows');
+        const { installed } = installWorkflows(templatesDir, targetDir);
+        if (installed.length === 0) {
+            console.log(`\n  ${C.dim}동봉된 템플릿이 없습니다.${C.reset}\n`);
+            return;
+        }
+        console.log(`\n  ${C.green}✓${C.reset} ${installed.length} workflow templates → ${C.cyan}${targetDir}${C.reset}`);
+        for (const f of installed)
+            console.log(`      /${f.replace(/\.js$/, '')}`);
+        console.log(`\n  ${C.dim}Claude Code 에서 /<name> 으로 실행. verify 스테이지는 forgen-verify 에이전트 사용.${C.reset}\n`);
+        return;
+    }
+    if (sub === 'list') {
+        const templates = listTemplates(templatesDir);
+        const homeDir = path.join(os.homedir(), '.claude', 'workflows');
+        const projDir = path.join(process.cwd(), '.claude', 'workflows');
+        console.log(`\n  ${C.bold}forgen workflow templates${C.reset}\n`);
+        for (const f of templates) {
+            const name = f.replace(/\.js$/, '');
+            const inHome = fs.existsSync(path.join(homeDir, f));
+            const inProj = fs.existsSync(path.join(projDir, f));
+            const where = [inHome && 'user', inProj && 'project'].filter(Boolean).join('+') || 'not installed';
+            console.log(`    ${inHome || inProj ? C.green + '✓' + C.reset : C.dim + '·' + C.reset} /${name}  ${C.dim}(${where})${C.reset}`);
+        }
+        console.log(`\n  ${C.dim}install: forgen workflows install [--project]${C.reset}\n`);
+        return;
+    }
+    console.log(`
+  ${C.bold}forgen workflows${C.reset} — dynamic-workflow 템플릿 (ADR-009 §3)
+
+  Usage:
+    forgen workflows install [--project]   템플릿을 .claude/workflows/ 로 복사
+    forgen workflows list                  동봉 템플릿 + 설치 여부
+`);
+}

package/dist/engine/compound-export.d.ts

@@ -50,6 +50,18 @@ export declare function exportKnowledge(outputPath?: string): ExportResult;
  * added.
  */
 export declare function importKnowledge(archivePath: string): ImportResult;
+/**
+ * Selective export — filter to specific categories.
+ * `--only solutions,rules` exports only those two directories.
+ */
+export declare function exportKnowledgeSelective(categories: string[], outputPath?: string): ExportResult;
+/**
+ * Import with merge mode — updates existing files instead of skipping them.
+ * Newer files in the archive overwrite older local files.
+ */
+export declare function importKnowledgeMerge(archivePath: string): ImportResult & {
+    merged: number;
+};
 /** CLI handler: forgen compound export */
 export declare function handleExport(args: string[]): Promise<void>;
 /** CLI handler: forgen compound import */

package/dist/engine/compound-export.js

@@ -152,14 +152,116 @@ export function importKnowledge(archivePath) {
         fs.rmSync(tmpDir, { recursive: true, force: true });
     }
 }
+/**
+ * Selective export — filter to specific categories.
+ * `--only solutions,rules` exports only those two directories.
+ */
+export function exportKnowledgeSelective(categories, outputPath) {
+    const date = new Date().toISOString().split('T')[0];
+    const resolved = outputPath ?? path.join(process.cwd(), `forgen-knowledge-${date}.tar.gz`);
+    const validCategories = categories.filter(c => KNOWLEDGE_DIRS.includes(c));
+    if (validCategories.length === 0) {
+        throw new Error(`No valid categories. Choose from: ${KNOWLEDGE_DIRS.join(', ')}`);
+    }
+    const counts = {};
+    const existingDirs = [];
+    for (const name of validCategories) {
+        const dir = path.join(ME_DIR, name);
+        const count = countFiles(dir);
+        counts[name] = count;
+        if (fs.existsSync(dir)) {
+            existingDirs.push(name);
+        }
+    }
+    const totalFiles = Object.values(counts).reduce((a, b) => a + b, 0);
+    if (existingDirs.length === 0) {
+        throw new Error('No knowledge directories found to export.');
+    }
+    const outDir = path.dirname(resolved);
+    fs.mkdirSync(outDir, { recursive: true });
+    execFileSync('tar', ['czf', resolved, ...existingDirs], {
+        cwd: ME_DIR,
+        timeout: 30000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { outputPath: resolved, counts, totalFiles };
+}
+/**
+ * Import with merge mode — updates existing files instead of skipping them.
+ * Newer files in the archive overwrite older local files.
+ */
+export function importKnowledgeMerge(archivePath) {
+    if (!fs.existsSync(archivePath)) {
+        throw new Error(`Archive not found: ${archivePath}`);
+    }
+    const listOutput = execFileSync('tar', ['tzf', archivePath], {
+        timeout: 30000,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const archiveFiles = listOutput
+        .split('\n')
+        .map(f => f.trim())
+        .filter(f => f && !f.endsWith('/'));
+    const tmpDir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'forgen-merge-'));
+    try {
+        execFileSync('tar', ['xzf', archivePath, '-C', tmpDir], {
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const result = { imported: 0, skipped: 0, merged: 0, details: [] };
+        const meDirCanon = path.resolve(ME_DIR) + path.sep;
+        const tmpDirCanon = path.resolve(tmpDir) + path.sep;
+        for (const relFile of archiveFiles) {
+            const srcPath = path.resolve(path.join(tmpDir, relFile));
+            const destPath = path.resolve(path.join(ME_DIR, relFile));
+            if (!isPathInside(meDirCanon, destPath) || !isPathInside(tmpDirCanon, srcPath)) {
+                result.skipped++;
+                result.details.push({ file: relFile, action: 'skipped' });
+                continue;
+            }
+            if (fs.existsSync(destPath)) {
+                const srcMtime = fs.statSync(srcPath).mtimeMs;
+                const destMtime = fs.statSync(destPath).mtimeMs;
+                if (srcMtime > destMtime) {
+                    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                    fs.copyFileSync(srcPath, destPath);
+                    result.merged++;
+                    result.details.push({ file: relFile, action: 'imported' });
+                }
+                else {
+                    result.skipped++;
+                    result.details.push({ file: relFile, action: 'skipped' });
+                }
+            }
+            else {
+                fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                fs.copyFileSync(srcPath, destPath);
+                result.imported++;
+                result.details.push({ file: relFile, action: 'imported' });
+            }
+        }
+        return result;
+    }
+    finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
 /** CLI handler: forgen compound export */
 export async function handleExport(args) {
     const outputIdx = args.indexOf('--output');
     const outputPath = outputIdx !== -1 ? args[outputIdx + 1] : undefined;
+    const onlyIdx = args.indexOf('--only');
+    const onlyCategories = onlyIdx !== -1 ? (args[onlyIdx + 1] ?? '').split(',').filter(Boolean) : [];
     try {
-        const result = exportKnowledge(outputPath);
+        const result = onlyCategories.length > 0
+            ? exportKnowledgeSelective(onlyCategories, outputPath)
+            : exportKnowledge(outputPath);
         console.log('\n  Compound Knowledge Export\n');
         console.log(`  Output: ${result.outputPath}`);
+        if (onlyCategories.length > 0) {
+            console.log(`  Filter: ${onlyCategories.join(', ')}`);
+        }
         console.log();
         for (const [category, count] of Object.entries(result.counts)) {
             console.log(`    ${category}: ${count} files`);
@@ -173,23 +275,43 @@ export async function handleExport(args) {
 }
 /** CLI handler: forgen compound import */
 export async function handleImport(args) {
-    const archivePath = args[0];
-    if (!archivePath || archivePath.startsWith('--')) {
-        console.log('  Usage: forgen compound import <path-to-archive>\n');
+    const filteredArgs = args.filter(a => !a.startsWith('--'));
+    const archivePath = filteredArgs[0];
+    const mergeMode = args.includes('--merge');
+    if (!archivePath) {
+        console.log('  Usage: forgen compound import <path-to-archive> [--merge]\n');
+        console.log('  --merge  Update existing files if archive version is newer');
         return;
     }
     try {
         const resolved = path.resolve(archivePath);
-        const result = importKnowledge(resolved);
-        console.log('\n  Compound Knowledge Import\n');
-        console.log(`  Archive: ${resolved}`);
-        console.log(`  Imported: ${result.imported} new files`);
-        console.log(`  Skipped: ${result.skipped} existing files`);
-        if (result.details.length > 0 && result.details.length <= 20) {
-            console.log();
-            for (const d of result.details) {
-                const icon = d.action === 'imported' ? '+' : '-';
-                console.log(`    ${icon} ${d.file}`);
+        if (mergeMode) {
+            const result = importKnowledgeMerge(resolved);
+            console.log('\n  Compound Knowledge Import (merge mode)\n');
+            console.log(`  Archive: ${resolved}`);
+            console.log(`  New:     ${result.imported} files`);
+            console.log(`  Merged:  ${result.merged} files (newer version overwrote local)`);
+            console.log(`  Skipped: ${result.skipped} files (local is same or newer)`);
+            if (result.details.length > 0 && result.details.length <= 20) {
+                console.log();
+                for (const d of result.details) {
+                    const icon = d.action === 'imported' ? '+' : '-';
+                    console.log(`    ${icon} ${d.file}`);
+                }
+            }
+        }
+        else {
+            const result = importKnowledge(resolved);
+            console.log('\n  Compound Knowledge Import\n');
+            console.log(`  Archive: ${resolved}`);
+            console.log(`  Imported: ${result.imported} new files`);
+            console.log(`  Skipped: ${result.skipped} existing files`);
+            if (result.details.length > 0 && result.details.length <= 20) {
+                console.log();
+                for (const d of result.details) {
+                    const icon = d.action === 'imported' ? '+' : '-';
+                    console.log(`    ${icon} ${d.file}`);
+                }
             }
         }
         console.log();

package/dist/engine/compound-extractor.d.ts

@@ -1,54 +1,24 @@
 /**
- * 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 type { SolutionType } from './solution-format.js';
-interface ExtractedSolution {
-    name: string;
-    type: SolutionType;
-    tags: string[];
-    identifiers: string[];
-    context: string;
-    content: string;
-}
-interface WriteContextEntry {
-    filePath: string;
-    contentSnippet: string;
-    fileExtension: string;
-}
-/**
- * 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 declare function loadClaudeProjectSessionContext(cwd: string, lastExtractedAt: string): {
-    prompts: string[];
-    writes: WriteContextEntry[];
-};
+import type { ExtractedSolution } from './extraction-gates.js';
+export { loadClaudeProjectSessionContext } from './extraction-session.js';
+export type { ExtractedSolution } from './extraction-gates.js';
 export declare function previewExtraction(cwd: string): Promise<{
     preview: ExtractedSolution[];
     skipped: string[];
     reason?: string;
 }>;
-/** Main extraction function — called from SessionStart or CLI */
 export declare function runExtraction(cwd: string, sessionId: string): Promise<{
     extracted: string[];
     skipped: string[];
@@ -65,4 +35,3 @@ export declare function isExtractionPaused(): boolean;
 export declare function pauseExtraction(): void;
 /** Resume auto-extraction */
 export declare function resumeExtraction(): void;
-export {};