@wooojin/forgen 0.2.0 → 0.2.1

package/dist/core/drift-score.js

@@ -0,0 +1,87 @@
+/**
+ * Forgen — Drift Score (Session Drift Detection)
+ *
+ * 세션 내 수정 패턴을 추적하여 drift(산만/반복 수정)를 감지.
+ * EWMA(Exponentially Weighted Moving Average) 기반 이동평균으로
+ * 최근 수정 강도를 측정하고, 임계값 초과 시 경고.
+ *
+ * Codex 합의: DriftState + evaluateDrift 2개만. 최소 인터페이스.
+ */
+const DEFAULTS = {
+    alpha: 0.35,
+    warningEdits: 15,
+    criticalEdits: 30,
+    criticalReverts: 2,
+    hardCapEdits: 50,
+    warningCooldownMs: 5 * 60 * 1000,
+    criticalCooldownMs: 10 * 60 * 1000,
+};
+/** EWMA 업데이트 (순수 함수) */
+export function updateEwma(prev, sample, alpha) {
+    return alpha * sample + (1 - alpha) * prev;
+}
+/** 새 DriftState 생성 */
+export function createDriftState(sessionId) {
+    return {
+        sessionId,
+        totalEdits: 0,
+        totalReverts: 0,
+        ewmaEditRate: 0,
+        ewmaRevertRate: 0,
+        lastWarningAt: 0,
+        lastCriticalAt: 0,
+        hardCapReached: false,
+    };
+}
+/**
+ * 도구 호출 이벤트로 drift 상태를 갱신하고 평가 결과를 반환.
+ * @param state 현재 상태 (mutate됨)
+ * @param isEdit Write/Edit 도구 호출 여부
+ * @param isRevert revert 감지 여부
+ * @param thresholds 커스텀 임계치 (hook-config에서 로드)
+ */
+export function evaluateDrift(state, isEdit, isRevert, thresholds = {}) {
+    const t = { ...DEFAULTS, ...thresholds };
+    const now = Date.now();
+    // Update counters
+    if (isEdit)
+        state.totalEdits++;
+    if (isRevert)
+        state.totalReverts++;
+    // Update EWMA
+    state.ewmaEditRate = updateEwma(state.ewmaEditRate, isEdit ? 1 : 0, t.alpha);
+    state.ewmaRevertRate = updateEwma(state.ewmaRevertRate, isRevert ? 1 : 0, t.alpha);
+    // Calculate drift score: edit rate 65% + revert rate 35%
+    const rawScore = (state.ewmaEditRate * 65) + (state.ewmaRevertRate * 35);
+    const score = Math.min(100, Math.max(0, Math.round(rawScore)));
+    // Hard cap
+    if (state.totalEdits >= t.hardCapEdits) {
+        state.hardCapReached = true;
+        return {
+            level: 'hardcap',
+            score: 100,
+            message: `[Forgen] ⛔ Session drift hard cap reached (${state.totalEdits} edits). Stop and reassess the approach before continuing.`,
+        };
+    }
+    // Critical: 2+ reverts OR 30+ edits OR score >= 78
+    if ((state.totalReverts >= t.criticalReverts || state.totalEdits >= t.criticalEdits || score >= 78) &&
+        (now - state.lastCriticalAt > t.criticalCooldownMs)) {
+        state.lastCriticalAt = now;
+        return {
+            level: 'critical',
+            score,
+            message: `[Forgen] ⚠ High drift detected (score: ${score}, edits: ${state.totalEdits}, reverts: ${state.totalReverts}). Consider stopping to redesign the approach.`,
+        };
+    }
+    // Warning: 15+ edits OR score >= 52
+    if ((state.totalEdits >= t.warningEdits || score >= 52) &&
+        (now - state.lastWarningAt > t.warningCooldownMs)) {
+        state.lastWarningAt = now;
+        return {
+            level: 'warning',
+            score,
+            message: `[Forgen] Drift building up (score: ${score}, edits: ${state.totalEdits}). Review your approach if changes feel repetitive.`,
+        };
+    }
+    return { level: 'normal', score, message: null };
+}

package/dist/core/mcp-config.d.ts

@@ -11,6 +11,8 @@ export interface McpServerConfig {
     command: string;
     args: string[];
     env?: Record<string, string>;
+    /** HTTP/SSE transport URL (alternative to command+args) */
+    url?: string;
 }
 /**
  * 기본 MCP 서버 템플릿 목록 반환

package/dist/core/mcp-config.js

@@ -101,7 +101,12 @@ export async function handleMcp(args) {
             for (const name of names) {
                 const cfg = installed[name];
                 console.log(`    ${name}`);
-                console.log(`      command: ${cfg.command} ${cfg.args.join(' ')}`);
+                if (cfg.command) {
+                    console.log(`      command: ${cfg.command} ${(cfg.args ?? []).join(' ')}`);
+                }
+                else if (cfg.url) {
+                    console.log(`      url: ${cfg.url}`);
+                }
                 if (cfg.env && Object.keys(cfg.env).length > 0) {
                     console.log(`      env: ${JSON.stringify(cfg.env)}`);
                 }

package/dist/core/paths.d.ts

@@ -74,7 +74,7 @@ export declare const V1_RAW_LOGS_DIR: string;
 /** @deprecated use GLOBAL_CONFIG */
 export declare const V1_GLOBAL_CONFIG: string;
 /** 모든 실행 모드 이름 (cancel/recovery 시 사용) */
-export declare const ALL_MODES: readonly ["ralph", "autopilot", "ultrawork", "team", "pipeline", "ccg", "ralplan", "deep-interview", "ecomode"];
+export declare const ALL_MODES: readonly ["ralph", "autopilot", "ultrawork", "team", "pipeline", "ccg", "ralplan", "deep-interview", "ecomode", "specify"];
 /** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
 export declare function projectDir(cwd: string): string;
 /** {repo}/.compound/pack.link — 팀 팩 연결 파일 */

package/dist/core/paths.js

@@ -81,7 +81,7 @@ export const V1_GLOBAL_CONFIG = GLOBAL_CONFIG;
 /** 모든 실행 모드 이름 (cancel/recovery 시 사용) */
 export const ALL_MODES = [
     'ralph', 'autopilot', 'ultrawork', 'team', 'pipeline',
-    'ccg', 'ralplan', 'deep-interview', 'ecomode',
+    'ccg', 'ralplan', 'deep-interview', 'ecomode', 'specify',
 ];
 /** {repo}/.compound/ — 프로젝트 로컬 디렉토리 */
 export function projectDir(cwd) {

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-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) {

package/dist/engine/solution-matcher.d.ts

@@ -6,6 +6,27 @@ import type { SolutionStatus, SolutionType } from './solution-format.js';
  * `synonym-tfidf.test.ts` and any external consumers.
  */
 export declare function expandTagsWithSynonyms(tags: string[]): string[];
+/**
+ * Compute the Dice coefficient between two strings using character bigrams.
+ *
+ * Dice = 2 * |intersection| / (|A| + |B|)
+ *
+ * Both strings are lowercased and whitespace-stripped before bigram generation.
+ * Returns 0 for empty strings or single-character strings (no bigrams possible).
+ * Returns 1.0 for identical non-trivial strings.
+ *
+ * This is used as a lightweight fuzzy matching signal for borderline cases
+ * where the TF-IDF tag intersection produces a low score but the query and
+ * solution tags are character-similar (e.g., "database" vs "데이터베이스"
+ * won't match, but "database" vs "databse" will get a high score).
+ */
+export declare function bigramSimilarity(a: string, b: string): number;
+/**
+ * Simplified BM25 score for a single query-document pair.
+ * Uses tag overlap with term frequency normalization.
+ * k1=1.2, b=0.75 (standard BM25 parameters).
+ */
+export declare function bm25Score(queryTags: string[], docTags: string[], avgDocLength: number): number;
 /** Apply IDF-like weight: common tags get reduced weight */
 export declare function tagWeight(tag: string): number;
 export interface SolutionMatch {
@@ -42,6 +63,8 @@ export interface CalculateRelevanceOptions {
      * pair — `solutionTagsExpanded` MUST be a superset of `solutionTags`.
      */
     solutionTagsExpanded?: string[];
+    /** Average document (solution) tag count for BM25 normalization. Defaults to 6. */
+    avgDocLength?: number;
 }
 export declare function calculateRelevance(promptTags: string[], solutionTags: string[], confidence: number, options?: CalculateRelevanceOptions): {
     relevance: number;

package/dist/engine/solution-matcher.js

@@ -31,6 +31,73 @@ export function expandTagsWithSynonyms(tags) {
     return defaultNormalizer.normalizeTerms(tags);
 }
 // ── TF-IDF weighting for common tags ──
+// ── Character bigram similarity (Dice coefficient) ──
+/**
+ * Compute the Dice coefficient between two strings using character bigrams.
+ *
+ * Dice = 2 * |intersection| / (|A| + |B|)
+ *
+ * Both strings are lowercased and whitespace-stripped before bigram generation.
+ * Returns 0 for empty strings or single-character strings (no bigrams possible).
+ * Returns 1.0 for identical non-trivial strings.
+ *
+ * This is used as a lightweight fuzzy matching signal for borderline cases
+ * where the TF-IDF tag intersection produces a low score but the query and
+ * solution tags are character-similar (e.g., "database" vs "데이터베이스"
+ * won't match, but "database" vs "databse" will get a high score).
+ */
+export function bigramSimilarity(a, b) {
+    const na = a.toLowerCase().replace(/\s+/g, '');
+    const nb = b.toLowerCase().replace(/\s+/g, '');
+    if (na.length < 2 || nb.length < 2)
+        return 0;
+    if (na === nb)
+        return 1.0;
+    const bigramsA = new Map();
+    for (let i = 0; i < na.length - 1; i++) {
+        const bg = na.slice(i, i + 2);
+        bigramsA.set(bg, (bigramsA.get(bg) ?? 0) + 1);
+    }
+    const bigramsB = new Map();
+    for (let i = 0; i < nb.length - 1; i++) {
+        const bg = nb.slice(i, i + 2);
+        bigramsB.set(bg, (bigramsB.get(bg) ?? 0) + 1);
+    }
+    let intersectionSize = 0;
+    for (const [bg, countA] of bigramsA) {
+        const countB = bigramsB.get(bg) ?? 0;
+        intersectionSize += Math.min(countA, countB);
+    }
+    const totalA = na.length - 1;
+    const totalB = nb.length - 1;
+    return (2 * intersectionSize) / (totalA + totalB);
+}
+// ── BM25-like scoring ──
+/**
+ * Simplified BM25 score for a single query-document pair.
+ * Uses tag overlap with term frequency normalization.
+ * k1=1.2, b=0.75 (standard BM25 parameters).
+ */
+export function bm25Score(queryTags, docTags, avgDocLength) {
+    const k1 = 1.2;
+    const b = 0.75;
+    const docLen = docTags.length;
+    if (docLen === 0 || queryTags.length === 0 || avgDocLength === 0)
+        return 0;
+    let score = 0;
+    for (const qt of queryTags) {
+        // Term frequency in document
+        const tf = docTags.filter(dt => dt === qt || (dt.length > 3 && qt.length > 3 && (dt.includes(qt) || qt.includes(dt)))).length;
+        if (tf === 0)
+            continue;
+        // BM25 TF saturation
+        const numerator = tf * (k1 + 1);
+        const denominator = tf + k1 * (1 - b + b * (docLen / avgDocLength));
+        score += numerator / denominator;
+    }
+    // Normalize by query length
+    return score / queryTags.length;
+}
 /** High-frequency tags that should be weighted lower */
 const COMMON_TAGS = new Set([
     'typescript', 'ts', 'javascript', 'js', 'fix', 'update', 'add', 'change',
@@ -72,20 +139,66 @@ export function calculateRelevance(promptOrTags, keywordsOrTags, confidence, opt
     // Apply TF-IDF weighting: common tags count less
     const weightedMatched = intersection.reduce((sum, t) => sum + tagWeight(t), 0)
         + partialMatches.reduce((sum, t) => sum + tagWeight(t) * 0.5, 0);
-    // 완화된 임계값: 가중 점수 0.5 이상이면 후보
-    if (weightedMatched < 0.5)
+    // ── Bigram similarity boost for borderline cases ──
+    //
+    // When the TF-IDF intersection score is below the match threshold (0.5),
+    // compute a character-bigram Dice coefficient between the query tags and
+    // the solution tags. If the best bigram similarity is high enough, blend
+    // it in at 20% weight (TF-IDF 80%, bigram 20%) to rescue fuzzy matches
+    // that the exact/substring intersection missed (e.g., typos, slight
+    // morphological variants).
+    //
+    // When TF-IDF score is already above threshold, the bigram boost is NOT
+    // applied — this preserves existing match quality and avoids disturbing
+    // already-good rankings. The bigram path is purely a rescue mechanism
+    // for borderline cases.
+    if (weightedMatched < 0.5) {
+        // Compute best bigram similarity across all (promptTag, solutionTag) pairs
+        let bestBigramScore = 0;
+        const bigramMatchedTags = [];
+        for (const st of matchTags) {
+            for (const pt of expandedPromptTags) {
+                const sim = bigramSimilarity(pt, st);
+                if (sim > bestBigramScore) {
+                    bestBigramScore = sim;
+                }
+                // Track solution tags with meaningful bigram similarity (> 0.4)
+                if (sim > 0.4 && !bigramMatchedTags.includes(st)) {
+                    bigramMatchedTags.push(st);
+                }
+            }
+        }
+        // Only rescue if the bigram signal is strong enough (> 0.4 threshold)
+        // to avoid noise from weakly similar strings
+        if (bestBigramScore > 0.4) {
+            const union = new Set([...promptOrTags, ...keywordsOrTags]).size;
+            const tfidfScore = weightedMatched / Math.max(union, 1);
+            const blendedScore = tfidfScore * 0.8 + bestBigramScore * 0.2;
+            return {
+                relevance: blendedScore * (confidence ?? 1),
+                matchedTags: [...intersection, ...partialMatches, ...bigramMatchedTags.filter(t => !intersection.includes(t) && !partialMatches.includes(t))],
+            };
+        }
         return { relevance: 0, matchedTags: [] };
-    // Jaccard-like: weighted matched / union.
-    // Union uses RAW promptTags and RAW solutionTags — not the expanded set —
-    // so that the denominator semantics are unchanged from pre-T2 behaviour.
-    // This is intentional: expanding both sides of the Jaccard would
-    // asymmetrically inflate recall and silently shift all baseline metrics.
-    // R4-T1 explicitly preserves this: `keywordsOrTags` is the raw solution
-    // tag list, not the compound-expanded `matchTags` used above.
+    }
+    // Ensemble: TF-IDF (Jaccard) 0.5 + BM25 0.3 + bigram 0.2
     const union = new Set([...promptOrTags, ...keywordsOrTags]).size;
-    const tagScore = weightedMatched / Math.max(union, 1);
+    const tfidfScore = weightedMatched / Math.max(union, 1);
+    // BM25 component: average doc length defaults to 6 tags (typical solution)
+    const avgDocLen = options?.avgDocLength ?? 6;
+    const bm25 = bm25Score(promptOrTags, keywordsOrTags, avgDocLen);
+    // Bigram component (mild boost for partial string matches)
+    let bigramBoost = 0;
+    for (const st of matchTags) {
+        for (const pt of expandedPromptTags) {
+            const sim = bigramSimilarity(pt, st);
+            if (sim > bigramBoost)
+                bigramBoost = sim;
+        }
+    }
+    const ensembleScore = tfidfScore * 0.5 + bm25 * 0.3 + bigramBoost * 0.2;
     return {
-        relevance: tagScore * (confidence ?? 1),
+        relevance: ensembleScore * (confidence ?? 1),
         matchedTags: [...intersection, ...partialMatches],
     };
 }

package/dist/hooks/context-guard.d.ts

@@ -19,6 +19,16 @@ export declare function shouldWarn(contextPercent: {
     charsThreshold?: number;
     cooldownMs?: number;
 }): boolean;
+/** auto-compact 트리거 여부 판정 (순수 함수) */
+export declare function shouldAutoCompact(state: {
+    totalChars: number;
+    lastAutoCompactAt: number;
+}, thresholds?: {
+    charsThreshold?: number;
+    cooldownMs?: number;
+}): boolean;
+/** auto-compact 지시 메시지 생성 (순수 함수) */
+export declare function buildAutoCompactMessage(totalChars: number): string;
 /** 경고 메시지 생성 (순수 함수) */
 export declare function buildContextWarningMessage(promptCount: number, totalChars: number): string;
 export declare function main(): Promise<void>;