autosnippet 3.2.21 → 3.3.2

package/dist/lib/service/signal/HitRecorder.d.ts

@@ -0,0 +1,68 @@
+/**
+ * HitRecorder — 批量使用信号采集器
+ *
+ * Phase 0 核心服务。将高频使用事件（Guard 命中、搜索命中、采用等）
+ * 先写入内存 buffer，定时批量持久化到 Stats JSON，同时发射 SignalBus 信号。
+ *
+ * 设计要点：
+ *   - 即时 emit Signal（信号不延迟）
+ *   - buffer → 30s flush → 批量 UPDATE（减少 SQLite 写）
+ *   - shutdown hook 保证进程退出前数据落盘
+ *
+ * @module service/signal/HitRecorder
+ */
+import type { SignalBus } from '#infra/signal/SignalBus.js';
+/** better-sqlite3 兼容类型（与 GuardCheckEngine 相同模式） */
+interface DatabaseLike {
+    prepare(sql: string): {
+        run(...params: unknown[]): unknown;
+    };
+}
+/** 支持的命中事件类型 */
+export type HitEventType = 'guardHit' | 'searchHit' | 'view' | 'adoption' | 'application';
+/** HitRecorder 配置 */
+export interface HitRecorderConfig {
+    /** flush 间隔（ms），默认 30000 */
+    flushIntervalMs?: number;
+    /** 立即 flush 的最大缓冲条目数，默认 100 */
+    maxBufferSize?: number;
+}
+export declare class HitRecorder {
+    #private;
+    constructor(bus: SignalBus, db: DatabaseLike | {
+        getDb(): DatabaseLike;
+    }, config?: HitRecorderConfig);
+    /**
+     * 启动定时 flush。通常在服务初始化时调用。
+     */
+    start(): void;
+    /**
+     * 停止定时 flush 并执行最后一次 flush。
+     * 供 shutdown hook 调用。
+     */
+    stop(): Promise<void>;
+    /**
+     * 记录一次命中事件。
+     *
+     * 1. 立即通过 SignalBus 发射信号（信号不延迟）
+     * 2. 事件写入内存 buffer，等待 flush 批量持久化
+     *
+     * @param recipeId  关联的知识条目 ID
+     * @param eventType 事件类型
+     * @param value     信号强度 0-1（默认 1）
+     * @param metadata  附加元数据
+     */
+    record(recipeId: string, eventType: HitEventType, value?: number, metadata?: Record<string, unknown>): void;
+    /**
+     * 批量持久化 buffer 到数据库。
+     * 使用 json_set 原子更新 Stats JSON 中对应字段。
+     */
+    flush(): Promise<number>;
+    /** 当前 buffer 中的条目数（诊断用） */
+    get bufferSize(): number;
+    /** 累计记录次数 */
+    get totalRecorded(): number;
+    /** 累计已持久化次数 */
+    get totalFlushed(): number;
+}
+export {};

package/dist/lib/service/signal/HitRecorder.js

@@ -0,0 +1,173 @@
+/**
+ * HitRecorder — 批量使用信号采集器
+ *
+ * Phase 0 核心服务。将高频使用事件（Guard 命中、搜索命中、采用等）
+ * 先写入内存 buffer，定时批量持久化到 Stats JSON，同时发射 SignalBus 信号。
+ *
+ * 设计要点：
+ *   - 即时 emit Signal（信号不延迟）
+ *   - buffer → 30s flush → 批量 UPDATE（减少 SQLite 写）
+ *   - shutdown hook 保证进程退出前数据落盘
+ *
+ * @module service/signal/HitRecorder
+ */
+/** 事件类型 → Stats JSON 字段 映射 */
+const EVENT_TO_STATS_FIELD = {
+    guardHit: 'guardHits',
+    searchHit: 'searchHits',
+    view: 'views',
+    adoption: 'adoptions',
+    application: 'applications',
+};
+/** 事件类型 → SignalBus 信号类型 映射 */
+const EVENT_TO_SIGNAL_TYPE = {
+    guardHit: 'guard',
+    searchHit: 'search',
+    view: 'usage',
+    adoption: 'usage',
+    application: 'usage',
+};
+// ── HitRecorder ─────────────────────────────────────
+export class HitRecorder {
+    #bus;
+    #db;
+    #buffer = new Map();
+    #flushIntervalMs;
+    #maxBufferSize;
+    #timer = null;
+    #totalRecorded = 0;
+    #totalFlushed = 0;
+    constructor(bus, db, config = {}) {
+        this.#bus = bus;
+        this.#db =
+            'getDb' in db && typeof db.getDb === 'function'
+                ? db.getDb()
+                : db;
+        this.#flushIntervalMs = config.flushIntervalMs ?? 30_000;
+        this.#maxBufferSize = config.maxBufferSize ?? 100;
+    }
+    /**
+     * 启动定时 flush。通常在服务初始化时调用。
+     */
+    start() {
+        if (this.#timer) {
+            return;
+        }
+        this.#timer = setInterval(() => {
+            void this.flush();
+        }, this.#flushIntervalMs);
+        this.#timer.unref(); // 不阻止进程退出
+    }
+    /**
+     * 停止定时 flush 并执行最后一次 flush。
+     * 供 shutdown hook 调用。
+     */
+    async stop() {
+        if (this.#timer) {
+            clearInterval(this.#timer);
+            this.#timer = null;
+        }
+        await this.flush();
+    }
+    /**
+     * 记录一次命中事件。
+     *
+     * 1. 立即通过 SignalBus 发射信号（信号不延迟）
+     * 2. 事件写入内存 buffer，等待 flush 批量持久化
+     *
+     * @param recipeId  关联的知识条目 ID
+     * @param eventType 事件类型
+     * @param value     信号强度 0-1（默认 1）
+     * @param metadata  附加元数据
+     */
+    record(recipeId, eventType, value = 1, metadata = {}) {
+        this.#totalRecorded++;
+        // 1. 即时发射信号
+        this.#bus.send(EVENT_TO_SIGNAL_TYPE[eventType], `HitRecorder.${eventType}`, value, {
+            target: recipeId,
+            metadata: { ...metadata, eventType },
+        });
+        // 2. 聚合进 buffer
+        const key = `${recipeId}:${eventType}`;
+        const now = Date.now();
+        const existing = this.#buffer.get(key);
+        if (existing) {
+            existing.count++;
+            existing.lastAt = now;
+        }
+        else {
+            this.#buffer.set(key, {
+                recipeId,
+                eventType,
+                count: 1,
+                firstAt: now,
+                lastAt: now,
+            });
+        }
+        // 3. buffer 满时立即 flush
+        if (this.#buffer.size >= this.#maxBufferSize) {
+            void this.flush();
+        }
+    }
+    /**
+     * 批量持久化 buffer 到数据库。
+     * 使用 json_set 原子更新 Stats JSON 中对应字段。
+     */
+    async flush() {
+        if (this.#buffer.size === 0) {
+            return 0;
+        }
+        // 取出当前 buffer 并清空（后续 record 写入新 buffer）
+        const entries = [...this.#buffer.values()];
+        this.#buffer.clear();
+        let flushed = 0;
+        const now = Math.floor(Date.now() / 1000);
+        try {
+            const stmt = this.#db.prepare(`UPDATE knowledge_entries
+         SET stats = json_set(
+               COALESCE(stats, '{}'),
+               '$.' || ?,
+               COALESCE(json_extract(stats, '$.' || ?), 0) + ?
+             ),
+             updatedAt = ?
+         WHERE id = ?`);
+            for (const entry of entries) {
+                const field = EVENT_TO_STATS_FIELD[entry.eventType];
+                try {
+                    stmt.run(field, field, entry.count, now, entry.recipeId);
+                    flushed += entry.count;
+                }
+                catch {
+                    // Recipe 可能已被删除，静默忽略
+                }
+            }
+        }
+        catch {
+            // DB statement prepare 失败（表可能不存在），回填 buffer
+            for (const entry of entries) {
+                const key = `${entry.recipeId}:${entry.eventType}`;
+                const existing = this.#buffer.get(key);
+                if (existing) {
+                    existing.count += entry.count;
+                }
+                else {
+                    this.#buffer.set(key, entry);
+                }
+            }
+        }
+        this.#totalFlushed += flushed;
+        return flushed;
+    }
+    /** 当前 buffer 中的条目数（诊断用） */
+    get bufferSize() {
+        return this.#buffer.size;
+    }
+    /** 累计记录次数 */
+    get totalRecorded() {
+        return this.#totalRecorded;
+    }
+    /** 累计已持久化次数 */
+    get totalFlushed() {
+        return this.#totalFlushed;
+    }
+}

package/dist/lib/service/skills/SignalCollector.d.ts

@@ -41,6 +41,7 @@ interface SignalCollectorOpts {
     database?: DatabaseLike | null;
     agentFactory?: AgentFactoryLike | null;
     container?: ContainerLike | null;
+    signalBus?: import('../../infrastructure/signal/SignalBus.js').SignalBus | null;
     mode?: string;
     intervalMs?: number;
     onSuggestions?: ((suggestions: Record<string, unknown>[]) => void) | null;
@@ -80,11 +81,12 @@ export declare class SignalCollector {
      * @param [opts.database] better-sqlite3 实例
      * @param [opts.agentFactory] AgentFactory 实例
      * @param [opts.container] ServiceContainer 实例
+     * @param [opts.signalBus] SignalBus 实例（实时信号订阅）
      * @param [opts.mode] 'off' | 'suggest' | 'auto'
      * @param [opts.intervalMs] 初始收集间隔（毫秒），后续由 AI 动态调整
      * @param [opts.onSuggestions] 新建议回调 (suggestions[]) => void
      */
-    constructor({ projectRoot, database, agentFactory, container, mode, intervalMs, onSuggestions, }: SignalCollectorOpts);
+    constructor({ projectRoot, database, agentFactory, container, signalBus, mode, intervalMs, onSuggestions, }: SignalCollectorOpts);
     start(): void;
     stop(): void;
     /**

package/dist/lib/service/skills/SignalCollector.js

@@ -62,16 +62,19 @@ export class SignalCollector {
     #onSuggestions;
     /** 信号聚类引擎 */
     #aggregator;
+    /** 各维度最新信号快照（由 SignalBus 实时更新） */
+    #dimensionSignals = {};
     /**
      * @param opts.projectRoot 用户项目根目录
      * @param [opts.database] better-sqlite3 实例
      * @param [opts.agentFactory] AgentFactory 实例
      * @param [opts.container] ServiceContainer 实例
+     * @param [opts.signalBus] SignalBus 实例（实时信号订阅）
      * @param [opts.mode] 'off' | 'suggest' | 'auto'
      * @param [opts.intervalMs] 初始收集间隔（毫秒），后续由 AI 动态调整
      * @param [opts.onSuggestions] 新建议回调 (suggestions[]) => void
      */
-    constructor({ projectRoot, database = null, agentFactory = null, container = null, mode = 'auto', intervalMs = DEFAULT_INTERVAL_MS, onSuggestions = null, }) {
+    constructor({ projectRoot, database = null, agentFactory = null, container = null, signalBus = null, mode = 'auto', intervalMs = DEFAULT_INTERVAL_MS, onSuggestions = null, }) {
         this.#projectRoot = projectRoot;
         this.#db = database;
         this.#agentFactory = agentFactory;
@@ -94,6 +97,12 @@ export class SignalCollector {
                 this.#timer = setTimeout(() => this.#tick(), 3000); // 3 秒后执行，留出更多聚合时间
             }
         });
+        // Phase 2: 订阅 SignalBus 全量信号，维护维度快照
+        if (signalBus) {
+            signalBus.subscribe('*', (signal) => {
+                this.#updateDimension(signal);
+            });
+        }
     }
     // ═══════════════════════════════════════════════════════
     //  公共 API
@@ -144,6 +153,27 @@ export class SignalCollector {
     getSnapshot() {
         return { ...this.#snapshot };
     }
+    /** 由 SignalBus 实时更新的维度信号快照 */
+    #updateDimension(signal) {
+        switch (signal.type) {
+            case 'guard':
+            case 'guard_blind_spot':
+                this.#dimensionSignals.compliance = signal;
+                break;
+            case 'usage':
+                this.#dimensionSignals.adoption = signal;
+                break;
+            case 'quality':
+                this.#dimensionSignals.quality = signal;
+                break;
+            case 'decay':
+                this.#dimensionSignals.decay = signal;
+                break;
+            case 'lifecycle':
+                this.#dimensionSignals.evolution = signal;
+                break;
+        }
+    }
     getMode() {
         return this.#mode;
     }

package/dist/lib/service/task/IntentExtractor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * IntentExtractor — Intake Layer
+ *
+ * Pure functions: extract intent signals from user query + active file.
+ * Builds multi-query set, infers language/module/scenario for search routing.
+ *
+ * @module service/task/IntentExtractor
+ */
+export type SearchScenario = 'lint' | 'generate' | 'search' | 'learning';
+export interface ExtractedIntent {
+    /** Multi-query set: Q1 raw + Q2 tech terms + Q3 file context */
+    queries: string[];
+    /** Inferred language from activeFile or args */
+    language: string | null;
+    /** Inferred module path from activeFile */
+    module: string | null;
+    /** Search scenario for MultiSignalRanker routing */
+    scenario: SearchScenario;
+    /** Original inputs */
+    raw: {
+        userQuery: string;
+        activeFile?: string;
+        language?: string;
+    };
+}
+export interface TechTermOptions {
+    /** Project-specific class prefixes, e.g. ['BD', 'BBA', 'KS'] */
+    projectPrefixes?: string[];
+    /** Language/platform common prefixes, e.g. ObjC: ['UI', 'NS', 'CA', 'AV'] */
+    platformPrefixes?: string[];
+}
+/**
+ * Extract intent signals from user query and active file.
+ * Pure function — no side effects, no DI.
+ */
+export declare function extract(userQuery: string, activeFile?: string, language?: string, termOpts?: TechTermOptions): ExtractedIntent;
+/**
+ * Build multi-query set from user query + active file.
+ * Q1: raw query, Q2: extracted tech terms, Q3: file context.
+ */
+export declare function buildQueries(userQuery: string, activeFile?: string, termOpts?: TechTermOptions): string[];
+/**
+ * Extract tech terms from query using universal patterns + dynamic project prefixes.
+ */
+export declare function extractTechTerms(query: string, opts?: TechTermOptions): string[];
+/**
+ * Infer file context string from file path for search augmentation.
+ * Returns module path + class name, e.g. "Services/Network BDNetworkManager"
+ */
+export declare function inferFileContext(filePath: string): string | null;
+/**
+ * Infer language from file extension.
+ */
+export declare function inferLanguage(filePath: string): string | null;
+/**
+ * Classify search scenario from user query (lightweight rule-based).
+ */
+export declare function classifyScenario(userQuery: string): SearchScenario;

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

@@ -0,0 +1,142 @@
+/**
+ * IntentExtractor — Intake Layer
+ *
+ * Pure functions: extract intent signals from user query + active file.
+ * Builds multi-query set, infers language/module/scenario for search routing.
+ *
+ * @module service/task/IntentExtractor
+ */
+// ── Universal Patterns (language-agnostic) ──────────
+const UNIVERSAL_PATTERNS = [
+    /\b[A-Z][a-z]+(?:[A-Z][a-z]+)+\b/g, // CamelCase
+    /`([^`]+)`/g, // backtick code
+    /\b[\w-]+\.(?:ts|js|m|h|swift|py|java|go|rs|tsx|kt)\b/g, // file names
+    /@[\w-]+/g, // trigger references
+];
+// ── Language Extension Map ──────────────────────────
+const LANG_MAP = {
+    m: 'objectivec',
+    h: 'objectivec',
+    mm: 'objectivec',
+    swift: 'swift',
+    ts: 'typescript',
+    tsx: 'typescript',
+    js: 'javascript',
+    jsx: 'javascript',
+    py: 'python',
+    go: 'go',
+    rs: 'rust',
+    java: 'java',
+    kt: 'kotlin',
+};
+// ── Public API ──────────────────────────────────────
+/**
+ * Extract intent signals from user query and active file.
+ * Pure function — no side effects, no DI.
+ */
+export function extract(userQuery, activeFile, language, termOpts) {
+    const queries = buildQueries(userQuery, activeFile, termOpts);
+    const inferredLang = language || (activeFile ? inferLanguage(activeFile) : null);
+    const module = activeFile ? inferFileContext(activeFile) : null;
+    const scenario = classifyScenario(userQuery);
+    return {
+        queries,
+        language: inferredLang,
+        module,
+        scenario,
+        raw: { userQuery, activeFile, language },
+    };
+}
+/**
+ * Build multi-query set from user query + active file.
+ * Q1: raw query, Q2: extracted tech terms, Q3: file context.
+ */
+export function buildQueries(userQuery, activeFile, termOpts) {
+    const queries = [userQuery];
+    const terms = extractTechTerms(userQuery, termOpts);
+    if (terms.length > 0) {
+        queries.push(terms.join(' '));
+    }
+    if (activeFile) {
+        const ctx = inferFileContext(activeFile);
+        if (ctx) {
+            queries.push(ctx);
+        }
+    }
+    return queries;
+}
+/**
+ * Extract tech terms from query using universal patterns + dynamic project prefixes.
+ */
+export function extractTechTerms(query, opts = {}) {
+    const terms = new Set();
+    // 1. Universal patterns (always run)
+    for (const pattern of UNIVERSAL_PATTERNS) {
+        for (const match of query.matchAll(new RegExp(pattern.source, pattern.flags))) {
+            const term = match[1] || match[0];
+            if (term.length >= 3 && term.length <= 50) {
+                terms.add(term);
+            }
+        }
+    }
+    // 2. Project prefix patterns (dynamic)
+    const allPrefixes = [...(opts.projectPrefixes ?? []), ...(opts.platformPrefixes ?? [])];
+    const prefixPattern = buildPrefixPattern(allPrefixes);
+    if (prefixPattern) {
+        for (const match of query.matchAll(prefixPattern)) {
+            if (match[0].length >= 3 && match[0].length <= 50) {
+                terms.add(match[0]);
+            }
+        }
+    }
+    return [...terms].slice(0, 8);
+}
+/**
+ * Infer file context string from file path for search augmentation.
+ * Returns module path + class name, e.g. "Services/Network BDNetworkManager"
+ */
+export function inferFileContext(filePath) {
+    const parts = filePath.replace(/\\/g, '/').split('/');
+    const fileName = parts[parts.length - 1] || '';
+    // Extract class name (remove extension)
+    const className = fileName.replace(/\.\w+$/, '');
+    // Extract meaningful module path (skip root dir and file name)
+    const meaningful = parts
+        .slice(1, -1)
+        .filter((p) => !['src', 'lib', 'Sources', 'BiliDili', 'BiliDemo'].includes(p));
+    const module = meaningful.slice(0, 2).join('/');
+    const segments = [module, className].filter(Boolean);
+    return segments.length > 0 ? segments.join(' ') : null;
+}
+/**
+ * Infer language from file extension.
+ */
+export function inferLanguage(filePath) {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    return ext ? (LANG_MAP[ext] ?? null) : null;
+}
+/**
+ * Classify search scenario from user query (lightweight rule-based).
+ */
+export function classifyScenario(userQuery) {
+    const q = userQuery.toLowerCase();
+    if (/帮我[加写做实现创建]|implement|add|create|新[增加建]/.test(q)) {
+        return 'generate';
+    }
+    if (/检查|review|lint|合规|违规|guard|规[则范]/.test(q)) {
+        return 'lint';
+    }
+    if (/什么是|怎么[用做]|原理|explain|学习|理解|为什么/.test(q)) {
+        return 'learning';
+    }
+    return 'search';
+}
+// ── Internal Helpers ────────────────────────────────
+function buildPrefixPattern(prefixes) {
+    if (prefixes.length === 0) {
+        return null;
+    }
+    const sorted = [...prefixes].sort((a, b) => b.length - a.length);
+    const escaped = sorted.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    return new RegExp(`\\b(?:${escaped.join('|')})\\w{2,}\\b`, 'g');
+}

package/dist/lib/service/task/PrimeSearchPipeline.d.ts

@@ -0,0 +1,54 @@
+/**
+ * PrimeSearchPipeline — Enrichment Layer
+ *
+ * Multi-query parallel search + scenario routing + session history accumulation.
+ * Replaces TaskKnowledgeBridge with full search pipeline integration.
+ *
+ * @module service/task/PrimeSearchPipeline
+ */
+import type { SlimSearchResult } from '#service/search/SearchTypes.js';
+import type { ExtractedIntent } from './IntentExtractor.js';
+/** Slim search result (re-export for external use) */
+export type { SlimSearchResult } from '#service/search/SearchTypes.js';
+export interface PrimeSearchMeta {
+    queries: string[];
+    scenario: string;
+    language: string | null;
+    module: string | null;
+    resultCount: number;
+    filteredCount: number;
+}
+export interface PrimeSearchResult {
+    relatedKnowledge: SlimSearchResult[];
+    guardRules: SlimSearchResult[];
+    searchMeta: PrimeSearchMeta;
+}
+/** Minimal SearchEngine shape — duck-typed for DI flexibility */
+interface SearchEngineLike {
+    search(query: string, options?: {
+        mode?: string;
+        limit?: number;
+        rank?: boolean;
+        context?: {
+            sessionHistory?: Array<{
+                content?: string;
+            }>;
+            language?: string;
+            intent?: string;
+        };
+    }): Promise<{
+        items?: unknown[];
+    }>;
+}
+export declare class PrimeSearchPipeline {
+    #private;
+    constructor(searchEngine: SearchEngineLike);
+    /**
+     * Core method: multi-query search + scenario routing + result merging.
+     */
+    search(intent: ExtractedIntent): Promise<PrimeSearchResult | null>;
+    /**
+     * Reset session history (called on new session start).
+     */
+    resetSession(): void;
+}

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

@@ -0,0 +1,98 @@
+/**
+ * PrimeSearchPipeline — Enrichment Layer
+ *
+ * Multi-query parallel search + scenario routing + session history accumulation.
+ * Replaces TaskKnowledgeBridge with full search pipeline integration.
+ *
+ * @module service/task/PrimeSearchPipeline
+ */
+import { slimSearchResult } from '#service/search/SearchTypes.js';
+// ── Constants ───────────────────────────────────────
+const RELEVANCE_THRESHOLD = 0.44;
+// ── PrimeSearchPipeline ─────────────────────────────
+export class PrimeSearchPipeline {
+    #search;
+    #sessionQueries = [];
+    constructor(searchEngine) {
+        this.#search = searchEngine;
+    }
+    /**
+     * Core method: multi-query search + scenario routing + result merging.
+     */
+    async search(intent) {
+        if (!intent.queries.length || !intent.queries[0]?.trim()) {
+            return null;
+        }
+        // Build ranking context
+        const context = {
+            language: intent.language ?? undefined,
+            intent: intent.scenario,
+            sessionHistory: this.#buildSessionHistory(),
+        };
+        // Multi-query parallel search
+        const allResults = await this.#multiQuerySearch(intent.queries, context);
+        // Threshold filter
+        const filtered = allResults.filter((r) => (r.score ?? 0) >= RELEVANCE_THRESHOLD);
+        if (filtered.length === 0) {
+            return null;
+        }
+        // Classify: knowledge vs rules
+        const knowledge = filtered.filter((r) => r.kind !== 'rule').slice(0, 5);
+        const rules = filtered.filter((r) => r.kind === 'rule').slice(0, 3);
+        // Record search to session history
+        this.#sessionQueries.push(intent.raw.userQuery);
+        return {
+            relatedKnowledge: knowledge,
+            guardRules: rules,
+            searchMeta: {
+                queries: intent.queries,
+                scenario: intent.scenario,
+                language: intent.language,
+                module: intent.module,
+                resultCount: allResults.length,
+                filteredCount: filtered.length,
+            },
+        };
+    }
+    /**
+     * Reset session history (called on new session start).
+     */
+    resetSession() {
+        this.#sessionQueries = [];
+    }
+    // ── Private ───────────────────────────────────────
+    /**
+     * Multi-query parallel search + de-dup by ID (keep highest score).
+     */
+    async #multiQuerySearch(queries, context) {
+        const promises = queries.map((q) => this.#search
+            .search(q, {
+            mode: 'auto',
+            limit: 8,
+            rank: true,
+            context,
+        })
+            .catch(() => ({ items: [] })));
+        const responses = await Promise.all(promises);
+        // Merge by ID, keep highest score
+        const bestById = new Map();
+        for (const resp of responses) {
+            const items = resp.items || [];
+            for (const raw of items) {
+                const item = slimSearchResult(raw);
+                const existing = bestById.get(item.id);
+                if (!existing || item.score > existing.score) {
+                    bestById.set(item.id, item);
+                }
+            }
+        }
+        // Sort by score descending
+        return [...bestById.values()].sort((a, b) => b.score - a.score);
+    }
+    /**
+     * Build sessionHistory for contextBoost (last 5 queries).
+     */
+    #buildSessionHistory() {
+        return this.#sessionQueries.slice(-5).map((q) => ({ content: q }));
+    }
+}