@wooojin/forgen 0.2.0 → 0.3.0

package/dist/core/spawn.js

@@ -12,6 +12,9 @@ const log = createLogger('spawn');
 function findClaude() {
     return 'claude';
 }
+function findRuntimeLauncher(runtime) {
+    return runtime === 'codex' ? 'codex' : findClaude();
+}
 /**
  * 가장 최근 transcript 파일을 찾는다.
  * Claude Code는 세션 대화를 ~/.claude/projects/{sanitized-cwd}/{uuid}.jsonl에 저장.
@@ -60,32 +63,43 @@ async function indexTranscriptToFTS(cwd, transcriptPath, sessionId) {
     }
 }
 /** Claude Code를 하네스 환경으로 실행. exit code를 반환. */
-export async function spawnClaude(args, context) {
-    const claudePath = findClaude();
-    const env = buildEnv(context.cwd);
+export async function spawnClaude(args, context, runtime = 'claude') {
+    const launcher = findRuntimeLauncher(runtime);
+    const env = buildEnv(context.cwd, context.v1.session?.session_id, runtime);
     const cleanArgs = [...args];
     // config.json에서 dangerouslySkipPermissions 기본값 적용
     const globalConfig = loadGlobalConfig();
-    if (globalConfig.dangerouslySkipPermissions && !cleanArgs.includes('--dangerously-skip-permissions')) {
+    if (runtime === 'claude' &&
+        globalConfig.dangerouslySkipPermissions &&
+        !cleanArgs.includes('--dangerously-skip-permissions')) {
         cleanArgs.unshift('--dangerously-skip-permissions');
     }
     // 세션 시작 전 timestamp 기록 (종료 후 transcript 찾기 위해)
     const sessionStartTime = Date.now();
     return new Promise((resolve, reject) => {
-        const child = spawn(claudePath, cleanArgs, {
+        const child = spawn(launcher, cleanArgs, {
             stdio: 'inherit',
             env: { ...process.env, ...env },
             cwd: context.cwd,
         });
         child.on('error', (err) => {
             if (err.code === 'ENOENT') {
-                reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
+                if (runtime === 'codex') {
+                    reject(new Error('Codex is not installed.'));
+                }
+                else {
+                    reject(new Error('Claude Code is not installed. npm install -g @anthropic-ai/claude-code'));
+                }
             }
             else {
                 reject(err);
             }
         });
         child.on('exit', async (code) => {
+            if (runtime !== 'claude') {
+                resolve(code ?? 0);
+                return;
+            }
             // 세션 종료 후 하네스 작업
             try {
                 const transcript = findLatestTranscript(context.cwd);
@@ -135,11 +149,16 @@ const MAX_RESUMES = 3;
  * 토큰 한도 도달 시 자동 재시작을 지원하는 claude 실행 래퍼.
  * context-guard가 pending-resume.json 마커를 생성하면 쿨다운 후 재시작.
  */
-export async function spawnClaudeWithResume(args, context, contextFactory) {
+export async function spawnClaudeWithResume(args, context, contextFactory, runtime = 'claude') {
     let resumeCount = 0;
     let currentContext = context;
     while (true) {
-        const exitCode = await spawnClaude(args, currentContext);
+        const exitCode = await spawnClaude(args, currentContext, runtime);
+        if (runtime !== 'claude') {
+            if (exitCode !== 0)
+                process.exit(exitCode);
+            break;
+        }
         const resumePath = path.join(STATE_DIR, 'pending-resume.json');
         if (!fs.existsSync(resumePath)) {
             if (exitCode !== 0)

package/dist/core/types.d.ts

@@ -106,3 +106,37 @@ export interface HarnessContext {
     /** 모델 라우팅 프리셋 (default, cost-saving, max-quality) */
     routingPreset?: string;
 }
+/** 런타임 Host */
+export type RuntimeHost = 'claude' | 'codex';
+/** 런칭 컨텍스트 — CLI에서 runtime/args 결정을 모델화 */
+export interface LaunchContext {
+    runtime: RuntimeHost;
+    args: string[];
+    runtimeSource: 'flag' | 'env' | 'default';
+}
+/** 훅 입력 이벤트 스키마 (버전 간 상위 호환용 최소 스펙) */
+export interface HookEventInput {
+    hookEventName?: string;
+    event?: string;
+    session_id?: string;
+    sessionId?: string;
+    tool_name?: string;
+    toolName?: string;
+    tool_input?: Record<string, unknown>;
+    toolInput?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** 훅 출력 스키마 (Claude/Codex 정규화용 공통 뷰) */
+export interface HookEventOutput {
+    continue?: boolean;
+    suppressOutput?: boolean;
+    systemMessage?: string;
+    hookSpecificOutput?: {
+        hookEventName?: string;
+        permissionDecision?: string;
+        permissionDecisionReason?: string;
+        additionalContext?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}

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

@@ -0,0 +1,41 @@
+/**
+ * Forgen — Compound Knowledge Export/Import
+ *
+ * Provides backup, migration, and sharing of accumulated personal knowledge
+ * stored under ~/.forgen/me/ (solutions/, rules/, behavior/).
+ *
+ * Export creates a tar.gz archive; Import extracts it while skipping existing
+ * files to prevent accidental overwrites.
+ */
+export interface ExportResult {
+    outputPath: string;
+    counts: Record<string, number>;
+    totalFiles: number;
+}
+export interface ImportResult {
+    imported: number;
+    skipped: number;
+    details: {
+        file: string;
+        action: 'imported' | 'skipped';
+    }[];
+}
+/**
+ * Export knowledge directories to a tar.gz archive.
+ *
+ * Uses `tar czf` via child_process for simplicity and reliability.
+ * Only archives solutions/, rules/, behavior/ under ME_DIR.
+ */
+export declare function exportKnowledge(outputPath?: string): ExportResult;
+/**
+ * Import knowledge from a tar.gz archive.
+ *
+ * For each file in the archive, if a file with the same name already exists
+ * in the target directory, it is SKIPPED (no overwrite). Only new files are
+ * added.
+ */
+export declare function importKnowledge(archivePath: string): ImportResult;
+/** CLI handler: forgen compound export */
+export declare function handleExport(args: string[]): Promise<void>;
+/** CLI handler: forgen compound import */
+export declare function handleImport(args: string[]): Promise<void>;

package/dist/engine/compound-export.js

@@ -0,0 +1,169 @@
+/**
+ * Forgen — Compound Knowledge Export/Import
+ *
+ * Provides backup, migration, and sharing of accumulated personal knowledge
+ * stored under ~/.forgen/me/ (solutions/, rules/, behavior/).
+ *
+ * Export creates a tar.gz archive; Import extracts it while skipping existing
+ * files to prevent accidental overwrites.
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { ME_DIR } from '../core/paths.js';
+/** Directories within ME_DIR to include in the archive. */
+const KNOWLEDGE_DIRS = ['solutions', 'rules', 'behavior'];
+/**
+ * Count .md files in a directory (non-recursive).
+ * Returns 0 if the directory does not exist.
+ */
+function countFiles(dir) {
+    try {
+        if (!fs.existsSync(dir))
+            return 0;
+        return fs.readdirSync(dir).filter(f => f.endsWith('.md')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Export knowledge directories to a tar.gz archive.
+ *
+ * Uses `tar czf` via child_process for simplicity and reliability.
+ * Only archives solutions/, rules/, behavior/ under ME_DIR.
+ */
+export function exportKnowledge(outputPath) {
+    const date = new Date().toISOString().split('T')[0];
+    const resolved = outputPath ?? path.join(process.cwd(), `forgen-knowledge-${date}.tar.gz`);
+    // Gather counts before archiving
+    const counts = {};
+    const existingDirs = [];
+    for (const name of KNOWLEDGE_DIRS) {
+        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.');
+    }
+    // Ensure output directory exists
+    const outDir = path.dirname(resolved);
+    fs.mkdirSync(outDir, { recursive: true });
+    // Create tar.gz relative to ME_DIR so archive paths are solutions/*, rules/*, behavior/*
+    execFileSync('tar', ['czf', resolved, ...existingDirs], {
+        cwd: ME_DIR,
+        timeout: 30000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { outputPath: resolved, counts, totalFiles };
+}
+/**
+ * Import knowledge from a tar.gz archive.
+ *
+ * For each file in the archive, if a file with the same name already exists
+ * in the target directory, it is SKIPPED (no overwrite). Only new files are
+ * added.
+ */
+export function importKnowledge(archivePath) {
+    if (!fs.existsSync(archivePath)) {
+        throw new Error(`Archive not found: ${archivePath}`);
+    }
+    // List files in the archive
+    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('/'));
+    // Extract to a temp directory first, then selectively copy
+    const tmpDir = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'forgen-import-'));
+    try {
+        execFileSync('tar', ['xzf', archivePath, '-C', tmpDir], {
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const result = { imported: 0, skipped: 0, details: [] };
+        for (const relFile of archiveFiles) {
+            const srcPath = path.join(tmpDir, relFile);
+            const destPath = path.join(ME_DIR, relFile);
+            // Security: ensure the dest path stays within ME_DIR
+            const realDest = path.resolve(destPath);
+            if (!realDest.startsWith(ME_DIR)) {
+                result.skipped++;
+                result.details.push({ file: relFile, action: 'skipped' });
+                continue;
+            }
+            if (fs.existsSync(destPath)) {
+                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 {
+        // Clean up temp directory
+        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;
+    try {
+        const result = exportKnowledge(outputPath);
+        console.log('\n  Compound Knowledge Export\n');
+        console.log(`  Output: ${result.outputPath}`);
+        console.log();
+        for (const [category, count] of Object.entries(result.counts)) {
+            console.log(`    ${category}: ${count} files`);
+        }
+        console.log(`\n  Total: ${result.totalFiles} files exported.\n`);
+    }
+    catch (e) {
+        console.error(`\n  Export failed: ${e.message}\n`);
+        process.exit(1);
+    }
+}
+/** 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');
+        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}`);
+            }
+        }
+        console.log();
+    }
+    catch (e) {
+        console.error(`\n  Import failed: ${e.message}\n`);
+        process.exit(1);
+    }
+}

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

@@ -1,4 +1,5 @@
 import type { SolutionFrontmatter, SolutionStatus } from './solution-format.js';
+import type { AdaptiveLifecycleThresholds } from './meta-learning/types.js';
 export interface LifecycleResult {
     promoted: string[];
     demoted: string[];
@@ -11,8 +12,8 @@ export declare function nextStatus(current: SolutionStatus): SolutionStatus | nu
  * Spacing: 0.25 between levels for meaningful differentiation in matching scores.
  * Previous: 0.3/0.6/0.8/0.85 had only 0.05 gap between verified and mature. */
 export declare function statusConfidence(status: SolutionStatus): number;
-/** Check promotion eligibility */
-export declare function checkPromotion(fm: SolutionFrontmatter): boolean;
+/** Check promotion eligibility (with optional adaptive thresholds) */
+export declare function checkPromotion(fm: SolutionFrontmatter, thresholds?: AdaptiveLifecycleThresholds | null): boolean;
 /** Check if solution should be demoted due to confidence-status mismatch */
 export declare function checkConfidenceDemotion(fm: SolutionFrontmatter): SolutionStatus | null;
 /** Check if solution identifiers still exist in codebase (staleness detection) */
@@ -25,7 +26,7 @@ export declare function isStale(fm: SolutionFrontmatter): boolean;
  */
 export declare function updateSolutionFile(filePath: string, updates: Partial<SolutionFrontmatter>): boolean;
 /** Run lifecycle check on all solutions */
-export declare function runLifecycleCheck(sessionId?: string): LifecycleResult;
+export declare function runLifecycleCheck(_sessionId?: string): LifecycleResult;
 /** Detect contradictions between solutions */
 export declare function detectContradictions(dirs: string[]): string[];
 /** Manual verify command: immediately promote to verified */

package/dist/engine/compound-lifecycle.js

@@ -1,11 +1,12 @@
+import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { execFileSync } from 'node:child_process';
+import { createLogger } from '../core/logger.js';
 import { parseFrontmatterOnly } from './solution-format.js';
 import { mutateSolutionFile } from './solution-writer.js';
-import { createLogger } from '../core/logger.js';
 const log = createLogger('compound-lifecycle');
-import { ME_SOLUTIONS, ME_RULES } from '../core/paths.js';
+import { ME_RULES, ME_SOLUTIONS, META_LEARNING_DIR } from '../core/paths.js';
+import { safeReadJSON } from '../hooks/shared/atomic-write.js';
 /** Circuit breaker negative thresholds by status */
 const CIRCUIT_BREAKER_THRESHOLDS = {
     experiment: 2,
@@ -29,10 +30,14 @@ const STATUS_CONFIDENCE_MIN = {
 /** Get the next promotion status */
 export function nextStatus(current) {
     switch (current) {
-        case 'experiment': return 'candidate';
-        case 'candidate': return 'verified';
-        case 'verified': return 'mature';
-        default: return null;
+        case 'experiment':
+            return 'candidate';
+        case 'candidate':
+            return 'verified';
+        case 'verified':
+            return 'mature';
+        default:
+            return null;
     }
 }
 /** Get confidence for a status level.
@@ -40,30 +45,54 @@ export function nextStatus(current) {
  * Previous: 0.3/0.6/0.8/0.85 had only 0.05 gap between verified and mature. */
 export function statusConfidence(status) {
     switch (status) {
-        case 'experiment': return 0.3;
-        case 'candidate': return 0.55;
-        case 'verified': return 0.75;
-        case 'mature': return 0.90;
-        case 'retired': return 0;
+        case 'experiment':
+            return 0.3;
+        case 'candidate':
+            return 0.55;
+        case 'verified':
+            return 0.75;
+        case 'mature':
+            return 0.9;
+        case 'retired':
+            return 0;
     }
 }
-/** Check promotion eligibility */
-export function checkPromotion(fm) {
+/** Load adaptive thresholds from meta-learning state (returns null if not tuned) */
+function loadAdaptiveThresholds() {
+    const thresholdsPath = path.join(META_LEARNING_DIR, 'lifecycle-thresholds.json');
+    return safeReadJSON(thresholdsPath, null);
+}
+/** Check promotion eligibility (with optional adaptive thresholds) */
+export function checkPromotion(fm, thresholds) {
     const ev = fm.evidence;
+    const t = thresholds ?? null;
     switch (fm.status) {
-        case 'experiment':
-            // A: reflected >= 3 AND negative == 0 AND sessions >= 3 (Beta(4,1) → P(rate>0.5)=0.94)
-            // B: reExtracted >= 2 AND negative == 0 AND reflected >= 1 (prevents trivial re-extraction)
-            return (ev.negative === 0) && ((ev.reflected >= 3 && ev.sessions >= 3) ||
-                (ev.reExtracted >= 2 && ev.reflected >= 1));
-        case 'candidate':
-            // A: reflected >= 4 AND negative == 0 AND sessions >= 3
-            // B: reExtracted >= 2 AND negative == 0
-            return (ev.negative === 0) && ((ev.reflected >= 4 && ev.sessions >= 3) ||
-                (ev.reExtracted >= 2));
-        case 'verified':
-            // reflected >= 8, negative <= 1, sessions >= 5
-            return ev.reflected >= 8 && ev.negative <= 1 && ev.sessions >= 5;
+        case 'experiment': {
+            const minReflected = t?.experiment.reflected ?? 3;
+            const minSessions = t?.experiment.sessions ?? 3;
+            const minReExtracted = t?.experiment.reExtracted ?? 2;
+            // A: reflected >= threshold AND negative == 0 AND sessions >= threshold
+            // B: reExtracted >= threshold AND negative == 0 AND reflected >= 1
+            return (ev.negative === 0 &&
+                ((ev.reflected >= minReflected && ev.sessions >= minSessions) ||
+                    (ev.reExtracted >= minReExtracted && ev.reflected >= 1)));
+        }
+        case 'candidate': {
+            const minReflected = t?.candidate.reflected ?? 4;
+            const minSessions = t?.candidate.sessions ?? 3;
+            const minReExtracted = t?.candidate.reExtracted ?? 2;
+            // A: reflected >= threshold AND negative == 0 AND sessions >= threshold
+            // B: reExtracted >= threshold AND negative == 0
+            return (ev.negative === 0 &&
+                ((ev.reflected >= minReflected && ev.sessions >= minSessions) ||
+                    ev.reExtracted >= minReExtracted));
+        }
+        case 'verified': {
+            const minReflected = t?.verified.reflected ?? 8;
+            const minSessions = t?.verified.sessions ?? 5;
+            const maxNegative = t?.verified.negative ?? 1;
+            return (ev.reflected >= minReflected && ev.negative <= maxNegative && ev.sessions >= minSessions);
+        }
         default:
             return false;
     }
@@ -88,21 +117,28 @@ export function checkIdentifierStaleness(fm, cwd) {
     if (fm.identifiers.length === 0)
         return false; // no identifiers to check
     try {
-        const validIds = fm.identifiers.slice(0, 5).filter(id => id.length >= 6);
+        const validIds = fm.identifiers.slice(0, 5).filter((id) => id.length >= 6);
         // All identifiers were too short — nothing to grep, treat as stale (matches original behavior)
         if (validIds.length === 0)
             return true;
         // Escape regex metacharacters and join with OR for a single grep call
         // (previously: one execFileSync per identifier — up to 15s worst case)
-        const pattern = validIds.map(id => id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+        const pattern = validIds.map((id) => id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
         execFileSync('grep', [
-            '-r', '-E',
-            '--include=*.ts', '--include=*.tsx',
-            '--include=*.js', '--include=*.jsx',
+            '-r',
+            '-E',
+            '--include=*.ts',
+            '--include=*.tsx',
+            '--include=*.js',
+            '--include=*.jsx',
             '--exclude-dir=node_modules',
             '--exclude-dir=dist',
             '--exclude-dir=.git',
-            '-l', '-m', '1', pattern, '.',
+            '-l',
+            '-m',
+            '1',
+            pattern,
+            '.',
         ], { cwd, encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
         return false; // grep exit 0 = at least one identifier found = not stale
     }
@@ -143,7 +179,7 @@ export function isStale(fm) {
  * PR2b: solution-writer.mutateSolutionFile로 통합. lock + fresh re-read + atomic write.
  */
 export function updateSolutionFile(filePath, updates) {
-    return mutateSolutionFile(filePath, sol => {
+    return mutateSolutionFile(filePath, (sol) => {
         sol.frontmatter = {
             ...sol.frontmatter,
             ...updates,
@@ -152,15 +188,17 @@ export function updateSolutionFile(filePath, updates) {
     });
 }
 /** Run lifecycle check on all solutions */
-export function runLifecycleCheck(sessionId = 'system') {
+export function runLifecycleCheck(_sessionId = 'system') {
     const result = { promoted: [], demoted: [], retired: [], contradictions: [] };
+    // Meta-learning: load adaptive thresholds if available
+    const adaptiveThresholds = loadAdaptiveThresholds();
     const dirs = [ME_SOLUTIONS, ME_RULES];
     for (const dir of dirs) {
         if (!fs.existsSync(dir))
             continue;
         let files;
         try {
-            files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
         }
         catch {
             continue;
@@ -182,7 +220,10 @@ export function runLifecycleCheck(sessionId = 'system') {
                 // 2. Check confidence-status consistency
                 const demoteTo = checkConfidenceDemotion(fm);
                 if (demoteTo) {
-                    if (updateSolutionFile(filePath, { status: demoteTo, confidence: statusConfidence(demoteTo) })) {
+                    if (updateSolutionFile(filePath, {
+                        status: demoteTo,
+                        confidence: statusConfidence(demoteTo),
+                    })) {
                         result.demoted.push(`${fm.name}: ${fm.status} → ${demoteTo}`);
                     }
                     continue;
@@ -198,7 +239,7 @@ export function runLifecycleCheck(sessionId = 'system') {
                 // 4. Check promotion FIRST (with minimum age gate based on updated timestamp)
                 //    Promotion must run before identifier staleness to give solutions a chance
                 //    to be promoted before being penalized for stale identifiers.
-                if (checkPromotion(fm)) {
+                if (checkPromotion(fm, adaptiveThresholds)) {
                     const minAgeMs = MIN_AGE_FOR_PROMOTION[fm.status] ?? 0;
                     const ageMs = Date.now() - new Date(fm.updated || fm.created).getTime();
                     if (ageMs >= minAgeMs) {
@@ -215,7 +256,7 @@ export function runLifecycleCheck(sessionId = 'system') {
                 if (fm.identifiers.length > 0) {
                     const effectiveCwd = process.env.FORGEN_CWD ?? process.env.COMPOUND_CWD ?? process.cwd();
                     if (checkIdentifierStaleness(fm, effectiveCwd)) {
-                        const newConf = Math.max(0, fm.confidence - 0.20);
+                        const newConf = Math.max(0, fm.confidence - 0.2);
                         if (updateSolutionFile(filePath, { confidence: newConf })) {
                             result.demoted.push(`${fm.name}: identifier-stale (confidence → ${newConf})`);
                         }
@@ -239,7 +280,7 @@ export function detectContradictions(dirs) {
         if (!fs.existsSync(dir))
             continue;
         try {
-            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
             for (const file of files) {
                 const content = fs.readFileSync(path.join(dir, file), 'utf-8');
                 const fm = parseFrontmatterOnly(content);
@@ -248,22 +289,24 @@ export function detectContradictions(dirs) {
                 solutions.push({ name: fm.name, tags: fm.tags, identifiers: fm.identifiers });
             }
         }
-        catch { /* 솔루션 파일 파싱 실패 무시 — 중복 감지는 best-effort */ }
+        catch {
+            /* 솔루션 파일 파싱 실패 무시 — 중복 감지는 best-effort */
+        }
     }
     // Pre-build tag Sets for O(1) lookup — avoids O(m²) per pair
-    const tagSets = solutions.map(s => new Set(s.tags));
+    const tagSets = solutions.map((s) => new Set(s.tags));
     // Pairwise comparison
     for (let i = 0; i < solutions.length; i++) {
         for (let j = i + 1; j < solutions.length; j++) {
             const a = solutions[i];
             const b = solutions[j];
             // Tags overlap > 70%
-            const overlap = a.tags.filter(t => tagSets[j].has(t));
+            const overlap = a.tags.filter((t) => tagSets[j].has(t));
             const overlapRatio = overlap.length / Math.max(a.tags.length, b.tags.length, 1);
             if (overlapRatio < 0.7)
                 continue;
             // Identifiers completely different
-            const idOverlap = a.identifiers.filter(id => b.identifiers.includes(id));
+            const idOverlap = a.identifiers.filter((id) => b.identifiers.includes(id));
             if (idOverlap.length === 0 && a.identifiers.length > 0 && b.identifiers.length > 0) {
                 contradictions.push(`${a.name} vs ${b.name} (tags ${(overlapRatio * 100).toFixed(0)}% overlap, identifiers disjoint)`);
             }
@@ -278,7 +321,7 @@ export function verifySolution(solutionName) {
         if (!fs.existsSync(dir))
             continue;
         try {
-            const files = fs.readdirSync(dir).filter(f => f.endsWith('.md'));
+            const files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
             for (const file of files) {
                 const filePath = path.join(dir, file);
                 // PR2c-4 (security L-1): symlink을 통한 임의 파일 read 차단.
@@ -299,7 +342,9 @@ export function verifySolution(solutionName) {
                 return updateSolutionFile(filePath, { status: 'verified', confidence: 0.8 });
             }
         }
-        catch { /* 솔루션 파일 읽기/업데이트 실패 무시 — false 반환으로 재시도 가능 */ }
+        catch {
+            /* 솔루션 파일 읽기/업데이트 실패 무시 — false 반환으로 재시도 가능 */
+        }
     }
     return false;
 }

package/dist/engine/compound-loop.js

@@ -190,6 +190,11 @@ export async function handleCompound(args) {
     forgen compound --lifecycle      Run promotion/demotion/circuit-breaker check
     forgen compound --verify <name>  Manually promote solution to verified
 
+  Export/Import:
+    forgen compound export [--output path]
+                                     Export knowledge to tar.gz archive
+    forgen compound import <path>    Import knowledge from archive (skip existing)
+
   Auto-extraction:
     forgen compound --pause-auto     Pause auto-extraction
     forgen compound --resume-auto    Resume auto-extraction
@@ -199,6 +204,18 @@ export async function handleCompound(args) {
 `);
         return;
     }
+    // --- export command ---
+    if (args[0] === 'export') {
+        const { handleExport } = await import('./compound-export.js');
+        await handleExport(args.slice(1));
+        return;
+    }
+    // --- import command ---
+    if (args[0] === 'import') {
+        const { handleImport } = await import('./compound-export.js');
+        await handleImport(args.slice(1));
+        return;
+    }
     // --pause-auto / --resume-auto
     if (args.includes('--pause-auto') || args.includes('pause-auto')) {
         const { pauseExtraction } = await import('./compound-extractor.js');
@@ -375,6 +392,7 @@ export async function handleCompound(args) {
         '--lifecycle', '--verify', '--save', '--interactive',
         'list', 'inspect', 'remove', 'rollback', 'retag', 'lifecycle',
         '--list', '--inspect', '--remove', '--rollback', '--retag', '--since', 'interactive',
+        'export', 'import', '--output',
     ];
     const hasTypeFlag = knownFlags.some(f => args.includes(f));
     if (!hasTypeFlag) {