@wooojin/forgen 0.2.1 → 0.3.1

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/learn-cli.d.ts

@@ -0,0 +1 @@
+export declare function handleLearn(args: string[]): Promise<void>;

package/dist/engine/learn-cli.js

@@ -0,0 +1,182 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { fixupSolutions } from './solution-fixup.js';
+import { listQuarantined, pruneQuarantine } from './solution-quarantine.js';
+import { computeFitness } from './solution-fitness.js';
+import { buildWeaknessReport, saveWeaknessReport } from './solution-weakness.js';
+import { listCandidates, promoteCandidate, rollbackSince } from './solution-candidate.js';
+const ME_SOLUTIONS = path.join(os.homedir(), '.forgen', 'me', 'solutions');
+export async function handleLearn(args) {
+    const sub = args[0];
+    if (sub === 'fix-up')
+        return runFixUp(args.slice(1));
+    if (sub === 'quarantine')
+        return runQuarantine(args.slice(1));
+    if (sub === 'fitness')
+        return runFitness(args.slice(1));
+    if (sub === 'evolve')
+        return runEvolve(args.slice(1));
+    printUsage();
+}
+function printUsage() {
+    console.log(`
+  forgen learn — solution index maintenance and fitness
+
+  Usage:
+    forgen learn fix-up [--apply]         Repair malformed solution frontmatter (dry-run by default)
+    forgen learn quarantine [--prune]     Show files dropped by the index; --prune removes fixed/deleted
+    forgen learn fitness [--json]         Show per-solution fitness (accept/correct/error ratios)
+    forgen learn evolve [--save|--rollback <ts>|--promote <name>]
+                                          Phase 4 evolution: weakness report + candidate lifecycle
+`);
+}
+function runFixUp(args) {
+    const apply = args.includes('--apply');
+    const result = fixupSolutions(ME_SOLUTIONS, { dryRun: !apply });
+    console.log(`\n  ${apply ? 'Applied' : 'Dry-run'}: scanned=${result.scanned} fixed=${result.fixed} untouched=${result.untouched} unfixable=${result.unfixable}`);
+    for (const rep of result.reports) {
+        const rel = path.basename(rep.path);
+        if (rep.changed && rep.remaining_errors.length === 0) {
+            console.log(`    ✓ ${rel} — add: ${rep.added.join(', ')}`);
+        }
+        else {
+            console.log(`    ✗ ${rel} — remaining: ${rep.remaining_errors.join('; ')}`);
+        }
+    }
+    if (!apply && result.fixed > 0) {
+        console.log(`\n  Re-run with --apply to write changes.\n`);
+    }
+    else if (apply && result.fixed > 0) {
+        console.log(`\n  Consider: forgen learn quarantine --prune\n`);
+    }
+    else {
+        console.log('');
+    }
+}
+function runQuarantine(args) {
+    if (args.includes('--prune')) {
+        const result = pruneQuarantine();
+        console.log(`\n  Pruned: removed=${result.removed} kept=${result.kept}\n`);
+        return;
+    }
+    const entries = listQuarantined();
+    if (entries.length === 0) {
+        console.log(`\n  No quarantined solutions. ✓\n`);
+        return;
+    }
+    console.log(`\n  Quarantined solutions (${entries.length}):\n`);
+    for (const e of entries) {
+        const rel = path.basename(e.path);
+        console.log(`    ${rel} (${e.at})`);
+        for (const err of e.errors)
+            console.log(`      - ${err}`);
+    }
+    console.log(`\n  Fix: forgen learn fix-up --apply  → then: forgen learn quarantine --prune\n`);
+}
+function runFitness(args) {
+    const records = computeFitness();
+    if (args.includes('--json')) {
+        console.log(JSON.stringify(records, null, 2));
+        return;
+    }
+    if (records.length === 0) {
+        console.log(`\n  No outcome events yet. Fitness becomes available after solution injections accumulate.\n`);
+        return;
+    }
+    console.log(`\n  Solution Fitness (${records.length} tracked):\n`);
+    console.log(`    ${'name'.padEnd(48)} ${'state'.padEnd(14)} ${'inj'.padStart(4)}  ${'acc/cor/err'.padStart(11)}  ${'fit'.padStart(6)}`);
+    console.log(`    ${'-'.repeat(48)} ${'-'.repeat(14)} ${'-'.repeat(4)}  ${'-'.repeat(11)}  ${'-'.repeat(6)}`);
+    for (const r of records) {
+        const name = r.solution.length > 47 ? r.solution.slice(0, 45) + '..' : r.solution;
+        const acr = `${r.accepted}/${r.corrected}/${r.errored}`;
+        console.log(`    ${name.padEnd(48)} ${r.state.padEnd(14)} ${String(r.injected).padStart(4)}  ${acr.padStart(11)}  ${r.fitness.toFixed(2).padStart(6)}`);
+    }
+    console.log('');
+}
+function runEvolve(args) {
+    const save = args.includes('--save');
+    const rollbackIdx = args.indexOf('--rollback');
+    const promoteIdx = args.indexOf('--promote');
+    if (rollbackIdx >= 0 && args[rollbackIdx + 1]) {
+        return runEvolveRollback(args[rollbackIdx + 1]);
+    }
+    if (promoteIdx >= 0 && args[promoteIdx + 1]) {
+        return runEvolvePromote(args[promoteIdx + 1]);
+    }
+    // Default: generate + optionally save weakness report, print proposer
+    // brief so the user can hand it to the ch-solution-evolver agent.
+    const report = buildWeaknessReport();
+    console.log(`\n  Weakness Report @ ${report.generated_at}\n`);
+    console.log(`  Population: ${report.population.total} solutions`);
+    console.log(`    champion=${report.population.champion}  active=${report.population.active}  underperform=${report.population.underperform}  draft=${report.population.draft}\n`);
+    renderTagRow('Under-served tags', report.under_served_tags.map((t) => `${t.tag} (×${t.correction_mentions})`));
+    renderTagRow('Conflict clusters', report.conflict_clusters.map((c) => `${c.shared_tags.slice(0, 2).join('+')}: ${c.champion.name} vs ${c.underperform.name}`));
+    renderTagRow('Dead corners', report.dead_corners.map((d) => `${d.solution}: [${d.unique_tags.slice(0, 2).join(',')}]`));
+    renderTagRow('Volatile', report.volatile.map((v) => `${v.solution} Δ${v.delta}`));
+    if (save) {
+        const p = saveWeaknessReport(report);
+        console.log(`\n  Saved: ${p}`);
+        console.log(`  Next: invoke the ch-solution-evolver agent with this report, then run:`);
+        console.log(`    forgen learn evolve --promote <candidate-name>   # accept one of the 3 proposals`);
+        console.log(`    forgen learn evolve --rollback ${Date.now()}      # undo this week's candidates`);
+        console.log('');
+    }
+    else {
+        console.log(`\n  Dry-run. Re-run with --save to persist this report and proceed to proposer.\n`);
+    }
+}
+function renderTagRow(label, items) {
+    if (items.length === 0) {
+        console.log(`  ${label}: (none)`);
+        return;
+    }
+    console.log(`  ${label}:`);
+    for (const item of items.slice(0, 5))
+        console.log(`    - ${item}`);
+}
+function runEvolveRollback(ts) {
+    const epochMs = /^\d+$/.test(ts) ? Number(ts) : Date.parse(ts);
+    if (!Number.isFinite(epochMs)) {
+        console.log(`\n  Invalid timestamp: ${ts}. Use epoch ms or ISO-8601.\n`);
+        return;
+    }
+    const result = rollbackSince(epochMs);
+    console.log(`\n  Rollback since ${new Date(epochMs).toISOString()}:`);
+    if (result.archived.length === 0) {
+        console.log(`    (no evolved solutions newer than cutoff)\n`);
+        return;
+    }
+    console.log(`    Archived ${result.archived.length} file(s) → ${result.archive_dir}`);
+    for (const p of result.archived)
+        console.log(`      - ${path.basename(p)}`);
+    if (result.errors.length > 0) {
+        console.log(`    Errors:`);
+        for (const e of result.errors)
+            console.log(`      ! ${e}`);
+    }
+    console.log('');
+}
+function runEvolvePromote(candidateNameOrList) {
+    if (candidateNameOrList === '--list' || candidateNameOrList === 'list') {
+        const found = listCandidates();
+        if (found.length === 0) {
+            console.log(`\n  No pending candidates in ~/.forgen/lab/candidates/\n`);
+            return;
+        }
+        console.log(`\n  Pending candidates (${found.length}):`);
+        for (const p of found)
+            console.log(`    - ${path.basename(p, '.md')}`);
+        console.log(`\n  Promote one: forgen learn evolve --promote <name>\n`);
+        return;
+    }
+    const result = promoteCandidate(candidateNameOrList);
+    if (result.ok) {
+        console.log(`\n  ✓ Promoted: ${path.basename(result.dest)}`);
+        console.log(`    from: ${result.source}`);
+        console.log(`    to:   ${result.dest}`);
+        console.log(`    Cold-start bonus active until 5 injections accumulate (auto-promotes to verified).\n`);
+    }
+    else {
+        console.log(`\n  ✗ Promotion refused: ${result.reason}\n`);
+    }
+}

package/dist/engine/meta-learning/adaptive-thresholds.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Forgen Meta-Learning — Adaptive Thresholds (Feature 4)
+ *
+ * Computes learning velocity and adapts promotion thresholds
+ * based on the user's solution accumulation rate.
+ *
+ * Learning velocity = solutions created in last 30 days / 4.3 weeks
+ *
+ *   > 3/week (high volume)  → thresholds +1 (more evidence needed)
+ *   0.5~3/week (normal)     → no change
+ *   < 0.5/week (slow pace)  → thresholds -1 (lower the bar)
+ *
+ * Guardrails: [thresholdFloor, thresholdCeiling], max ±1 per cycle.
+ */
+import type { AdaptiveLifecycleThresholds, MetaLearningConfig } from './types.js';
+/**
+ * Compute adaptive promotion thresholds based on learning velocity.
+ * Returns null if cold-start conditions are not met.
+ */
+export declare function computeAdaptiveThresholds(config: MetaLearningConfig): AdaptiveLifecycleThresholds | null;

package/dist/engine/meta-learning/adaptive-thresholds.js

@@ -0,0 +1,126 @@
+/**
+ * Forgen Meta-Learning — Adaptive Thresholds (Feature 4)
+ *
+ * Computes learning velocity and adapts promotion thresholds
+ * based on the user's solution accumulation rate.
+ *
+ * Learning velocity = solutions created in last 30 days / 4.3 weeks
+ *
+ *   > 3/week (high volume)  → thresholds +1 (more evidence needed)
+ *   0.5~3/week (normal)     → no change
+ *   < 0.5/week (slow pace)  → thresholds -1 (lower the bar)
+ *
+ * Guardrails: [thresholdFloor, thresholdCeiling], max ±1 per cycle.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { ME_SOLUTIONS, META_LEARNING_DIR } from '../../core/paths.js';
+import { atomicWriteJSON, safeReadJSON } from '../../hooks/shared/atomic-write.js';
+import { parseFrontmatterOnly } from '../solution-format.js';
+import { DEFAULT_PROMOTION_THRESHOLDS } from './types.js';
+const THRESHOLDS_PATH = path.join(META_LEARNING_DIR, 'lifecycle-thresholds.json');
+const VELOCITY_WINDOW_DAYS = 30;
+const WEEKS_IN_WINDOW = VELOCITY_WINDOW_DAYS / 7;
+function loadCurrentThresholds() {
+    return safeReadJSON(THRESHOLDS_PATH, null);
+}
+function saveThresholds(t) {
+    atomicWriteJSON(THRESHOLDS_PATH, t, { pretty: true });
+}
+function clampThreshold(value, floor, ceiling) {
+    return Math.max(floor, Math.min(ceiling, Math.round(value)));
+}
+function computeLearningVelocity() {
+    try {
+        if (!fs.existsSync(ME_SOLUTIONS))
+            return { velocity: 0, totalSolutions: 0 };
+        const files = fs.readdirSync(ME_SOLUTIONS).filter((f) => f.endsWith('.md'));
+        const now = Date.now();
+        const windowMs = VELOCITY_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+        let recentCount = 0;
+        let totalSolutions = 0;
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(ME_SOLUTIONS, file), 'utf-8');
+                const fm = parseFrontmatterOnly(content);
+                if (!fm || fm.status === 'retired')
+                    continue;
+                totalSolutions++;
+                const created = fm.created ? new Date(fm.created).getTime() : 0;
+                if (created > 0 && now - created <= windowMs) {
+                    recentCount++;
+                }
+            }
+            catch { }
+        }
+        return {
+            velocity: recentCount / WEEKS_IN_WINDOW,
+            totalSolutions,
+        };
+    }
+    catch {
+        return { velocity: 0, totalSolutions: 0 };
+    }
+}
+/**
+ * Compute adaptive promotion thresholds based on learning velocity.
+ * Returns null if cold-start conditions are not met.
+ */
+export function computeAdaptiveThresholds(config) {
+    const { velocity, totalSolutions } = computeLearningVelocity();
+    // Cold-start check
+    if (totalSolutions < config.coldStart.minSolutionsForThresholds) {
+        return null;
+    }
+    const current = loadCurrentThresholds();
+    const base = current ?? {
+        experiment: { ...DEFAULT_PROMOTION_THRESHOLDS.experiment },
+        candidate: { ...DEFAULT_PROMOTION_THRESHOLDS.candidate },
+        verified: { ...DEFAULT_PROMOTION_THRESHOLDS.verified },
+        learningVelocity: velocity,
+        updatedAt: new Date().toISOString(),
+        sampleSize: totalSolutions,
+        defaults: { ...DEFAULT_PROMOTION_THRESHOLDS },
+    };
+    // Determine adjustment direction
+    const { maxThresholdDelta, thresholdFloor, thresholdCeiling } = config.guardrails;
+    let delta = 0;
+    if (velocity > 3) {
+        delta = maxThresholdDelta; // high volume → stricter
+    }
+    else if (velocity < 0.5) {
+        delta = -maxThresholdDelta; // slow pace → more lenient
+    }
+    if (delta === 0 && current) {
+        // No change needed, but update metadata
+        current.learningVelocity = velocity;
+        current.sampleSize = totalSolutions;
+        current.updatedAt = new Date().toISOString();
+        saveThresholds(current);
+        return current;
+    }
+    const result = {
+        experiment: {
+            reflected: clampThreshold(base.experiment.reflected + delta, thresholdFloor, thresholdCeiling),
+            sessions: clampThreshold(base.experiment.sessions + delta, thresholdFloor, thresholdCeiling),
+            reExtracted: clampThreshold(base.experiment.reExtracted + delta, thresholdFloor, thresholdCeiling),
+        },
+        candidate: {
+            reflected: clampThreshold(base.candidate.reflected + delta, thresholdFloor, thresholdCeiling),
+            sessions: clampThreshold(base.candidate.sessions + delta, thresholdFloor, thresholdCeiling),
+            reExtracted: clampThreshold(base.candidate.reExtracted + delta, thresholdFloor, thresholdCeiling),
+        },
+        verified: {
+            reflected: clampThreshold(base.verified.reflected + delta, thresholdFloor, thresholdCeiling),
+            sessions: clampThreshold(base.verified.sessions + delta, thresholdFloor, thresholdCeiling),
+            reExtracted: clampThreshold(base.verified.reExtracted + delta, thresholdFloor, thresholdCeiling),
+            negative: base.verified.negative, // negative threshold does not adapt
+        },
+        learningVelocity: velocity,
+        updatedAt: new Date().toISOString(),
+        sampleSize: totalSolutions,
+        defaults: { ...DEFAULT_PROMOTION_THRESHOLDS },
+    };
+    saveThresholds(result);
+    return result;
+}

package/dist/engine/meta-learning/extraction-tuner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Forgen Meta-Learning — Extraction Tuner (Feature 5)
+ *
+ * Tracks which solution types (pattern, solution, decision, etc.) have the
+ * best reflected/injected ratio and biases future extraction toward those types.
+ *
+ * Uses Laplace smoothing (pseudo-count +1) to prevent zero weights
+ * for underrepresented types.
+ */
+import type { ExtractionBias, MetaLearningConfig } from './types.js';
+/**
+ * Compute extraction bias based on type effectiveness.
+ * Returns null if cold-start conditions are not met.
+ */
+export declare function computeExtractionBias(config: MetaLearningConfig): ExtractionBias | null;