autosnippet 3.3.9 → 3.4.1

package/dist/lib/service/guard/ComplianceReporter.js

@@ -93,7 +93,11 @@ export class ComplianceReporter {
         try {
             const { initEnhancementRegistry } = await import('#core/enhancement/index.js');
             const enhReg = await initEnhancementRegistry();
-            const allPacks = enhReg.all();
+            // 仅注入无框架条件的通用 Pack（有框架条件的由 Bootstrap resolve() 精确注入）
+            const allPacks = enhReg.all().filter((pack) => {
+                const cond = pack.conditions;
+                return !cond?.frameworks?.length;
+            });
             const allGuardRules = [];
             for (const pack of allPacks) {
                 try {

package/dist/lib/service/guard/GuardCheckEngine.d.ts

@@ -29,8 +29,10 @@ interface BuiltInRule {
     fixSuggestion?: string;
     excludePaths?: RegExp;
     excludeLinePatterns?: string[];
+    excludePrevLinePatterns?: string[];
     skipComments?: boolean;
     skipTestBlocks?: boolean;
+    skipTestFiles?: boolean;
 }
 interface GuardRule {
     id: string;
@@ -46,8 +48,11 @@ interface GuardRule {
     fixSuggestion?: string | null;
     excludePaths?: RegExp | string;
     excludeLinePatterns?: string[];
+    excludePrevLinePatterns?: string[];
     skipComments?: boolean;
     skipTestBlocks?: boolean;
+    /** When true, this rule is skipped for test files (detected by LanguageService.isTestFile) */
+    skipTestFiles?: boolean;
     astQuery?: {
         queryType: string;
         params?: Record<string, string>;
@@ -108,6 +113,8 @@ interface AuditFileResult {
 interface AuditFilesInput {
     path: string;
     content: string;
+    /** Pre-computed test file flag from LanguageService.isTestFile */
+    isTest?: boolean;
 }
 export { detectLanguage } from './GuardPatternUtils.js';
 /** GuardCheckEngine - 核心检查引擎 */
@@ -146,12 +153,13 @@ export declare class GuardCheckEngine {
      * 对代码运行静态检查
      * @param code 源代码
      * @param language 'objc'|'swift'|'javascript' 等
-     * @param options {scope, filePath}
+     * @param options {scope, filePath, isTest}
      * @returns >}
      */
     checkCode(code: string, language: string, options?: {
         scope?: string | null;
         filePath?: string;
+        isTest?: boolean;
     }): {
         reasoning: {
             whatViolated: string;
@@ -223,6 +231,7 @@ export declare class GuardCheckEngine {
      */
     auditFile(filePath: string, code: string, options?: {
         scope?: string;
+        isTest?: boolean;
     }): AuditFileResult;
     /**
      * 批量文件审计
@@ -237,6 +246,8 @@ export declare class GuardCheckEngine {
         crossFileViolations: import("./GuardCrossFileChecks.js").CrossFileViolation[];
         summary: {
             filesChecked: number;
+            testFiles: number;
+            productionFiles: number;
             totalViolations: number;
             totalErrors: number;
             totalUncertain: number;

package/dist/lib/service/guard/GuardCheckEngine.js

@@ -261,6 +261,7 @@ const BUILT_IN_RULES = {
         languages: ['go'],
         dimension: 'file',
         category: 'correctness',
+        skipTestFiles: true,
     },
     'go-no-err-ignored': {
         message: '错误值不应用 _ 忽略，应处理或明确标注',
@@ -270,6 +271,11 @@ const BUILT_IN_RULES = {
         dimension: 'file',
         category: 'correctness',
         excludePaths: /(?:^|[/\\])(?:tests?|testdata|_test)[/\\]|_test\.go$/,
+        excludeLinePatterns: [
+            '\\.\\([^)]*\\)', // type assertion: val, _ := expr.(Type) — _ 是 bool ok，不是 error
+            'RegisterFlagCompletionFunc', // cobra flag completion: flag 名由同函数字面量保证，不会失败
+            'MarkFlagRequired', // cobra flag setup: 同上
+        ],
     },
     'go-no-init-abuse': {
         message: 'init() 函数副作用难以追踪，避免在 init 中执行复杂逻辑',
@@ -287,6 +293,14 @@ const BUILT_IN_RULES = {
         dimension: 'file',
         category: 'style',
         excludePaths: /(?:^|[/\\])(?:tests?|testdata)[/\\]|_test\.go$/,
+        excludeLinePatterns: [
+            '\\bembed\\.', // //go:embed requires package-level var
+            '\\bsync\\.', // sync.Map, sync.Once, sync.Mutex etc. are designed as package-level vars
+            '\\batomic\\.', // atomic.Pointer, atomic.Value etc.
+        ],
+        excludePrevLinePatterns: [
+            '//go:embed', // //go:embed directive on previous line requires package-level var
+        ],
     },
     // ══════════════════════════════════════════════════════════
     //  Dart (Flutter)
@@ -623,7 +637,11 @@ export class GuardCheckEngine {
                     ...(rule.excludePaths ? { excludePaths: rule.excludePaths } : {}),
                     ...(rule.skipComments ? { skipComments: true } : {}),
                     ...(rule.skipTestBlocks ? { skipTestBlocks: true } : {}),
+                    ...(rule.skipTestFiles ? { skipTestFiles: true } : {}),
                     ...(rule.excludeLinePatterns ? { excludeLinePatterns: rule.excludeLinePatterns } : {}),
+                    ...(rule.excludePrevLinePatterns
+                        ? { excludePrevLinePatterns: rule.excludePrevLinePatterns }
+                        : {}),
                 });
             }
         }
@@ -662,11 +680,11 @@ export class GuardCheckEngine {
      * 对代码运行静态检查
      * @param code 源代码
      * @param language 'objc'|'swift'|'javascript' 等
-     * @param options {scope, filePath}
+     * @param options {scope, filePath, isTest}
      * @returns >}
      */
     checkCode(code, language, options = {}) {
-        const { scope = null, filePath = '' } = options;
+        const { scope = null, filePath = '', isTest = false } = options;
         const violations = [];
         // 获取匹配语言的规则
         let rules = this.getRules(language);
@@ -680,6 +698,10 @@ export class GuardCheckEngine {
                 return !re.test(filePath);
             });
         }
+        // 按 skipTestFiles 标记过滤测试文件
+        if (isTest) {
+            rules = rules.filter((r) => !r.skipTestFiles);
+        }
         // 如果有 scope，按层级过滤：project ⊇ target ⊇ file
         // project 范围包含所有维度的规则；target 包含 file+target；file 仅匹配 file
         // 'universal' 维度在所有 scope 下都生效
@@ -719,6 +741,7 @@ export class GuardCheckEngine {
             // 合并内置 + 配置级排除行模式
             const ruleId = rule.id || rule.name;
             const excludeLineRegexes = this._getExcludeLineRegexes(ruleId, rule.excludeLinePatterns);
+            const excludePrevLineRegexes = this._getExcludeLineRegexes(`${ruleId}:prev`, rule.excludePrevLinePatterns);
             for (let i = 0; i < lines.length; i++) {
                 // skipComments: 跳过注释行（doc comments / 行注释 / 块注释内）
                 if (shouldSkipComments && commentLines[i]) {
@@ -733,6 +756,12 @@ export class GuardCheckEngine {
                     if (excludeLineRegexes.length > 0 && excludeLineRegexes.some((ep) => ep.test(lines[i]))) {
                         continue;
                     }
+                    // excludePrevLinePatterns: 跳过前一行匹配排除模式的行（//go:embed 等指令注释）
+                    if (excludePrevLineRegexes.length > 0 &&
+                        i > 0 &&
+                        excludePrevLineRegexes.some((ep) => ep.test(lines[i - 1]))) {
+                        continue;
+                    }
                     violations.push({
                         ruleId: rule.id || rule.name,
                         message: rule.message,
@@ -1358,8 +1387,8 @@ export class GuardCheckEngine {
         const results = [];
         let totalViolations = 0;
         let totalErrors = 0;
-        for (const { path: filePath, content } of files) {
-            const result = this.auditFile(filePath, content, options);
+        for (const { path: filePath, content, isTest } of files) {
+            const result = this.auditFile(filePath, content, { ...options, isTest });
             results.push(result);
             totalViolations += result.summary.total;
             totalErrors += result.summary.errors;
@@ -1370,8 +1399,11 @@ export class GuardCheckEngine {
         });
         totalViolations += crossFileViolations.length;
         totalErrors += crossFileViolations.filter((v) => v.severity === 'error').length;
+        const testFileCount = files.filter((f) => f.isTest).length;
         const summary = {
             filesChecked: results.length,
+            testFiles: testFileCount,
+            productionFiles: results.length - testFileCount,
             totalViolations,
             totalErrors,
             totalUncertain: results.reduce((s, r) => s + r.summary.uncertain, 0),

package/dist/lib/service/guard/GuardCodeChecks.js

@@ -90,6 +90,7 @@ export function runCodeLevelChecks(code, language, lines, options = {}) {
     // ── Go ──
     if (language === 'go') {
         // defer 在循环内检查 — defer 在函数结束时才执行，循环内 defer 可能资源泄露
+        // 排除 go func() { defer ... } 模式（goroutine 内的 defer 是安全的）
         if (!isDisabled('go-defer-in-loop')) {
             let inLoop = false;
             for (let i = 0; i < lines.length; i++) {
@@ -98,15 +99,32 @@ export function runCodeLevelChecks(code, language, lines, options = {}) {
                     inLoop = true;
                 }
                 if (inLoop && /^\s*defer\s/.test(lines[i])) {
-                    violations.push({
-                        ruleId: 'go-defer-in-loop',
-                        message: 'defer 在循环内会延迟到函数返回时才执行，可能导致资源泄露或大量堆积',
-                        severity: 'warning',
-                        line: i + 1,
-                        snippet: lines[i].trim().slice(0, 120),
-                        dimension: 'file',
-                        fixSuggestion: '将循环体提取到独立函数中，或手动调用 Close()',
-                    });
+                    // 回溯找最近的作用域开场 { — 判断 defer 是否在匿名函数/goroutine 内
+                    let insideAnonymousFunc = false;
+                    let braceBalance = 0;
+                    for (let j = i - 1; j >= 0; j--) {
+                        const prev = lines[j];
+                        braceBalance += (prev.match(/\}/g) || []).length;
+                        braceBalance -= (prev.match(/\{/g) || []).length;
+                        if (braceBalance < 0) {
+                            // 找到包裹 defer 的最近 { — 检查该行是否包含 func 关键字
+                            if (/\bfunc\b/.test(prev)) {
+                                insideAnonymousFunc = true;
+                            }
+                            break;
+                        }
+                    }
+                    if (!insideAnonymousFunc) {
+                        violations.push({
+                            ruleId: 'go-defer-in-loop',
+                            message: 'defer 在循环内会延迟到函数返回时才执行，可能导致资源泄露或大量堆积',
+                            severity: 'warning',
+                            line: i + 1,
+                            snippet: lines[i].trim().slice(0, 120),
+                            dimension: 'file',
+                            fixSuggestion: '将循环体提取到独立函数中，或手动调用 Close()',
+                        });
+                    }
                 }
                 // 简化: 遇到 } 且缩进回到顶层，认为循环结束
                 if (inLoop && trimmed === '}' && (lines[i].match(/^\t/) || lines[i].match(/^}/))) {

package/dist/lib/service/guard/SourceFileCollector.d.ts

@@ -19,10 +19,10 @@ export declare function collectSourceFiles(dir: string, options?: {
     maxFiles?: number;
 }): Promise<string[]>;
 /**
- * 收集源文件并读取内容
+ * 收集源文件并读取内容（带测试文件标记）
  * @param dir 根目录
  * @param options collectSourceFiles 选项
- * @returns >>}
+ * @returns { path, content, isTest }[]
  */
 export declare function collectSourceFilesWithContent(dir: string, options?: {
     extensions?: Set<string>;
@@ -31,6 +31,7 @@ export declare function collectSourceFilesWithContent(dir: string, options?: {
 }): Promise<{
     path: string;
     content: string;
+    isTest: boolean;
 }[]>;
 declare const _default: {
     collectSourceFiles: typeof collectSourceFiles;

package/dist/lib/service/guard/SourceFileCollector.js

@@ -82,10 +82,10 @@ export async function collectSourceFiles(dir, options = {}) {
     return files;
 }
 /**
- * 收集源文件并读取内容
+ * 收集源文件并读取内容（带测试文件标记）
  * @param dir 根目录
  * @param options collectSourceFiles 选项
- * @returns >>}
+ * @returns { path, content, isTest }[]
  */
 export async function collectSourceFilesWithContent(dir, options = {}) {
     const paths = await collectSourceFiles(dir, options);
@@ -93,7 +93,7 @@ export async function collectSourceFilesWithContent(dir, options = {}) {
     for (const filePath of paths) {
         try {
             const content = await readFile(filePath, 'utf-8');
-            results.push({ path: filePath, content });
+            results.push({ path: filePath, content, isTest: LanguageService.isTestFile(filePath) });
         }
         catch {
             // 读取失败跳过

package/dist/lib/service/search/SearchEngine.js

@@ -110,6 +110,7 @@ export class SearchEngine {
     async search(query, options = {}) {
         const { type = 'all', limit = 20, mode = 'keyword', context } = options;
         const shouldRank = options.rank ?? mode !== 'keyword';
+        const tSearchStart = performance.now();
         if (!query || !query.trim()) {
             return { items: [], total: 0, query };
         }
@@ -132,60 +133,62 @@ export class SearchEngine {
         let actualMode = mode;
         switch (mode) {
             case 'auto': {
-                // 缓存 FieldWeighted 结果, 避免 RRF 降级时重复计算
-                let cachedScorerItems = null;
-                const getScorerResults = () => {
-                    if (!cachedScorerItems) {
-                        cachedScorerItems = this._scorerSearch(query, type, recallLimit);
-                    }
-                    return cachedScorerItems;
-                };
-                // 优先使用 VectorService 的 hybridSearch (统一 RRF 融合)
-                if (this.vectorService) {
-                    try {
-                        const sparseItems = getScorerResults();
-                        const rrfResults = await this.vectorService.hybridSearch(query, {
-                            topK: recallLimit,
-                            alpha: this._fusionSemanticWeight,
-                            sparseSearchFn: () => sparseItems,
+                // ── Weighted-First + Confidence Gate ──
+                // 先跑 weighted（~40ms），评估是否需要 embed（2-22s）
+                const weightedItems = this._scorerSearch(query, type, recallLimit);
+                const confidence = this.#computeWeightedConfidence(query, weightedItems, limit);
+                if (confidence >= 60 || !this.vectorService) {
+                    // 高 confidence: weighted 已足够，跳过 embed
+                    results = weightedItems;
+                    actualMode = `auto(weighted-only,conf=${confidence})`;
+                    this.logger.info(`[QueryRouter] skip-semantic: conf=${confidence} topScore=${weightedItems[0]?.score ?? 0} query="${query}"`);
+                    break;
+                }
+                // 低 confidence: 投入 embed，RRF 融合
+                // 自适应 alpha：confidence 越低 → semantic 权重越高
+                // conf=0 → alpha=0.75, conf=30 → alpha=0.575, conf=55 → alpha=0.42
+                const adaptiveAlpha = this._fusionSemanticWeight + (0.75 - this._fusionSemanticWeight) * (1 - confidence / 60);
+                this.logger.info(`[QueryRouter] invoke-semantic: conf=${confidence} alpha=${adaptiveAlpha.toFixed(2)} topScore=${weightedItems[0]?.score ?? 0} query="${query}"`);
+                try {
+                    const rrfResults = await this.vectorService.hybridSearch(query, {
+                        topK: recallLimit,
+                        alpha: adaptiveAlpha,
+                        sparseSearchFn: () => weightedItems,
+                    });
+                    if (rrfResults.length > 0) {
+                        results = rrfResults.map((r) => {
+                            const base = r.data?.item ||
+                                r.data ||
+                                {};
+                            const baseMeta = (base.metadata || {});
+                            return {
+                                id: r.id,
+                                title: (base.title ||
+                                    baseMeta.title ||
+                                    r.id),
+                                type: (base.type || 'recipe'),
+                                kind: (base.kind ||
+                                    baseMeta.kind ||
+                                    'pattern'),
+                                status: (base.status ||
+                                    baseMeta.status ||
+                                    'active'),
+                                score: Math.round(r.score * 1000) / 1000,
+                                content: base.content,
+                                description: base.description,
+                            };
                         });
-                        if (rrfResults.length > 0) {
-                            results = rrfResults.map((r) => {
-                                const base = r.data?.item ||
-                                    r.data ||
-                                    {};
-                                const baseMeta = (base.metadata || {});
-                                return {
-                                    id: r.id,
-                                    title: (base.title ||
-                                        baseMeta.title ||
-                                        r.id),
-                                    type: (base.type || 'recipe'),
-                                    kind: (base.kind ||
-                                        baseMeta.kind ||
-                                        'pattern'),
-                                    status: (base.status ||
-                                        baseMeta.status ||
-                                        'active'),
-                                    score: Math.round(r.score * 1000) / 1000,
-                                    content: base.content,
-                                    description: base.description,
-                                };
-                            });
-                            this._supplementDetails(results);
-                            actualMode = 'auto(rrf)';
-                            break;
-                        }
-                    }
-                    catch {
-                        // VectorService RRF 失败, 降级到 min-max 融合
+                        this._supplementDetails(results);
+                        actualMode = `auto(rrf,conf=${confidence},α=${adaptiveAlpha.toFixed(2)})`;
+                        break;
                     }
                 }
-                // 降级: VectorService 不可用或 RRF 零结果 → 纯 FieldWeighted
-                // 旧版在此做 BM25+semantic min-max 融合，但当 VectorService 不可用时
-                // semantic 通常也会失败，最终退化为纯 FieldWeighted。简化为直接走 scorer。
-                results = getScorerResults();
-                actualMode = 'auto(weighted-only)';
+                catch {
+                    // VectorService RRF 失败, 降级
+                }
+                // 降级: embed 失败 → 返回已有的 weighted 结果
+                results = weightedItems;
+                actualMode = `auto(weighted-fallback,conf=${confidence})`;
                 break;
             }
             case 'weighted':
@@ -215,6 +218,9 @@ export class SearchEngine {
             type,
             ranked: shouldRank && results.length > 0,
         };
+        // ── 搜索计时日志 ──
+        const tSearchEnd = performance.now();
+        this.logger.info(`Search completed: mode=${actualMode} total=${results.length} time=${Math.round(tSearchEnd - tSearchStart)}ms ranked=${response.ranked} query="${query}"`);
         if (options.groupByKind) {
             response.byKind = { rule: [], pattern: [], fact: [] };
             for (const r of results) {
@@ -448,15 +454,20 @@ export class SearchEngine {
                     let results = vectorResults.map((vr) => {
                         const item = vr.item;
                         const metadata = (item.metadata || {});
+                        const rawId = item.id || '';
+                        // 从 vector ID 提取 DB entryId: "entry_<uuid>" → "<uuid>"
+                        const entryId = metadata.entryId || rawId.replace(/^entry_/, '');
                         return {
-                            id: item.id || metadata.entryId || '',
-                            title: metadata.title || item.id || '',
+                            id: entryId,
+                            title: metadata.title || entryId,
                             type: 'recipe',
                             kind: metadata.kind || 'pattern',
                             status: metadata.status || 'active',
                             score: Math.round(vr.score * 1000) / 1000,
                         };
                     });
+                    // 按 entryId 去重 — 同一 Recipe 的多个 chunk 只保留最高分
+                    results = this.#deduplicateByEntryId(results);
                     if (type !== 'all') {
                         results = results.filter((r) => {
                             if (type === 'rule') {
@@ -505,14 +516,20 @@ export class SearchEngine {
                         vectorResults = await this.vectorStore.query(queryEmbedding, limit * 2);
                     }
                     if (vectorResults && vectorResults.length > 0) {
-                        let results = vectorResults.map((vr) => ({
-                            id: vr.id,
-                            title: vr.metadata?.title || vr.id,
-                            type: 'recipe',
-                            kind: vr.metadata?.kind || 'pattern',
-                            status: vr.metadata?.status || 'active',
-                            score: Math.round((vr.similarity || vr.score || 0) * 1000) / 1000,
-                        }));
+                        let results = vectorResults.map((vr) => {
+                            const rawId = vr.id || '';
+                            const entryId = vr.metadata?.entryId || rawId.replace(/^entry_/, '');
+                            return {
+                                id: entryId,
+                                title: vr.metadata?.title || entryId,
+                                type: 'recipe',
+                                kind: vr.metadata?.kind || 'pattern',
+                                status: vr.metadata?.status || 'active',
+                                score: Math.round((vr.similarity || vr.score || 0) * 1000) / 1000,
+                            };
+                        });
+                        // 按 entryId 去重
+                        results = this.#deduplicateByEntryId(results);
                         if (type !== 'all') {
                             results = results.filter((r) => {
                                 if (type === 'rule') {
@@ -542,6 +559,93 @@ export class SearchEngine {
             return { items: this._scorerSearch(query, type, limit), actualMode: 'weighted' };
         }
     }
+    /**
+     * 按 entryId 去重 — 同一 Recipe 的多个 chunk 只保留最高分的
+     * 解决向量搜索返回同一条目的多个 chunk 浪费结果位的问题
+     */
+    #deduplicateByEntryId(items) {
+        const seen = new Map();
+        for (const item of items) {
+            const existing = seen.get(item.id);
+            if (!existing || (item.score ?? 0) > (existing.score ?? 0)) {
+                seen.set(item.id, item);
+            }
+        }
+        return [...seen.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    }
+    /**
+     * 评估 weighted 搜索结果的 confidence，决定是否需要语义搜索
+     * 返回 0-100 的分数，>= 60 跳过语义
+     */
+    #computeWeightedConfidence(query, items, requestedLimit) {
+        let score = 0;
+        // ── 结果质量信号 ──
+        // FieldWeightedScorer 分数范围约 0-20，归一化后判断
+        const topScore = items[0]?.score ?? 0;
+        const secondScore = items[1]?.score ?? 0;
+        // top1 与 top2 分差大 → 明确命中
+        if (items.length >= 2 && topScore > 0) {
+            const relativeGap = (topScore - secondScore) / topScore;
+            if (relativeGap > 0.3) {
+                score += 25;
+            }
+            else if (relativeGap > 0.15) {
+                score += 15;
+            }
+        }
+        // title/trigger 匹配（子串级别）
+        const lq = query.toLowerCase();
+        const matchLevel = items.slice(0, 3).reduce((best, it) => {
+            const t = (it.title || '').toLowerCase();
+            const tr = (it.trigger || '').toLowerCase();
+            if (t === lq || tr === lq || tr === `@${lq}`) {
+                return Math.max(best, 3); // 完全匹配
+            }
+            if (t.includes(lq) || tr.includes(lq)) {
+                return Math.max(best, 2); // 子串匹配
+            }
+            if (lq.includes(t) && t.length > 3) {
+                return Math.max(best, 1); // 反向包含
+            }
+            return best;
+        }, 0);
+        if (matchLevel === 3) {
+            score += 50;
+        }
+        else if (matchLevel === 2) {
+            score += 35;
+        }
+        else if (matchLevel === 1) {
+            score += 15;
+        }
+        // 代码术语检测（CamelCase、snake_case、@trigger）
+        if (/^[A-Z][a-zA-Z0-9]+$/.test(query) ||
+            /^[a-z]+(_[a-z]+)+$/.test(query) ||
+            query.startsWith('@')) {
+            score += 25;
+        }
+        // 候选充足
+        if (items.length >= requestedLimit) {
+            score += 10;
+        }
+        // ── 查询特征信号（降低 confidence → 倾向调用语义）──
+        // 中文自然语言疑问句
+        if (/[如怎什为何哪]么?|是否|有没有|都有哪些|应该|需要/.test(query)) {
+            score -= 40;
+        }
+        // 英文自然语言问句
+        if (/^(how|what|why|when|where|which|can|does|is|should)\b/i.test(query)) {
+            score -= 40;
+        }
+        // 较长查询（可能是描述性语句）
+        if (query.length > 20) {
+            score -= 20;
+        }
+        else if (query.length > 10) {
+            score -= 10;
+        }
+        return Math.max(0, Math.min(100, score));
+    }
     /**
      * 补充详细字段（content / description / trigger / delivery 字段）— 批量 IN 查询
      * 用于向量搜索结果与 FieldWeighted 结果的一致性

package/dist/lib/service/task/PrimeSearchPipeline.js

@@ -108,15 +108,30 @@ export class PrimeSearchPipeline {
         const autoPromises = autoQueries.map((q) => this.#search
             .search(q, { mode: 'auto', limit: 8, rank: false, context })
             .catch(() => ({ items: [] })));
+        // Semantic-mode search for primary query — ensures semantic is always
+        // part of RRF fusion even when auto mode skips it (confidence ≥ 60)
+        const semanticPromise = autoQueries[0]
+            ? this.#search
+                .search(autoQueries[0], { mode: 'semantic', limit: 6, rank: false })
+                .catch(() => ({ items: [] }))
+            : Promise.resolve({ items: [] });
         // Keyword-mode searches (raw FWS scores — for cross-language synonym matching)
         const kwPromises = keywordQueries.map((q) => this.#search
             .search(q, { mode: 'keyword', limit: 8, rank: false })
             .catch(() => ({ items: [] })));
-        const [autoResponses, kwResponses] = await Promise.all([
+        const [autoResponses, kwResponses, semanticResponse] = await Promise.all([
             Promise.all(autoPromises),
             Promise.all(kwPromises),
+            semanticPromise,
         ]);
-        const allResponses = [...autoResponses, ...kwResponses];
+        // Merge: auto + semantic + keyword
+        const semanticItems = (semanticResponse.items ||
+            []);
+        const allResponses = [
+            ...autoResponses,
+            ...(semanticItems.length > 0 ? [semanticResponse] : []),
+            ...kwResponses,
+        ];
         // Single-query shortcut: preserve original scores from search engine.
         // RRF is pointless with one response — it just converts rank to score,
         // discarding the magnitude information from BM25/CoarseRanker.

package/dist/lib/service/vector/VectorService.js

@@ -201,13 +201,18 @@ export class VectorService {
         }
         const { topK = 10, filter = null, minScore = 0 } = opts;
         try {
+            const t0 = performance.now();
             const embedResult = await this.#embedProvider.embed(query);
+            const tEmbed = performance.now();
             const queryVector = Array.isArray(embedResult[0]) ? embedResult[0] : embedResult;
-            return this.#vectorStore.searchVector(queryVector, {
+            const results = await this.#vectorStore.searchVector(queryVector, {
                 topK,
                 filter,
                 minScore,
             });
+            const tHnsw = performance.now();
+            this.#logger.info(`[VectorService] search: embed=${Math.round(tEmbed - t0)}ms hnsw=${Math.round(tHnsw - tEmbed)}ms total=${Math.round(tHnsw - t0)}ms results=${results.length}`);
+            return results;
         }
         catch (err) {
             this.#logger.warn('[VectorService] search failed', {
@@ -240,6 +245,7 @@ export class VectorService {
         // Embed query — circuit breaker skips embed after repeated failures
         let queryVector = null;
         const circuitOpen = Date.now() < this.#embedCircuitOpenUntil;
+        const tEmbedStart = performance.now();
         if (circuitOpen) {
             this.#logger.debug('[VectorService] embed circuit open, skipping embed');
         }
@@ -267,12 +273,15 @@ export class VectorService {
                 }
             }
         }
+        const tEmbedEnd = performance.now();
         try {
             const fused = await this.#hybridRetriever.search(query, queryVector, {
                 topK,
                 alpha,
                 sparseSearchFn: sparseSearchFn ?? undefined,
             });
+            const tFuseEnd = performance.now();
+            this.#logger.info(`[VectorService] hybridSearch: embed=${Math.round(tEmbedEnd - tEmbedStart)}ms fuse=${Math.round(tFuseEnd - tEmbedEnd)}ms total=${Math.round(tFuseEnd - tEmbedStart)}ms hasVector=${!!queryVector} results=${fused.length} alpha=${alpha}`);
             return fused.map((r) => ({
                 id: r.id || '',
                 score: r.score || 0,

package/dist/lib/shared/LanguageService.d.ts

@@ -161,5 +161,17 @@ export declare class LanguageService {
         discovererIds?: string[];
         maxDepth?: number;
     }): unknown[];
+    /**
+     * 判定文件路径是否为测试文件
+     *
+     * 两层判定：
+     *   1. 语言特定的文件名模式（_test.go, .test.ts, test_*.py 等）
+     *   2. 通用测试目录模式（test/, tests/, __tests__/, spec/ 等）
+     *
+     * @param filePath 文件路径（相对或绝对均可）
+     * @param [language] 已知语言 ID，省略时从扩展名推断
+     * @returns 是否为测试文件
+     */
+    static isTestFile(filePath: string, language?: string): boolean;
 }
 export default LanguageService;