@wooojin/forgen 0.2.1 → 0.3.0

package/dist/engine/solution-format.js

@@ -1,9 +1,26 @@
 import yaml from 'js-yaml';
 export const DEFAULT_EVIDENCE = {
-    injected: 0, reflected: 0, negative: 0, sessions: 0, reExtracted: 0,
+    injected: 0,
+    reflected: 0,
+    negative: 0,
+    sessions: 0,
+    reExtracted: 0,
 };
-const VALID_STATUSES = ['experiment', 'candidate', 'verified', 'mature', 'retired'];
-const VALID_TYPES = ['pattern', 'solution', 'decision', 'troubleshoot', 'anti-pattern', 'convention'];
+const VALID_STATUSES = [
+    'experiment',
+    'candidate',
+    'verified',
+    'mature',
+    'retired',
+];
+const VALID_TYPES = [
+    'pattern',
+    'solution',
+    'decision',
+    'troubleshoot',
+    'anti-pattern',
+    'convention',
+];
 // ── Helpers ──
 export function slugify(text) {
     const slug = text
@@ -31,7 +48,7 @@ export function validateFrontmatter(fm) {
         return false;
     if (typeof o.type !== 'string' || !VALID_TYPES.includes(o.type))
         return false;
-    if (o.scope !== 'me' && o.scope !== 'team' && o.scope !== 'project')
+    if (o.scope !== 'me' && o.scope !== 'team' && o.scope !== 'project' && o.scope !== 'universal')
         return false;
     if (!Array.isArray(o.tags) || !o.tags.every((t) => typeof t === 'string'))
         return false;
@@ -122,7 +139,11 @@ export function parseSolutionV3(content) {
 // ── Serialization ──
 /** Serialize a SolutionV3 to a markdown string with YAML frontmatter */
 export function serializeSolutionV3(solution) {
-    const yamlStr = yaml.dump(solution.frontmatter, { lineWidth: -1, quotingType: '"', schema: yaml.JSON_SCHEMA });
+    const yamlStr = yaml.dump(solution.frontmatter, {
+        lineWidth: -1,
+        quotingType: '"',
+        schema: yaml.JSON_SCHEMA,
+    });
     return `---\n${yamlStr}---\n\n## Context\n${solution.context}\n\n## Content\n${solution.content}\n`;
 }
 // ── Format Detection ──
@@ -149,34 +170,207 @@ export function isV1Format(content) {
 /** 한국어 불용어 — 태그로 의미 없는 일반 단어 */
 const KO_STOPWORDS = new Set([
     // 일반 불용어
-    '적용', '패턴', '모든', '같은', '발견', '다른', '사용', '경우', '위해',
-    '통해', '대한', '이후', '때문', '하는', '있는', '없는', '되는', '관련',
-    '해야', '하고', '있다', '없다', '한다', '이런', '그런', '저런', '매우',
-    '항상', '모두', '각각', '대해', '여러', '시작', '그것', '이것', '저것',
-    '아주', '정말', '너무', '많이', '자주', '가장', '먼저', '이미', '아직',
-    '그냥', '바로', '다시', '함께', '위한', '따라', '부분', '전체', '방법',
-    '내용', '결과', '문제', '시점', '설정', '작업', '확인', '수행', '처리',
-    '기본', '추가', '변경', '제거', '포함', '생성', '실행', '완료', '필요',
+    '적용',
+    '패턴',
+    '모든',
+    '같은',
+    '발견',
+    '다른',
+    '사용',
+    '경우',
+    '위해',
+    '통해',
+    '대한',
+    '이후',
+    '때문',
+    '하는',
+    '있는',
+    '없는',
+    '되는',
+    '관련',
+    '해야',
+    '하고',
+    '있다',
+    '없다',
+    '한다',
+    '이런',
+    '그런',
+    '저런',
+    '매우',
+    '항상',
+    '모두',
+    '각각',
+    '대해',
+    '여러',
+    '시작',
+    '그것',
+    '이것',
+    '저것',
+    '아주',
+    '정말',
+    '너무',
+    '많이',
+    '자주',
+    '가장',
+    '먼저',
+    '이미',
+    '아직',
+    '그냥',
+    '바로',
+    '다시',
+    '함께',
+    '위한',
+    '따라',
+    '부분',
+    '전체',
+    '방법',
+    '내용',
+    '결과',
+    '문제',
+    '시점',
+    '설정',
+    '작업',
+    '확인',
+    '수행',
+    '처리',
+    '기본',
+    '추가',
+    '변경',
+    '제거',
+    '포함',
+    '생성',
+    '실행',
+    '완료',
+    '필요',
     // 조사/어미/접속사 — Jaccard 분모 희석 방지
-    '에서', '으로', '에게', '에는', '에도', '까지', '부터', '보다', '처럼',
-    '만큼', '대로', '밖에', '뿐만', '이나', '이고', '이면', '이라', '인데',
-    '했는데', '됐는데', '있으면', '없으면', '하면', '되면', '하지', '되지',
-    '하며', '되며', '에서의', '으로의', '라는', '라고', '이라고', '때문에',
-    '아니라', '하지만', '그러나', '그래서', '따라서', '그리고', '그러면',
-    '만약', '비록', '하여', '않고', '않은', '않는', '해서', '해도', '해야',
+    '에서',
+    '으로',
+    '에게',
+    '에는',
+    '에도',
+    '까지',
+    '부터',
+    '보다',
+    '처럼',
+    '만큼',
+    '대로',
+    '밖에',
+    '뿐만',
+    '이나',
+    '이고',
+    '이면',
+    '이라',
+    '인데',
+    '했는데',
+    '됐는데',
+    '있으면',
+    '없으면',
+    '하면',
+    '되면',
+    '하지',
+    '되지',
+    '하며',
+    '되며',
+    '에서의',
+    '으로의',
+    '라는',
+    '라고',
+    '이라고',
+    '때문에',
+    '아니라',
+    '하지만',
+    '그러나',
+    '그래서',
+    '따라서',
+    '그리고',
+    '그러면',
+    '만약',
+    '비록',
+    '하여',
+    '않고',
+    '않은',
+    '않는',
+    '해서',
+    '해도',
+    '해야',
     // 일반 동사/형용사 어간 — 의미 없는 고빈도 단어
-    '가능', '상태', '이유', '방지', '의존', '의존성', '즉시', '원칙', '근거',
-    '수정', '제안', '기능', '구현', '구조', '단계', '목적', '상황', '조건',
-    '규칙', '동작', '활성', '비활성', '원래', '현재', '이전', '다음', '최종',
+    '가능',
+    '상태',
+    '이유',
+    '방지',
+    '의존',
+    '의존성',
+    '즉시',
+    '원칙',
+    '근거',
+    '수정',
+    '제안',
+    '기능',
+    '구현',
+    '구조',
+    '단계',
+    '목적',
+    '상황',
+    '조건',
+    '규칙',
+    '동작',
+    '활성',
+    '비활성',
+    '원래',
+    '현재',
+    '이전',
+    '다음',
+    '최종',
 ]);
 /** 영어 불용어 */
 const EN_STOPWORDS = new Set([
-    'the', 'and', 'for', 'that', 'this', 'with', 'from', 'are', 'was',
-    'were', 'been', 'have', 'has', 'had', 'not', 'but', 'all', 'can',
-    'will', 'use', 'used', 'using', 'when', 'each', 'which', 'their',
-    'also', 'into', 'more', 'some', 'than', 'other', 'should', 'would',
-    'could', 'about', 'after', 'before', 'between', 'does', 'only',
-    'across', 'just', 'detected', 'based', 'sessions', 'prompts',
+    'the',
+    'and',
+    'for',
+    'that',
+    'this',
+    'with',
+    'from',
+    'are',
+    'was',
+    'were',
+    'been',
+    'have',
+    'has',
+    'had',
+    'not',
+    'but',
+    'all',
+    'can',
+    'will',
+    'use',
+    'used',
+    'using',
+    'when',
+    'each',
+    'which',
+    'their',
+    'also',
+    'into',
+    'more',
+    'some',
+    'than',
+    'other',
+    'should',
+    'would',
+    'could',
+    'about',
+    'after',
+    'before',
+    'between',
+    'does',
+    'only',
+    'across',
+    'just',
+    'detected',
+    'based',
+    'sessions',
+    'prompts',
 ]);
 /** 한국어 일반 조사/어미 — strip 대상 (긴 것부터 매칭)
  *
@@ -189,9 +383,32 @@ const EN_STOPWORDS = new Set([
  * term-matcher의 `KO_VERBAL_SUFFIXES`에 따로 둔다.
  */
 export const KO_SUFFIXES = [
-    '했습니다', '있습니다', '합니다', '입니다', '됩니다',
-    '에서', '까지', '으로', '하는', '하고', '했다', '된다', '한다',
-    '을', '를', '이', '가', '은', '는', '의', '에', '와', '과', '도', '만', '로',
+    '했습니다',
+    '있습니다',
+    '합니다',
+    '입니다',
+    '됩니다',
+    '에서',
+    '까지',
+    '으로',
+    '하는',
+    '하고',
+    '했다',
+    '된다',
+    '한다',
+    '을',
+    '를',
+    '이',
+    '가',
+    '은',
+    '는',
+    '의',
+    '에',
+    '와',
+    '과',
+    '도',
+    '만',
+    '로',
 ];
 export function stripKoSuffix(word) {
     for (const suffix of KO_SUFFIXES) {
@@ -220,9 +437,7 @@ const MAX_TAGS = 8;
  * a fresh `ROUND3_BASELINE` measurement on every downstream PR.
  */
 export function extractTags(text) {
-    const cleaned = text
-        .toLowerCase()
-        .replace(/[^가-힣a-z0-9\s]/g, ' ');
+    const cleaned = text.toLowerCase().replace(/[^가-힣a-z0-9\s]/g, ' ');
     const words = cleaned.split(/\s+/).filter(Boolean);
     const freq = new Map();
     for (const w of words) {

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

@@ -1,7 +1,7 @@
 import type { SolutionIndexEntry } from './solution-format.js';
 export interface SolutionDirConfig {
     dir: string;
-    scope: 'me' | 'team' | 'project';
+    scope: 'me' | 'team' | 'project' | 'universal';
 }
 export interface SolutionIndex {
     entries: SolutionIndexEntry[];

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

@@ -32,7 +32,7 @@ export declare function tagWeight(tag: string): number;
 export interface SolutionMatch {
     name: string;
     path: string;
-    scope: 'me' | 'team' | 'project';
+    scope: 'me' | 'team' | 'project' | 'universal';
     relevance: number;
     summary: string;
     status: SolutionStatus;
@@ -65,6 +65,12 @@ export interface CalculateRelevanceOptions {
     solutionTagsExpanded?: string[];
     /** Average document (solution) tag count for BM25 normalization. Defaults to 6. */
     avgDocLength?: number;
+    /** Meta-learning: dynamic ensemble weights (sum must equal 1.0). Defaults to {tfidf:0.5, bm25:0.3, bigram:0.2}. */
+    ensembleWeights?: {
+        tfidf: number;
+        bm25: number;
+        bigram: number;
+    };
 }
 export declare function calculateRelevance(promptTags: string[], solutionTags: string[], confidence: number, options?: CalculateRelevanceOptions): {
     relevance: number;

package/dist/engine/solution-matcher.js

@@ -1,9 +1,10 @@
+import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { ME_SOLUTIONS, PACKS_DIR } from '../core/paths.js';
-import { extractTags, expandCompoundTags, expandQueryBigrams } from './solution-format.js';
+import { ME_SOLUTIONS, META_LEARNING_DIR, PACKS_DIR } from '../core/paths.js';
+import { maskBlockedTokens } from './phrase-blocklist.js';
+import { expandCompoundTags, expandQueryBigrams, extractTags } from './solution-format.js';
 import { getOrBuildIndex } from './solution-index.js';
 import { defaultNormalizer } from './term-normalizer.js';
-import { maskBlockedTokens } from './phrase-blocklist.js';
 // ── Synonym expansion (delegates to term-normalizer) ──
 //
 // The old `SYNONYM_MAP` + `expandTagsWithSynonyms` pair had two problems:
@@ -87,7 +88,7 @@ export function bm25Score(queryTags, docTags, avgDocLength) {
     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;
+        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
@@ -100,10 +101,37 @@ export function bm25Score(queryTags, docTags, avgDocLength) {
 }
 /** High-frequency tags that should be weighted lower */
 const COMMON_TAGS = new Set([
-    'typescript', 'ts', 'javascript', 'js', 'fix', 'update', 'add', 'change',
-    'file', 'code', 'function', 'import', 'export', 'error', 'type', 'string',
-    'number', 'object', 'array', 'return', 'const', 'class', 'module',
-    '코드', '파일', '함수', '수정', '추가', '변경', '에러', '타입',
+    'typescript',
+    'ts',
+    'javascript',
+    'js',
+    'fix',
+    'update',
+    'add',
+    'change',
+    'file',
+    'code',
+    'function',
+    'import',
+    'export',
+    'error',
+    'type',
+    'string',
+    'number',
+    'object',
+    'array',
+    'return',
+    'const',
+    'class',
+    'module',
+    '코드',
+    '파일',
+    '함수',
+    '수정',
+    '추가',
+    '변경',
+    '에러',
+    '타입',
 ]);
 /** Apply IDF-like weight: common tags get reduced weight */
 export function tagWeight(tag) {
@@ -114,7 +142,7 @@ export function calculateRelevance(promptOrTags, keywordsOrTags, confidence, opt
         // Legacy mode: substring matching for backwards compatibility.
         // Not a hot path — only hit by the (old) solution-matcher.test.ts cases.
         const promptTags = extractTags(promptOrTags);
-        const intersection = keywordsOrTags.filter(kw => promptTags.some(pt => pt === kw || (pt.length > 3 && kw.length > 3 && (pt.startsWith(kw) || kw.startsWith(pt)))));
+        const intersection = keywordsOrTags.filter((kw) => promptTags.some((pt) => pt === kw || (pt.length > 3 && kw.length > 3 && (pt.startsWith(kw) || kw.startsWith(pt)))));
         return Math.min(1, intersection.length / Math.max(promptTags.length * 0.5, 1));
     }
     // v3 mode: tag matching with synonym expansion + TF-IDF weighting.
@@ -124,21 +152,21 @@ export function calculateRelevance(promptOrTags, keywordsOrTags, confidence, opt
     // the hot path pre-compute the expansion once per query and pass it via
     // `options.normalizedPromptTags`, so this function no longer repeats the
     // work per solution.
-    const expandedPromptTags = options?.normalizedPromptTags
-        ?? defaultNormalizer.normalizeTerms(promptOrTags);
+    const expandedPromptTags = options?.normalizedPromptTags ?? defaultNormalizer.normalizeTerms(promptOrTags);
     // R4-T1: when the caller supplies a compound-expanded solution tag set,
     // intersection and partial matching run against the expanded set (so
     // `api-key` matches `api`/`key` queries via the split parts), but the
     // Jaccard union denominator below still uses the RAW `keywordsOrTags`
     // for normalization stability.
     const matchTags = options?.solutionTagsExpanded ?? keywordsOrTags;
-    const intersection = matchTags.filter(t => expandedPromptTags.includes(t));
+    const intersection = matchTags.filter((t) => expandedPromptTags.includes(t));
     // partial/substring matches for longer tags (>3 chars)
-    const partialMatches = matchTags.filter(t => t.length > 3 && !intersection.includes(t)
-        && expandedPromptTags.some(pt => pt.length > 3 && (pt.includes(t) || t.includes(pt))));
+    const partialMatches = matchTags.filter((t) => t.length > 3 &&
+        !intersection.includes(t) &&
+        expandedPromptTags.some((pt) => pt.length > 3 && (pt.includes(t) || t.includes(pt))));
     // 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);
+    const weightedMatched = intersection.reduce((sum, t) => sum + tagWeight(t), 0) +
+        partialMatches.reduce((sum, t) => sum + tagWeight(t) * 0.5, 0);
     // ── Bigram similarity boost for borderline cases ──
     //
     // When the TF-IDF intersection score is below the match threshold (0.5),
@@ -176,7 +204,11 @@ export function calculateRelevance(promptOrTags, keywordsOrTags, confidence, opt
             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))],
+                matchedTags: [
+                    ...intersection,
+                    ...partialMatches,
+                    ...bigramMatchedTags.filter((t) => !intersection.includes(t) && !partialMatches.includes(t)),
+                ],
             };
         }
         return { relevance: 0, matchedTags: [] };
@@ -196,7 +228,8 @@ export function calculateRelevance(promptOrTags, keywordsOrTags, confidence, opt
                 bigramBoost = sim;
         }
     }
-    const ensembleScore = tfidfScore * 0.5 + bm25 * 0.3 + bigramBoost * 0.2;
+    const w = options?.ensembleWeights ?? { tfidf: 0.5, bm25: 0.3, bigram: 0.2 };
+    const ensembleScore = tfidfScore * w.tfidf + bm25 * w.bm25 + bigramBoost * w.bigram;
     return {
         relevance: ensembleScore * (confidence ?? 1),
         matchedTags: [...intersection, ...partialMatches],
@@ -274,8 +307,8 @@ export function shouldRejectByR4T3Rules(promptTags, matchedTags) {
     // Rule B
     if (matchedTags.length === 1) {
         const tag = matchedTags[0];
-        const literalHit = promptTags.includes(tag)
-            || promptTags.some(pt => {
+        const literalHit = promptTags.includes(tag) ||
+            promptTags.some((pt) => {
                 if (pt.length <= 3 || tag.length <= 3)
                     return false;
                 if (pt.includes(tag) || tag.includes(pt))
@@ -310,7 +343,7 @@ export function shouldRejectByR4T3Rules(promptTags, matchedTags) {
  *     `matchSolutions` behaviour (both scopes could rank). Callers that want
  *     first-wins scope precedence must dedupe on their side.
  */
-function rankCandidates(promptTags, promptLower, solutions) {
+function rankCandidates(promptTags, promptLower, solutions, ensembleWeights) {
     // T2: normalize prompt tags ONCE per query (not once per solution).
     // Pre-T2 this expansion happened inside calculateRelevance and was
     // repeated N times for N solutions — the plan's primary hot-path win.
@@ -345,7 +378,7 @@ function rankCandidates(promptTags, promptLower, solutions) {
     const promptTagsWithBigrams = expandQueryBigrams(maskedPromptTags);
     const normalizedPromptTags = defaultNormalizer.normalizeTerms(promptTagsWithBigrams);
     return solutions
-        .map(sol => {
+        .map((sol) => {
         // R4-T1: solution-side compound-tag expansion. `api-key` becomes
         // {api-key, api, key} so a query token `api` (from "api keys") hits
         // it directly. Computed per solution because each sol.tags is
@@ -358,7 +391,11 @@ function rankCandidates(promptTags, promptLower, solutions) {
         // step (intersection/partialMatches) already uses the masked set
         // via `normalizedPromptTags` — the union must match for score
         // semantics to stay consistent.
-        const result = calculateRelevance(maskedPromptTags, sol.tags, sol.confidence, { normalizedPromptTags, solutionTagsExpanded: solTagsExpanded });
+        const result = calculateRelevance(maskedPromptTags, sol.tags, sol.confidence, {
+            normalizedPromptTags,
+            solutionTagsExpanded: solTagsExpanded,
+            ensembleWeights,
+        });
         // Compute identifier boost FIRST — independent of tag scoring so
         // R4-T3's tag-evidence precision rules below cannot silently drop
         // a candidate that has strong identifier-level evidence.
@@ -385,9 +422,9 @@ function rankCandidates(promptTags, promptLower, solutions) {
         // the `matchedTags.length + matchedIdentifiers.length >= 1` filter.
         let tagRelevance = result.relevance;
         let tagMatches = result.matchedTags;
-        if (matchedIdentifiers.length === 0
-            && tagMatches.length > 0
-            && shouldRejectByR4T3Rules(maskedPromptTags, tagMatches)) {
+        if (matchedIdentifiers.length === 0 &&
+            tagMatches.length > 0 &&
+            shouldRejectByR4T3Rules(maskedPromptTags, tagMatches)) {
             tagRelevance = 0;
             tagMatches = [];
         }
@@ -398,7 +435,7 @@ function rankCandidates(promptTags, promptLower, solutions) {
             matchedIdentifiers,
         };
     })
-        .filter(c => c.matchedTags.length + c.matchedIdentifiers.length >= 1)
+        .filter((c) => c.matchedTags.length + c.matchedIdentifiers.length >= 1)
         .sort((a, b) => b.relevance - a.relevance)
         .slice(0, 5);
 }
@@ -675,7 +712,7 @@ function computeBucketMetrics(queries, solutions) {
  */
 export function evaluateQuery(query, solutions) {
     const promptTags = extractTags(query);
-    return rankCandidates(promptTags, query.toLowerCase(), solutions).map(c => ({
+    return rankCandidates(promptTags, query.toLowerCase(), solutions).map((c) => ({
         name: c.solution.name,
         relevance: c.relevance,
         matchedTags: c.matchedTags,
@@ -701,13 +738,16 @@ export function evaluateSolutionMatcher(fixture) {
     // doesn't drown a small paraphrase bucket but also a single-query bucket
     // doesn't dominate.
     const recallAt5 = combinedTotal > 0
-        ? (positiveM.recallAt5 * positiveM.total + paraphraseM.recallAt5 * paraphraseM.total) / combinedTotal
+        ? (positiveM.recallAt5 * positiveM.total + paraphraseM.recallAt5 * paraphraseM.total) /
+            combinedTotal
         : 0;
     const mrrAt5 = combinedTotal > 0
-        ? (positiveM.mrrAt5 * positiveM.total + paraphraseM.mrrAt5 * paraphraseM.total) / combinedTotal
+        ? (positiveM.mrrAt5 * positiveM.total + paraphraseM.mrrAt5 * paraphraseM.total) /
+            combinedTotal
         : 0;
     const noResultRate = combinedTotal > 0
-        ? (positiveM.noResultRate * positiveM.total + paraphraseM.noResultRate * paraphraseM.total) / combinedTotal
+        ? (positiveM.noResultRate * positiveM.total + paraphraseM.noResultRate * paraphraseM.total) /
+            combinedTotal
         : 0;
     let negAnyResult = 0;
     for (const q of fixture.negative) {
@@ -733,27 +773,64 @@ export function evaluateSolutionMatcher(fixture) {
         },
     };
 }
+// ── Meta-learning: dynamic ensemble weights ──
+let _cachedWeights;
+let _weightsCacheTime = 0;
+const WEIGHTS_CACHE_TTL = 60_000; // 1 minute cache
+/**
+ * Load tuned matcher weights from meta-learning state.
+ * Returns undefined (use defaults) if no tuned weights exist.
+ * Cached for 1 minute to avoid re-reading per matchSolutions call.
+ */
+function loadTunedMatcherWeights() {
+    const now = Date.now();
+    if (_cachedWeights !== undefined && now - _weightsCacheTime < WEIGHTS_CACHE_TTL) {
+        return _cachedWeights ?? undefined;
+    }
+    try {
+        const weightsPath = path.join(META_LEARNING_DIR, 'matcher-weights.json');
+        if (!fs.existsSync(weightsPath)) {
+            _cachedWeights = null;
+            _weightsCacheTime = now;
+            return undefined;
+        }
+        const data = JSON.parse(fs.readFileSync(weightsPath, 'utf-8'));
+        if (typeof data.tfidf === 'number' &&
+            typeof data.bm25 === 'number' &&
+            typeof data.bigram === 'number') {
+            _cachedWeights = { tfidf: data.tfidf, bm25: data.bm25, bigram: data.bigram };
+            _weightsCacheTime = now;
+            return _cachedWeights;
+        }
+    }
+    catch {
+        /* fail-open: use defaults */
+    }
+    _cachedWeights = null;
+    _weightsCacheTime = now;
+    return undefined;
+}
 export function matchSolutions(prompt, scope, cwd) {
     // Build solution dirs for index cache
-    const dirs = [
-        { dir: ME_SOLUTIONS, scope: 'me' },
-    ];
+    const dirs = [{ dir: ME_SOLUTIONS, scope: 'me' }];
     if (scope.team) {
         dirs.push({ dir: path.join(PACKS_DIR, scope.team.name, 'solutions'), scope: 'team' });
     }
     dirs.push({ dir: path.join(cwd, '.compound', 'solutions'), scope: 'project' });
     // Use cached index (rebuilt only when dirs change)
     const index = getOrBuildIndex(dirs);
-    const allSolutions = index.entries.map(e => ({ ...e }));
+    const allSolutions = index.entries.map((e) => ({ ...e }));
     const promptTags = extractTags(prompt);
     const promptLower = prompt.toLowerCase();
+    // Meta-learning: load tuned weights if available
+    const tunedWeights = loadTunedMatcherWeights();
     // Delegate to shared ranking core. `rankCandidates` is generic so each
     // ranked candidate carries the original `LoadedSolution` reference — no
     // name-based re-lookup, so two scopes sharing a name (e.g. me/foo and
     // project/foo) can both appear in the result without a Map last-wins
     // scope-precedence bug.
-    const ranked = rankCandidates(promptTags, promptLower, allSolutions);
-    return ranked.map(c => ({
+    const ranked = rankCandidates(promptTags, promptLower, allSolutions, tunedWeights);
+    return ranked.map((c) => ({
         name: c.solution.name,
         path: c.solution.filePath,
         scope: c.solution.scope,