openclaw-cortex-memory 0.1.0-Alpha.2 → 0.1.0-Alpha.20

package/dist/src/store/read_store.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createReadStore = createReadStore;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const module_1 = require("module");
 function safeReadFile(filePath) {
     try {
         if (!fs.existsSync(filePath)) {
@@ -65,6 +66,55 @@ function scoreText(query, text) {
     }
     return score;
 }
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9\u4e00-\u9fa5]+/i)
+        .map(token => token.trim())
+        .filter(Boolean);
+}
+function buildBm25Stats(docs, queryTerms, getTokens) {
+    const docFreq = new Map();
+    let totalLen = 0;
+    for (const doc of docs) {
+        const tokens = typeof getTokens === "function" ? getTokens(doc) : tokenize(doc.text);
+        totalLen += tokens.length;
+        if (queryTerms.length === 0) {
+            continue;
+        }
+        const termSet = new Set(tokens);
+        for (const term of queryTerms) {
+            if (termSet.has(term)) {
+                docFreq.set(term, (docFreq.get(term) || 0) + 1);
+            }
+        }
+    }
+    const avgDocLen = docs.length > 0 ? Math.max(1, totalLen / docs.length) : 1;
+    return { avgDocLen, docFreq };
+}
+function bm25Score(args) {
+    const tokens = Array.isArray(args.docTokens) ? args.docTokens : tokenize(args.docText);
+    if (tokens.length === 0 || args.queryTerms.length === 0 || args.docCount <= 0) {
+        return 0;
+    }
+    const termFreq = new Map();
+    for (const token of tokens) {
+        termFreq.set(token, (termFreq.get(token) || 0) + 1);
+    }
+    const k1 = 1.2;
+    const b = 0.75;
+    let score = 0;
+    for (const term of args.queryTerms) {
+        const tf = termFreq.get(term) || 0;
+        if (tf <= 0)
+            continue;
+        const df = args.docFreq.get(term) || 0;
+        const idf = Math.log(1 + ((args.docCount - df + 0.5) / (df + 0.5)));
+        const denominator = tf + k1 * (1 - b + b * (tokens.length / Math.max(1, args.avgDocLen)));
+        score += idf * (((k1 + 1) * tf) / Math.max(1e-6, denominator));
+    }
+    return score;
+}
 function normalizeRecordText(record) {
     const direct = [record.content, record.summary, record.text, record.message]
         .find(v => typeof v === "string" && v.trim());
@@ -114,11 +164,46 @@ function parseJsonlFile(filePath, sourceLabel, logger) {
             }
             const id = typeof parsed.id === "string" ? parsed.id : `${sourceLabel}:${docs.length + 1}`;
             const timestampValue = typeof parsed.timestamp === "string" ? Date.parse(parsed.timestamp) : NaN;
+            const entities = Array.isArray(parsed.entities)
+                ? parsed.entities.map(item => (typeof item === "string" ? item.trim() : "")).filter(Boolean)
+                : [];
+            const relations = Array.isArray(parsed.relations)
+                ? parsed.relations
+                    .map(item => {
+                    if (typeof item !== "object" || item === null)
+                        return null;
+                    const relation = item;
+                    const source = typeof relation.source === "string" ? relation.source.trim() : "";
+                    const target = typeof relation.target === "string" ? relation.target.trim() : "";
+                    const type = typeof relation.type === "string" ? relation.type.trim() : "related_to";
+                    if (!source || !target)
+                        return null;
+                    return { source, target, type };
+                })
+                    .filter((item) => Boolean(item))
+                : [];
             docs.push({
                 id,
                 text,
                 source: sourceLabel,
                 timestamp: Number.isFinite(timestampValue) ? timestampValue : undefined,
+                layer: parsed.layer === "active" || parsed.layer === "archive"
+                    ? parsed.layer
+                    : (sourceLabel === "sessions_active" ? "active" : (sourceLabel === "sessions_archive" ? "archive" : undefined)),
+                sourceMemoryId: typeof parsed.source_memory_id === "string"
+                    ? parsed.source_memory_id
+                    : id,
+                sourceMemoryCanonicalId: typeof parsed.source_memory_canonical_id === "string"
+                    ? parsed.source_memory_canonical_id
+                    : (typeof parsed.canonical_id === "string" ? parsed.canonical_id : undefined),
+                embedding: Array.isArray(parsed.embedding) ? parsed.embedding.filter(item => Number.isFinite(item)) : undefined,
+                eventType: typeof parsed.event_type === "string" ? parsed.event_type.trim() : undefined,
+                qualityScore: typeof parsed.quality_score === "number" ? parsed.quality_score : undefined,
+                charCount: typeof parsed.char_count === "number" ? parsed.char_count : undefined,
+                tokenCount: typeof parsed.token_count === "number" ? parsed.token_count : undefined,
+                sessionId: typeof parsed.session_id === "string" ? parsed.session_id : undefined,
+                entities,
+                relations,
             });
         }
         catch (error) {
@@ -160,19 +245,647 @@ function withRecencyBoost(score, timestamp) {
     }
     return score;
 }
+function recencyScore(timestamp) {
+    if (!timestamp) {
+        return 0;
+    }
+    const ageHours = (Date.now() - timestamp) / (1000 * 60 * 60);
+    if (ageHours < 12)
+        return 1;
+    if (ageHours < 24)
+        return 0.8;
+    if (ageHours < 72)
+        return 0.6;
+    if (ageHours < 168)
+        return 0.4;
+    if (ageHours < 720)
+        return 0.2;
+    return 0.05;
+}
+function eventTypeHalfLifeDays(eventType, options) {
+    const fallback = typeof options?.defaultHalfLifeDays === "number" && options.defaultHalfLifeDays > 0
+        ? options.defaultHalfLifeDays
+        : 90;
+    const type = (eventType || "").trim().toLowerCase();
+    if (!type)
+        return fallback;
+    const configured = options?.halfLifeByEventType || {};
+    if (typeof configured[type] === "number" && configured[type] > 0) {
+        return configured[type];
+    }
+    if (["issue", "fix", "action_item", "blocker"].includes(type))
+        return 30;
+    if (["plan", "milestone", "follow_up"].includes(type))
+        return 60;
+    if (["decision", "insight", "retrospective"].includes(type))
+        return 120;
+    if (["preference", "constraint", "requirement", "dependency", "assumption"].includes(type))
+        return 240;
+    return fallback;
+}
+function computeAntiDecayBoost(id, hitStats, options) {
+    const anti = options?.antiDecay;
+    if (anti?.enabled === false) {
+        return 1;
+    }
+    const item = hitStats.items[id];
+    if (!item) {
+        return 1;
+    }
+    const hitWeight = typeof anti?.hitWeight === "number" && anti.hitWeight > 0 ? anti.hitWeight : 0.08;
+    const maxBoost = typeof anti?.maxBoost === "number" && anti.maxBoost >= 1 ? anti.maxBoost : 1.6;
+    const recentWindowDays = typeof anti?.recentWindowDays === "number" && anti.recentWindowDays > 0 ? anti.recentWindowDays : 30;
+    const lastHitTs = Date.parse(item.lastHitAt || "");
+    const ageDays = Number.isFinite(lastHitTs) ? Math.max(0, (Date.now() - lastHitTs) / (1000 * 60 * 60 * 24)) : recentWindowDays * 2;
+    const freshness = ageDays <= recentWindowDays ? (1 - ageDays / recentWindowDays) : 0;
+    const countFactor = Math.log1p(Math.max(0, item.count));
+    const boost = 1 + countFactor * hitWeight * (0.5 + 0.5 * freshness);
+    return Math.min(maxBoost, Math.max(1, boost));
+}
+function computeDecayFactor(id, eventType, timestamp, options, hitStats) {
+    const enabled = options?.enabled !== false;
+    if (!enabled || !timestamp) {
+        return computeAntiDecayBoost(id, hitStats, options);
+    }
+    const ageDays = Math.max(0, (Date.now() - timestamp) / (1000 * 60 * 60 * 24));
+    const halfLife = eventTypeHalfLifeDays(eventType, options);
+    const base = Math.pow(2, -ageDays / Math.max(1, halfLife));
+    const floor = typeof options?.minFloor === "number"
+        ? Math.max(0, Math.min(1, options.minFloor))
+        : 0.15;
+    const decay = Math.max(floor, base);
+    const boost = computeAntiDecayBoost(id, hitStats, options);
+    return Math.min(1, decay * boost);
+}
+function normalizeBaseUrl(value) {
+    if (!value)
+        return "";
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+const READ_FUSION_PROMPT_VERSION = "read-fusion.v1.1.0";
+const READ_FUSION_REGRESSION_SAMPLES = [
+    "样例A: 同一 source_memory_id 同时出现在 archive 与 vector，输出中只保留一条主事实并在证据链保留两者关联。",
+    "样例B: 新旧决策冲突时，将冲突写入 conflicts，并在 canonical_answer 标注优先级依据（时间、质量、明确性）。",
+];
+function cosineSimilarity(left, right) {
+    if (left.length === 0 || right.length === 0) {
+        return 0;
+    }
+    const size = Math.min(left.length, right.length);
+    let dot = 0;
+    let leftNorm = 0;
+    let rightNorm = 0;
+    for (let i = 0; i < size; i += 1) {
+        const a = left[i];
+        const b = right[i];
+        dot += a * b;
+        leftNorm += a * a;
+        rightNorm += b * b;
+    }
+    if (leftNorm === 0 || rightNorm === 0) {
+        return 0;
+    }
+    return dot / (Math.sqrt(leftNorm) * Math.sqrt(rightNorm));
+}
+async function requestEmbedding(args) {
+    const endpoint = args.baseUrl.endsWith("/embeddings") ? args.baseUrl : `${args.baseUrl}/embeddings`;
+    const body = {
+        input: args.text,
+        model: args.model,
+    };
+    if (typeof args.dimensions === "number" && Number.isFinite(args.dimensions) && args.dimensions > 0) {
+        body.dimensions = args.dimensions;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${args.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                lastError = new Error(`embedding_http_${response.status}`);
+                continue;
+            }
+            const json = await response.json();
+            const embedding = json?.data?.[0]?.embedding;
+            if (Array.isArray(embedding) && embedding.length > 0) {
+                return embedding.filter(item => Number.isFinite(item));
+            }
+            lastError = new Error("embedding_empty");
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            lastError = error;
+        }
+    }
+    if (lastError) {
+        throw lastError;
+    }
+    return null;
+}
+async function requestRerank(args) {
+    const endpoint = args.baseUrl.endsWith("/rerank") ? args.baseUrl : `${args.baseUrl}/rerank`;
+    const documents = args.candidates.map(item => item.text);
+    const body = {
+        model: args.model,
+        query: args.query,
+        documents,
+        top_n: args.candidates.length,
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 12000);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${args.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                lastError = new Error(`rerank_http_${response.status}`);
+                continue;
+            }
+            const json = await response.json();
+            const list = Array.isArray(json.results) ? json.results : (Array.isArray(json.data) ? json.data : []);
+            if (!Array.isArray(list) || list.length === 0) {
+                lastError = new Error("rerank_empty");
+                continue;
+            }
+            const mapped = list
+                .map((item, rank) => {
+                const index = typeof item.index === "number" ? item.index : rank;
+                const hit = args.candidates[index];
+                if (!hit)
+                    return null;
+                const score = typeof item.relevance_score === "number" ? item.relevance_score : (typeof item.score === "number" ? item.score : hit.score);
+                return { ...hit, score };
+            })
+                .filter((item) => Boolean(item));
+            if (mapped.length > 0) {
+                return mapped;
+            }
+            lastError = new Error("rerank_map_empty");
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError || "rerank_failed"));
+}
+function classifyIntent(query) {
+    const text = query.toLowerCase();
+    const relationHints = /(关系|依赖|关联|上下游|graph|relation|entity|拓扑)/i;
+    if (relationHints.test(text))
+        return "RELATION_DISCOVERY";
+    const troubleHints = /(报错|错误|异常|失败|超时|无法|崩溃|error|failed|timeout|fix)/i;
+    if (troubleHints.test(text))
+        return "TROUBLESHOOTING";
+    const preferenceHints = /(偏好|习惯|口味|喜欢|不喜欢|偏向|preference)/i;
+    if (preferenceHints.test(text))
+        return "PREFERENCE_PROFILE";
+    const timelineHints = /(最近|上次|之前|时间线|timeline|history)/i;
+    if (timelineHints.test(text))
+        return "TIMELINE_REVIEW";
+    const decisionHints = /(方案|决策|选择|建议|取舍|tradeoff|plan)/i;
+    if (decisionHints.test(text))
+        return "DECISION_SUPPORT";
+    return "FACT_LOOKUP";
+}
+function preferredEventTypes(intent) {
+    if (intent === "TROUBLESHOOTING")
+        return ["issue", "fix", "risk", "blocker", "dependency", "retrospective"];
+    if (intent === "PREFERENCE_PROFILE")
+        return ["preference", "decision", "constraint", "requirement"];
+    if (intent === "DECISION_SUPPORT")
+        return ["decision", "plan", "insight", "assumption", "constraint", "requirement"];
+    if (intent === "TIMELINE_REVIEW")
+        return ["action_item", "follow_up", "milestone", "plan", "decision", "issue", "fix"];
+    return [];
+}
+function sourceWeight(source, intent) {
+    if (source === "rules") {
+        return intent === "DECISION_SUPPORT" || intent === "TROUBLESHOOTING" ? 1.15 : 0.9;
+    }
+    if (source === "graph") {
+        return intent === "RELATION_DISCOVERY" ? 1.25 : 0.85;
+    }
+    if (source === "vector") {
+        return 1.05;
+    }
+    return 1;
+}
+function mergeKeyFromDoc(doc) {
+    const canonical = typeof doc.sourceMemoryCanonicalId === "string" ? doc.sourceMemoryCanonicalId.trim() : "";
+    if (canonical) {
+        return `canonical:${canonical}`;
+    }
+    const sourceMemoryId = typeof doc.sourceMemoryId === "string" ? doc.sourceMemoryId.trim() : "";
+    if (sourceMemoryId) {
+        return `source:${sourceMemoryId}`;
+    }
+    return `id:${doc.id}`;
+}
+function customChannelWeight(source, options) {
+    const weights = options?.channelWeights;
+    if (!weights)
+        return 1;
+    const value = weights[source];
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return 1;
+    }
+    return value;
+}
+function lengthNormalizeFactor(doc, options) {
+    const lengthNorm = options?.lengthNorm;
+    if (lengthNorm?.enabled === false) {
+        return 1;
+    }
+    const pivotChars = typeof lengthNorm?.pivotChars === "number" && lengthNorm.pivotChars > 0
+        ? lengthNorm.pivotChars
+        : 1200;
+    const strength = typeof lengthNorm?.strength === "number" && lengthNorm.strength > 0
+        ? lengthNorm.strength
+        : 0.75;
+    const minFactor = typeof lengthNorm?.minFactor === "number" && lengthNorm.minFactor > 0 && lengthNorm.minFactor <= 1
+        ? lengthNorm.minFactor
+        : 0.45;
+    const charCount = typeof doc.charCount === "number" && Number.isFinite(doc.charCount)
+        ? doc.charCount
+        : doc.text.length;
+    if (charCount <= pivotChars) {
+        return 1;
+    }
+    const over = (charCount - pivotChars) / pivotChars;
+    const factor = 1 / (1 + over * strength);
+    return Math.max(minFactor, Math.min(1, factor));
+}
+function channelQuota(source, topK, options) {
+    const configured = options?.channelTopK?.[source];
+    if (typeof configured === "number" && Number.isFinite(configured) && configured >= 1) {
+        return Math.floor(configured);
+    }
+    if (source === "rules")
+        return Math.max(6, topK * 2);
+    if (source === "graph")
+        return Math.max(8, topK * 3);
+    return Math.max(12, topK * 4);
+}
+async function searchLanceDb(args) {
+    try {
+        const require = (0, module_1.createRequire)(__filename);
+        const lancedbDir = path.join(args.memoryRoot, "vector", "lancedb");
+        if (!fs.existsSync(lancedbDir)) {
+            return [];
+        }
+        const moduleValue = require("@lancedb/lancedb");
+        const connect = moduleValue.connect;
+        if (typeof connect !== "function") {
+            return [];
+        }
+        const db = await connect(lancedbDir);
+        if (!db || typeof db.openTable !== "function") {
+            return [];
+        }
+        const table = await db.openTable("events");
+        if (!table || typeof table.search !== "function") {
+            return [];
+        }
+        const searchObj = table.search(args.queryEmbedding);
+        if (!searchObj || typeof searchObj.limit !== "function") {
+            return [];
+        }
+        const limited = searchObj.limit(args.limit);
+        if (!limited || typeof limited.toArray !== "function") {
+            return [];
+        }
+        const rows = await limited.toArray();
+        const docs = [];
+        for (const row of rows) {
+            if (typeof row !== "object" || row === null)
+                continue;
+            const record = row;
+            const id = typeof record.id === "string" ? record.id : "";
+            const summary = typeof record.summary === "string" ? record.summary : "";
+            if (!id || !summary)
+                continue;
+            const ts = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : NaN;
+            const entities = typeof record.entities_json === "string"
+                ? JSON.parse(record.entities_json).filter(item => typeof item === "string" && item.trim())
+                : [];
+            const relations = typeof record.relations_json === "string"
+                ? JSON.parse(record.relations_json)
+                : [];
+            docs.push({
+                id,
+                text: summary,
+                source: "vector_lancedb",
+                timestamp: Number.isFinite(ts) ? ts : undefined,
+                layer: record.layer === "active" || record.layer === "archive" ? record.layer : undefined,
+                sourceMemoryId: typeof record.source_memory_id === "string" ? record.source_memory_id : undefined,
+                sourceMemoryCanonicalId: typeof record.source_memory_canonical_id === "string" ? record.source_memory_canonical_id : undefined,
+                embedding: Array.isArray(record.vector) ? record.vector.filter(item => Number.isFinite(item)) : undefined,
+                eventType: typeof record.event_type === "string" ? record.event_type : undefined,
+                qualityScore: typeof record.quality_score === "number" ? record.quality_score : undefined,
+                charCount: typeof record.char_count === "number" ? record.char_count : undefined,
+                tokenCount: typeof record.token_count === "number" ? record.token_count : undefined,
+                sessionId: typeof record.session_id === "string" ? record.session_id : undefined,
+                entities,
+                relations: Array.isArray(relations) ? relations : [],
+            });
+        }
+        return docs;
+    }
+    catch (error) {
+        args.logger.debug(`LanceDB search fallback: ${error}`);
+        return [];
+    }
+}
+function parseVectorFallback(filePath, logger) {
+    const content = safeReadFile(filePath);
+    if (!content) {
+        return [];
+    }
+    const docs = [];
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const id = typeof parsed.id === "string" ? parsed.id : "";
+            const summary = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
+            if (!id || !summary)
+                continue;
+            const ts = typeof parsed.timestamp === "string" ? Date.parse(parsed.timestamp) : NaN;
+            const entities = Array.isArray(parsed.entities)
+                ? parsed.entities.map(item => (typeof item === "string" ? item.trim() : "")).filter(Boolean)
+                : [];
+            const relations = Array.isArray(parsed.relations)
+                ? parsed.relations
+                    .map(item => {
+                    if (typeof item !== "object" || item === null)
+                        return null;
+                    const relation = item;
+                    const source = typeof relation.source === "string" ? relation.source.trim() : "";
+                    const target = typeof relation.target === "string" ? relation.target.trim() : "";
+                    const type = typeof relation.type === "string" ? relation.type.trim() : "related_to";
+                    if (!source || !target)
+                        return null;
+                    return { source, target, type };
+                })
+                    .filter((item) => Boolean(item))
+                : [];
+            docs.push({
+                id,
+                text: summary,
+                source: "vector_jsonl",
+                timestamp: Number.isFinite(ts) ? ts : undefined,
+                layer: parsed.layer === "active" || parsed.layer === "archive" ? parsed.layer : undefined,
+                sourceMemoryId: typeof parsed.source_memory_id === "string" ? parsed.source_memory_id : undefined,
+                sourceMemoryCanonicalId: typeof parsed.source_memory_canonical_id === "string" ? parsed.source_memory_canonical_id : undefined,
+                embedding: Array.isArray(parsed.embedding) ? parsed.embedding.filter(item => Number.isFinite(item)) : undefined,
+                eventType: typeof parsed.event_type === "string" ? parsed.event_type.trim() : undefined,
+                qualityScore: typeof parsed.quality_score === "number" ? parsed.quality_score : undefined,
+                charCount: typeof parsed.char_count === "number" ? parsed.char_count : undefined,
+                tokenCount: typeof parsed.token_count === "number" ? parsed.token_count : undefined,
+                sessionId: typeof parsed.session_id === "string" ? parsed.session_id : undefined,
+                entities,
+                relations,
+            });
+        }
+        catch (error) {
+            logger.debug(`Skip invalid vector jsonl line: ${error}`);
+        }
+    }
+    return docs;
+}
+async function requestFusion(args) {
+    const endpoint = args.llm.baseUrl.endsWith("/chat/completions")
+        ? args.llm.baseUrl
+        : `${args.llm.baseUrl}/chat/completions`;
+    const evidenceText = args.candidates
+        .map((item, index) => `${index + 1}. [${item.id}] (${item.source}, score=${item.score.toFixed(4)}) ${item.text}`)
+        .join("\n")
+        .slice(0, 18000);
+    const prompt = [
+        `prompt_version=${READ_FUSION_PROMPT_VERSION}`,
+        "你是记忆检索融合器。请融合多路召回结果，产出可直接给 Agent 使用的完整记忆包，不要让 Agent 再去翻历史。",
+        "必须严格返回 JSON：",
+        "{\"canonical_answer\": string, \"coverage_note\": string, \"facts\": [{\"text\": string, \"evidence_ids\": string[]}], \"timeline\": [{\"when\": string, \"event\": string, \"evidence_ids\": string[]}], \"entities\": [{\"name\": string, \"role\": string}], \"decisions\": [{\"decision\": string, \"rationale\": string, \"evidence_ids\": string[]}], \"fixes\": [{\"issue\": string, \"fix\": string, \"evidence_ids\": string[]}], \"preferences\": [{\"subject\": string, \"preference\": string, \"evidence_ids\": string[]}], \"risks\": [{\"risk\": string, \"mitigation\": string, \"evidence_ids\": string[]}], \"action_items\": [{\"item\": string, \"owner\": string, \"status\": string, \"evidence_ids\": string[]}], \"conflicts\": [{\"topic\": string, \"details\": string}], \"evidence_ids\": string[], \"confidence\": number}",
+        "要求：",
+        "1) canonical_answer 是完整可执行答案，不要只写摘要",
+        "2) facts 3-12 条，优先高分证据",
+        "3) evidence_ids 必须来自输入候选 id",
+        "4) 若存在冲突写入 conflicts，否则返回空数组",
+        "5) confidence 0~1",
+        "6) 不确定信息必须在 coverage_note 标注",
+        "7) 同源记录合并：同 source_memory_id/source_memory_canonical_id 的候选只保留一条主结论，其余作为证据补充",
+        ...READ_FUSION_REGRESSION_SAMPLES,
+    ].join("\n");
+    const body = {
+        model: args.llm.model,
+        temperature: 0.1,
+        messages: [
+            { role: "system", content: "你只输出 JSON，不要额外解释。" },
+            { role: "user", content: `${prompt}\n\n问题:\n${args.query}\n\n候选证据:\n${evidenceText}` },
+        ],
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 20000);
+        try {
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${args.llm.apiKey}`,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                lastError = new Error(`fusion_http_${response.status}`);
+                continue;
+            }
+            const json = await response.json();
+            const content = json?.choices?.[0]?.message?.content?.trim() || "";
+            if (!content) {
+                lastError = new Error("fusion_empty");
+                continue;
+            }
+            const parsed = JSON.parse(content);
+            if (!parsed || typeof parsed.canonical_answer !== "string" || !parsed.canonical_answer.trim()) {
+                lastError = new Error("fusion_invalid");
+                continue;
+            }
+            const evidenceIds = Array.isArray(parsed.evidence_ids)
+                ? parsed.evidence_ids.filter(item => typeof item === "string" && item.trim())
+                : [];
+            return {
+                canonical_answer: parsed.canonical_answer.trim().slice(0, 6000),
+                coverage_note: typeof parsed.coverage_note === "string" ? parsed.coverage_note.trim().slice(0, 1200) : "",
+                facts: Array.isArray(parsed.facts) ? parsed.facts : [],
+                timeline: Array.isArray(parsed.timeline) ? parsed.timeline : [],
+                entities: Array.isArray(parsed.entities) ? parsed.entities : [],
+                decisions: Array.isArray(parsed.decisions) ? parsed.decisions : [],
+                fixes: Array.isArray(parsed.fixes) ? parsed.fixes : [],
+                preferences: Array.isArray(parsed.preferences) ? parsed.preferences : [],
+                risks: Array.isArray(parsed.risks) ? parsed.risks : [],
+                action_items: Array.isArray(parsed.action_items) ? parsed.action_items : [],
+                conflicts: Array.isArray(parsed.conflicts) ? parsed.conflicts : [],
+                evidence_ids: evidenceIds,
+                confidence: typeof parsed.confidence === "number"
+                    ? Math.max(0, Math.min(1, parsed.confidence))
+                    : 0.5,
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            lastError = error;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError || "fusion_failed"));
+}
 function createReadStore(options) {
     const memoryRoot = options.dbPath ? path.resolve(options.dbPath) : path.join(options.projectRoot, "data", "memory");
+    const vectorFallbackPath = path.join(memoryRoot, "vector", "lancedb_events.jsonl");
+    const hitStatsPath = path.join(memoryRoot, ".read_hit_stats.json");
+    let docsCache = null;
+    let vectorFallbackCache = null;
+    let bm25TokenCacheSignature = "";
+    let bm25TokenCache = new Map();
+    function fileSignature(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return `${filePath}:missing`;
+            }
+            const stat = fs.statSync(filePath);
+            return `${filePath}:${stat.size}:${Math.floor(stat.mtimeMs)}`;
+        }
+        catch {
+            return `${filePath}:error`;
+        }
+    }
+    function loadHitStats() {
+        try {
+            if (!fs.existsSync(hitStatsPath)) {
+                return { items: {} };
+            }
+            const content = fs.readFileSync(hitStatsPath, "utf-8").trim();
+            if (!content) {
+                return { items: {} };
+            }
+            const parsed = JSON.parse(content);
+            if (!parsed || typeof parsed !== "object" || !parsed.items || typeof parsed.items !== "object") {
+                return { items: {} };
+            }
+            return parsed;
+        }
+        catch {
+            return { items: {} };
+        }
+    }
+    function saveHitStats(state) {
+        try {
+            const dir = path.dirname(hitStatsPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(hitStatsPath, JSON.stringify(state, null, 2), "utf-8");
+        }
+        catch (error) {
+            options.logger.warn(`Failed to persist read hit stats: ${error}`);
+        }
+    }
+    function markHit(ids) {
+        if (!ids.length) {
+            return;
+        }
+        const state = loadHitStats();
+        const now = new Date().toISOString();
+        for (const id of ids) {
+            const key = (id || "").trim();
+            if (!key)
+                continue;
+            const prev = state.items[key];
+            state.items[key] = {
+                count: (prev?.count || 0) + 1,
+                lastHitAt: now,
+            };
+        }
+        const entries = Object.entries(state.items)
+            .sort((a, b) => {
+            const ta = Date.parse(a[1].lastHitAt || "");
+            const tb = Date.parse(b[1].lastHitAt || "");
+            return (Number.isFinite(tb) ? tb : 0) - (Number.isFinite(ta) ? ta : 0);
+        })
+            .slice(0, 20000);
+        state.items = Object.fromEntries(entries);
+        saveHitStats(state);
+    }
     function loadAllDocuments() {
         const cortexRulesPath = path.join(memoryRoot, "CORTEX_RULES.md");
         const memoryMdPath = path.join(memoryRoot, "MEMORY.md");
         const activeSessionsPath = path.join(memoryRoot, "sessions", "active", "sessions.jsonl");
         const archiveSessionsPath = path.join(memoryRoot, "sessions", "archive", "sessions.jsonl");
-        return [
+        const signature = [
+            fileSignature(cortexRulesPath),
+            fileSignature(memoryMdPath),
+            fileSignature(activeSessionsPath),
+            fileSignature(archiveSessionsPath),
+        ].join("|");
+        if (docsCache && docsCache.signature === signature) {
+            return docsCache.docs;
+        }
+        const docs = [
             ...parseMarkdownFile(cortexRulesPath, "CORTEX_RULES.md"),
             ...parseMarkdownFile(memoryMdPath, "MEMORY.md"),
             ...parseJsonlFile(activeSessionsPath, "sessions_active", options.logger),
             ...parseJsonlFile(archiveSessionsPath, "sessions_archive", options.logger),
         ];
+        docsCache = { signature, docs };
+        return docs;
+    }
+    function loadVectorFallbackCached() {
+        const signature = fileSignature(vectorFallbackPath);
+        if (vectorFallbackCache && vectorFallbackCache.signature === signature) {
+            return vectorFallbackCache.docs;
+        }
+        const docs = parseVectorFallback(vectorFallbackPath, options.logger);
+        vectorFallbackCache = { signature, docs };
+        return docs;
+    }
+    function getBm25Tokens(doc, signature) {
+        if (bm25TokenCacheSignature !== signature) {
+            bm25TokenCacheSignature = signature;
+            bm25TokenCache = new Map();
+        }
+        const key = `${doc.source}|${doc.id}|${doc.text.length}|${doc.text.slice(0, 64)}`;
+        const cached = bm25TokenCache.get(key);
+        if (cached) {
+            return cached;
+        }
+        const tokens = tokenize(doc.text);
+        bm25TokenCache.set(key, tokens);
+        return tokens;
     }
     async function searchMemory(args) {
         const query = args.query?.trim();
@@ -180,36 +893,406 @@ function createReadStore(options) {
             return { results: [] };
         }
         const docs = loadAllDocuments();
-        const ranked = docs
+        const hitStats = loadHitStats();
+        const intent = classifyIntent(query);
+        const preferredTypes = preferredEventTypes(intent);
+        let queryEmbedding = null;
+        const embeddingModel = options.embedding?.model || "";
+        const embeddingApiKey = options.embedding?.apiKey || "";
+        const embeddingBaseUrl = normalizeBaseUrl(options.embedding?.baseURL || options.embedding?.baseUrl);
+        if (embeddingModel && embeddingApiKey && embeddingBaseUrl) {
+            try {
+                queryEmbedding = await requestEmbedding({
+                    text: query,
+                    model: embeddingModel,
+                    apiKey: embeddingApiKey,
+                    baseUrl: embeddingBaseUrl,
+                    dimensions: options.embedding?.dimensions,
+                });
+            }
+            catch (error) {
+                options.logger.warn(`Embedding query failed, fallback to lexical search: ${error}`);
+            }
+        }
+        const vectorDocsFromLance = queryEmbedding && queryEmbedding.length > 0
+            ? await searchLanceDb({ memoryRoot, queryEmbedding, limit: Math.max(20, args.topK * 8), logger: options.logger })
+            : [];
+        const vectorDocsFallback = vectorDocsFromLance.length > 0
+            ? []
+            : loadVectorFallbackCached();
+        const vectorDocs = [...vectorDocsFromLance, ...vectorDocsFallback];
+        const graphDocs = docs
+            .filter(doc => Array.isArray(doc.relations) && doc.relations.length > 0)
             .map(doc => {
-            const base = scoreText(query, doc.text);
-            const total = withRecencyBoost(base, doc.timestamp);
-            return { doc, score: total };
-        })
-            .filter(item => item.score > 0)
+            const graphText = [
+                doc.text,
+                ...(doc.relations || []).map(relation => `${relation.source} ${relation.type} ${relation.target}`),
+            ].join(" | ");
+            return {
+                ...doc,
+                text: graphText,
+            };
+        });
+        const rulesDocs = docs.filter(doc => doc.source === "CORTEX_RULES.md");
+        const archiveDocs = docs.filter(doc => doc.source.startsWith("sessions_"));
+        const bm25Terms = tokenize(query);
+        const bm25Corpus = [...rulesDocs, ...archiveDocs, ...vectorDocs, ...graphDocs];
+        const bm25Signature = `${docsCache?.signature || "na"}|vector:${vectorDocs.length}:${vectorDocs.slice(0, 40).map(item => `${item.id}:${item.text.length}`).join(",")}`;
+        const bm25Stats = buildBm25Stats(bm25Corpus, bm25Terms, doc => getBm25Tokens(doc, bm25Signature));
+        const combinedCandidates = [];
+        const channels = {
+            rules: [],
+            archive: [],
+            vector: [],
+            graph: [],
+        };
+        const evaluateDoc = (doc, source) => {
+            const lexical = scoreText(query, doc.text);
+            const bm25 = bm25Score({
+                queryTerms: bm25Terms,
+                docText: doc.text,
+                docTokens: getBm25Tokens(doc, bm25Signature),
+                docCount: bm25Corpus.length,
+                avgDocLen: bm25Stats.avgDocLen,
+                docFreq: bm25Stats.docFreq,
+            });
+            const lexicalCombined = lexical + bm25 * 2;
+            const semantic = queryEmbedding && Array.isArray(doc.embedding) && doc.embedding.length > 0
+                ? Math.max(0, cosineSimilarity(queryEmbedding, doc.embedding) * 5)
+                : 0;
+            if (lexicalCombined <= 0 && semantic <= 0) {
+                return null;
+            }
+            const recency = recencyScore(doc.timestamp);
+            const quality = typeof doc.qualityScore === "number" ? Math.max(0, Math.min(1, doc.qualityScore)) : 0.5;
+            const typeMatch = preferredTypes.length > 0 && doc.eventType
+                ? (preferredTypes.includes(doc.eventType) ? 1 : 0)
+                : 0.5;
+            const graphMatch = source === "graph" ? 1 : 0;
+            const sourceBaseWeight = sourceWeight(source, intent);
+            const sourceConfigWeight = customChannelWeight(source, options.fusion);
+            const lengthNorm = lengthNormalizeFactor(doc, options.fusion);
+            const baseWeighted = (0.2 * lexicalCombined +
+                0.3 * (semantic * lengthNorm) +
+                0.1 * recency +
+                0.15 * quality +
+                0.15 * typeMatch +
+                0.1 * graphMatch) * sourceBaseWeight * sourceConfigWeight;
+            const decayFactor = computeDecayFactor(doc.id, doc.eventType, doc.timestamp, options.memoryDecay, hitStats);
+            const weighted = baseWeighted * decayFactor;
+            return {
+                doc,
+                source,
+                lexical: lexicalCombined,
+                bm25,
+                semantic,
+                recency,
+                quality,
+                typeMatch,
+                graphMatch,
+                decayFactor,
+                weighted,
+            };
+        };
+        for (const doc of rulesDocs) {
+            const candidate = evaluateDoc(doc, "rules");
+            if (candidate)
+                channels.rules.push(candidate);
+        }
+        for (const doc of archiveDocs) {
+            const candidate = evaluateDoc(doc, "archive");
+            if (candidate)
+                channels.archive.push(candidate);
+        }
+        for (const doc of vectorDocs) {
+            const candidate = evaluateDoc(doc, "vector");
+            if (candidate)
+                channels.vector.push(candidate);
+        }
+        for (const doc of graphDocs) {
+            const candidate = evaluateDoc(doc, "graph");
+            if (candidate)
+                channels.graph.push(candidate);
+        }
+        for (const key of Object.keys(channels)) {
+            channels[key].sort((a, b) => b.weighted - a.weighted);
+            combinedCandidates.push(...channels[key].slice(0, channelQuota(key, args.topK, options.fusion)));
+        }
+        const rrfMap = new Map();
+        const weightedMap = new Map();
+        const rrfK = 60;
+        for (const key of Object.keys(channels)) {
+            const list = channels[key];
+            for (let i = 0; i < list.length; i += 1) {
+                const candidate = list[i];
+                const rrf = 1 / (rrfK + i + 1);
+                const mergeKey = mergeKeyFromDoc(candidate.doc);
+                rrfMap.set(mergeKey, (rrfMap.get(mergeKey) || 0) + rrf);
+                const current = weightedMap.get(mergeKey);
+                if (!current || candidate.weighted > current.weighted) {
+                    weightedMap.set(mergeKey, candidate);
+                }
+            }
+        }
+        const preRanked = [...weightedMap.entries()]
+            .map(([mergeKey, candidate]) => ({
+            id: candidate.doc.id,
+            merge_key: mergeKey,
+            source_memory_id: candidate.doc.sourceMemoryId || "",
+            source_memory_canonical_id: candidate.doc.sourceMemoryCanonicalId || "",
+            text: candidate.doc.text,
+            source: candidate.doc.source,
+            layer: candidate.doc.layer || "",
+            event_type: candidate.doc.eventType || "",
+            quality_score: candidate.quality,
+            timestamp: candidate.doc.timestamp ? new Date(candidate.doc.timestamp).toISOString() : "",
+            score: candidate.weighted + (rrfMap.get(mergeKey) || 0) * 1.5,
+            score_breakdown: {
+                lexical: Number(candidate.lexical.toFixed(4)),
+                bm25: Number(candidate.bm25.toFixed(4)),
+                semantic: Number(candidate.semantic.toFixed(4)),
+                recency: Number(candidate.recency.toFixed(4)),
+                quality: Number(candidate.quality.toFixed(4)),
+                type: Number(candidate.typeMatch.toFixed(4)),
+                graph: Number(candidate.graphMatch.toFixed(4)),
+                decay: Number(candidate.decayFactor.toFixed(4)),
+                rrf: Number(((rrfMap.get(mergeKey) || 0) * 1.5).toFixed(4)),
+                weighted: Number(candidate.weighted.toFixed(4)),
+            },
+            reason_tags: [
+                `intent:${intent.toLowerCase()}`,
+                candidate.semantic > 0 ? "vector_hit" : "lexical_hit",
+                candidate.typeMatch >= 1 ? "event_type_match" : "event_type_weak",
+                candidate.recency >= 0.8 ? "recent" : "historical",
+                candidate.quality >= 0.7 ? "high_quality" : "normal_quality",
+                candidate.decayFactor < 1 ? `decay:${candidate.decayFactor.toFixed(3)}` : "decay:1.000",
+                `source:${candidate.source}`,
+                `merge_key:${mergeKey}`,
+            ],
+        }))
             .sort((a, b) => b.score - a.score)
-            .slice(0, Math.max(1, args.topK))
-            .map(item => ({
-            id: item.doc.id,
-            text: item.doc.text,
-            source: item.doc.source,
-            score: Number(item.score.toFixed(4)),
+            .slice(0, Math.max(1, Math.max(args.topK, 20)));
+        const lexicalRanked = preRanked
+            .map(doc => {
+            const boost = withRecencyBoost(doc.score, doc.timestamp ? Date.parse(doc.timestamp) : undefined);
+            return { ...doc, score: Number(boost.toFixed(4)) };
+        });
+        const rerankerModel = options.reranker?.model || "";
+        const rerankerApiKey = options.reranker?.apiKey || "";
+        const rerankerBaseUrl = normalizeBaseUrl(options.reranker?.baseURL || options.reranker?.baseUrl);
+        const fusionEnabled = options.fusion?.enabled !== false;
+        const llmModel = options.llm?.model || "";
+        const llmApiKey = options.llm?.apiKey || "";
+        const llmBaseUrl = normalizeBaseUrl(options.llm?.baseURL || options.llm?.baseUrl);
+        const fusionAuthoritative = options.fusion?.authoritative !== false;
+        const skipRerankerForFusion = fusionEnabled && fusionAuthoritative && llmModel && llmApiKey && llmBaseUrl;
+        let rerankedSimple = lexicalRanked.map(item => ({
+            id: item.id,
+            merge_key: item.merge_key,
+            text: item.text,
+            source: item.source,
+            score: item.score,
         }));
-        return { results: ranked };
+        if (rerankerModel && rerankerApiKey && rerankerBaseUrl && lexicalRanked.length > 1 && !skipRerankerForFusion) {
+            try {
+                rerankedSimple = await requestRerank({
+                    query,
+                    candidates: lexicalRanked.map(item => ({ id: item.id, text: item.text, source: item.source, score: item.score })),
+                    model: rerankerModel,
+                    apiKey: rerankerApiKey,
+                    baseUrl: rerankerBaseUrl,
+                });
+                rerankedSimple = rerankedSimple.map(item => {
+                    const found = lexicalRanked.find(entry => entry.id === item.id);
+                    return { ...item, merge_key: found?.merge_key || item.id };
+                });
+            }
+            catch (error) {
+                options.logger.warn(`Reranker failed, keep hybrid ranking: ${error}`);
+            }
+        }
+        const ranked = rerankedSimple.slice(0, Math.max(1, args.topK)).map(item => {
+            const hit = lexicalRanked.find(entry => entry.id === item.id);
+            return {
+                id: item.id,
+                merge_key: hit?.merge_key || item.merge_key || item.id,
+                source_memory_id: hit?.source_memory_id || "",
+                source_memory_canonical_id: hit?.source_memory_canonical_id || "",
+                text: item.text,
+                source: item.source,
+                layer: hit?.layer || "",
+                event_type: hit?.event_type || "",
+                quality_score: hit?.quality_score ?? 0,
+                timestamp: hit?.timestamp || "",
+                score: Number(item.score.toFixed(4)),
+                score_breakdown: hit?.score_breakdown || {},
+                reason_tags: Array.isArray(hit?.reason_tags) ? hit?.reason_tags : [],
+                explain: {
+                    merge_key: hit?.merge_key || item.merge_key || item.id,
+                    source_memory_id: hit?.source_memory_id || "",
+                    source_memory_canonical_id: hit?.source_memory_canonical_id || "",
+                    channel: item.source,
+                    layer: hit?.layer || "",
+                    score_breakdown: hit?.score_breakdown || {},
+                    reason_tags: Array.isArray(hit?.reason_tags) ? hit?.reason_tags : [],
+                },
+            };
+        });
+        const minLexicalHits = Math.max(0, Math.floor(options.fusion?.minLexicalHits ?? 1));
+        const minSemanticHits = Math.max(0, Math.floor(options.fusion?.minSemanticHits ?? 1));
+        const fallbackPool = lexicalRanked.filter(item => !ranked.some(existing => existing.id === item.id));
+        const lexicalCount = ranked.filter(item => item.reason_tags.includes("lexical_hit")).length;
+        const semanticCount = ranked.filter(item => item.reason_tags.includes("vector_hit")).length;
+        if (semanticCount < minSemanticHits) {
+            const needed = minSemanticHits - semanticCount;
+            const supplement = fallbackPool.filter(item => item.reason_tags.includes("vector_hit")).slice(0, needed);
+            for (const item of supplement) {
+                ranked.push({
+                    id: item.id,
+                    merge_key: item.merge_key,
+                    source_memory_id: item.source_memory_id,
+                    source_memory_canonical_id: item.source_memory_canonical_id,
+                    text: item.text,
+                    source: item.source,
+                    layer: item.layer,
+                    event_type: item.event_type,
+                    quality_score: item.quality_score,
+                    timestamp: item.timestamp,
+                    score: Number(item.score.toFixed(4)),
+                    score_breakdown: item.score_breakdown || {},
+                    reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
+                    explain: {
+                        merge_key: item.merge_key,
+                        source_memory_id: item.source_memory_id,
+                        source_memory_canonical_id: item.source_memory_canonical_id,
+                        channel: item.source,
+                        layer: item.layer,
+                        score_breakdown: item.score_breakdown || {},
+                        reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
+                    },
+                });
+            }
+        }
+        if (lexicalCount < minLexicalHits) {
+            const needed = minLexicalHits - lexicalCount;
+            const supplement = fallbackPool.filter(item => item.reason_tags.includes("lexical_hit")).slice(0, needed);
+            for (const item of supplement) {
+                if (ranked.some(existing => existing.id === item.id)) {
+                    continue;
+                }
+                ranked.push({
+                    id: item.id,
+                    merge_key: item.merge_key,
+                    source_memory_id: item.source_memory_id,
+                    source_memory_canonical_id: item.source_memory_canonical_id,
+                    text: item.text,
+                    source: item.source,
+                    layer: item.layer,
+                    event_type: item.event_type,
+                    quality_score: item.quality_score,
+                    timestamp: item.timestamp,
+                    score: Number(item.score.toFixed(4)),
+                    score_breakdown: item.score_breakdown || {},
+                    reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
+                    explain: {
+                        merge_key: item.merge_key,
+                        source_memory_id: item.source_memory_id,
+                        source_memory_canonical_id: item.source_memory_canonical_id,
+                        channel: item.source,
+                        layer: item.layer,
+                        score_breakdown: item.score_breakdown || {},
+                        reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
+                    },
+                });
+            }
+        }
+        ranked.sort((a, b) => b.score - a.score);
+        if (fusionEnabled && llmModel && llmApiKey && llmBaseUrl && ranked.length > 1) {
+            try {
+                const maxCandidates = Math.max(4, Math.min(20, options.fusion?.maxCandidates ?? 10));
+                const fusion = await requestFusion({
+                    query,
+                    candidates: ranked.slice(0, maxCandidates).map(item => ({
+                        id: item.id,
+                        text: item.text,
+                        source: item.source,
+                        event_type: item.event_type,
+                        quality_score: item.quality_score,
+                        timestamp: item.timestamp,
+                        score: item.score,
+                        reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
+                    })),
+                    llm: {
+                        model: llmModel,
+                        apiKey: llmApiKey,
+                        baseUrl: llmBaseUrl,
+                    },
+                });
+                if (fusion && fusion.canonical_answer) {
+                    const fusedItem = {
+                        id: `fusion_${Date.now().toString(36)}`,
+                        text: fusion.canonical_answer,
+                        source: "llm_fusion",
+                        event_type: "fusion",
+                        quality_score: Number(fusion.confidence.toFixed(4)),
+                        timestamp: new Date().toISOString(),
+                        score: Number((Math.max(...ranked.map(item => item.score)) + 1).toFixed(4)),
+                        reason_tags: ["llm_fused_authoritative", `evidence:${fusion.evidence_ids.length}`],
+                        explain: {
+                            channel: "llm_fusion",
+                            fused_from: ranked.slice(0, maxCandidates).map(item => item.id),
+                            reason_tags: ["llm_fused_authoritative", `evidence:${fusion.evidence_ids.length}`],
+                        },
+                        fused_coverage_note: fusion.coverage_note || "",
+                        fused_facts: fusion.facts,
+                        fused_timeline: fusion.timeline || [],
+                        fused_entities: fusion.entities || [],
+                        fused_decisions: fusion.decisions || [],
+                        fused_fixes: fusion.fixes || [],
+                        fused_preferences: fusion.preferences || [],
+                        fused_risks: fusion.risks || [],
+                        fused_action_items: fusion.action_items || [],
+                        fused_conflicts: fusion.conflicts,
+                        fused_evidence_ids: fusion.evidence_ids,
+                    };
+                    const authoritative = options.fusion?.authoritative !== false;
+                    if (authoritative) {
+                        markHit(Array.isArray(fusion.evidence_ids) ? fusion.evidence_ids : []);
+                        return { results: [fusedItem] };
+                    }
+                    const merged = [fusedItem, ...ranked];
+                    markHit([
+                        ...(Array.isArray(fusion.evidence_ids) ? fusion.evidence_ids : []),
+                        ...ranked.map(item => item.id),
+                    ]);
+                    return { results: merged.slice(0, Math.max(1, args.topK)) };
+                }
+            }
+            catch (error) {
+                options.logger.warn(`LLM fusion failed, fallback to reranked results: ${error}`);
+            }
+        }
+        const finalRanked = ranked.slice(0, Math.max(1, args.topK));
+        markHit(finalRanked.map(item => item.id));
+        return { results: finalRanked };
     }
     async function getHotContext(args) {
         const limit = Math.max(1, args.limit);
         const docs = loadAllDocuments();
         const coreRules = docs.find(doc => doc.source === "CORTEX_RULES.md");
-        const sessionDocs = docs
-            .filter(doc => doc.source.startsWith("sessions_"))
+        const archiveDocs = docs
+            .filter(doc => doc.source === "sessions_archive")
             .sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0))
             .slice(0, limit);
+        const issueFixPairs = docs
+            .filter(doc => doc.source === "sessions_archive" && (doc.eventType === "issue" || doc.eventType === "fix"))
+            .sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0))
+            .slice(0, 2);
         const result = [];
         if (coreRules) {
             result.push({ id: coreRules.id, text: coreRules.text, source: coreRules.source });
         }
-        for (const doc of sessionDocs) {
+        for (const doc of [...issueFixPairs, ...archiveDocs]) {
             result.push({ id: doc.id, text: doc.text, source: doc.source });
         }
         return { context: result.slice(0, limit) };
@@ -223,6 +1306,20 @@ function createReadStore(options) {
                 age_seconds: args.cachedAutoSearch.ageSeconds,
             };
         }
+        if (!result.auto_search) {
+            const docs = loadAllDocuments()
+                .filter(doc => doc.source === "sessions_archive" && doc.sessionId === args.sessionId)
+                .sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
+            const latest = docs[0];
+            if (latest && latest.text.trim()) {
+                const light = await searchMemory({ query: latest.text.slice(0, 80), topK: 3 });
+                result.auto_search = {
+                    query: latest.text.slice(0, 80),
+                    results: light.results,
+                    age_seconds: 0,
+                };
+            }
+        }
         if (args.includeHot) {
             const hot = await getHotContext({ limit: 20 });
             result.hot_context = hot.context;