// Story Summary - Recall Engine
// L1 chunk + L2 event 召回
// - 全量向量打分
// - 指数衰减加权 Query Embedding
// - 实体/参与者加分
// - MMR 去重
// - floor 稀疏去重

import { getAllEventVectors, getAllChunkVectors, getChunksByFloors, getMeta } from './chunk-store.js';
import { embed, getEngineFingerprint } from './embedder.js';
import { xbLog } from '../../../core/debug-core.js';
import { getContext } from '../../../../../../extensions.js';
import { getSummaryStore } from '../data/store.js';
import { filterText } from './text-filter.js';
import {
    searchStateAtoms,
    buildL0FloorBonus,
    stateToVirtualChunks,
    mergeAndSparsify,
} from './state-recall.js';

const MODULE_ID = 'recall';

const CONFIG = {
    QUERY_MSG_COUNT: 5,
    QUERY_DECAY_BETA: 0.7,
    QUERY_MAX_CHARS: 600,
    QUERY_CONTEXT_CHARS: 240,

    // 因果链
    CAUSAL_CHAIN_MAX_DEPTH: 10,  // 放宽跳数，让图自然终止
    CAUSAL_INJECT_MAX: 30,       // 放宽上限，由 prompt token 预算最终控制

    CANDIDATE_CHUNKS: 200,
    CANDIDATE_EVENTS: 150,

    MAX_CHUNKS: 40,
    MAX_EVENTS: 120,

    MIN_SIMILARITY_CHUNK: 0.6,
    MIN_SIMILARITY_EVENT: 0.65,
    MMR_LAMBDA: 0.72,

    BONUS_PARTICIPANT_HIT: 0.08,
    BONUS_TEXT_HIT: 0.05,
    BONUS_WORLD_TOPIC_HIT: 0.06,

    // L0 配置
    L0_FLOOR_BONUS_FACTOR: 0.10,
    FLOOR_MAX_CHUNKS: 2,

    FLOOR_LIMIT: 1,
};

// ═══════════════════════════════════════════════════════════════════════════
// 工具函数
// ═══════════════════════════════════════════════════════════════════════════

function cosineSimilarity(a, b) {
    if (!a?.length || !b?.length || a.length !== b.length) return 0;
    let dot = 0, nA = 0, nB = 0;
    for (let i = 0; i < a.length; i++) {
        dot += a[i] * b[i];
        nA += a[i] * a[i];
        nB += b[i] * b[i];
    }
    return nA && nB ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
}

function normalizeVec(v) {
    let s = 0;
    for (let i = 0; i < v.length; i++) s += v[i] * v[i];
    s = Math.sqrt(s) || 1;
    return v.map(x => x / s);
}

// ═══════════════════════════════════════════════════════════════════════════
// 因果链追溯（Graph-augmented retrieval）
// - 从已召回事件出发，沿 causedBy 向上追溯祖先事件
// - 记录边：chainFrom = 哪个召回事件需要它
// - 不在这里决定“是否额外注入”，只负责遍历与结构化结果
// ═══════════════════════════════════════════════════════════════════════════

function buildEventIndex(allEvents) {
    const map = new Map();
    for (const e of allEvents || []) {
        if (e?.id) map.set(e.id, e);
    }
    return map;
}

/**
 * @returns {Map<string, {event, depth, chainFrom}>}
 */
function traceCausalAncestors(recalledEvents, eventIndex, maxDepth = CONFIG.CAUSAL_CHAIN_MAX_DEPTH) {
    const out = new Map();
    const idRe = /^evt-\d+$/;

    function visit(parentId, depth, chainFrom) {
        if (depth > maxDepth) return;
        if (!idRe.test(parentId)) return;

        const ev = eventIndex.get(parentId);
        if (!ev) return;

        // 如果同一个祖先被多个召回事件引用：保留更“近”的深度或追加来源
        const existed = out.get(parentId);
        if (!existed) {
            out.set(parentId, { event: ev, depth, chainFrom: [chainFrom] });
        } else {
            if (depth < existed.depth) existed.depth = depth;
            if (!existed.chainFrom.includes(chainFrom)) existed.chainFrom.push(chainFrom);
        }

        for (const next of (ev.causedBy || [])) {
            visit(String(next || '').trim(), depth + 1, chainFrom);
        }
    }

    for (const r of recalledEvents || []) {
        const rid = r?.event?.id;
        if (!rid) continue;
        for (const cid of (r.event?.causedBy || [])) {
            visit(String(cid || '').trim(), 1, rid);
        }
    }

    return out;
}

/**
 * 因果事件排序：引用数 > 深度 > 编号
 */
function sortCausalEvents(causalArray) {
    return causalArray.sort((a, b) => {
        // 1. 被多条召回链引用的优先
        const refDiff = b.chainFrom.length - a.chainFrom.length;
        if (refDiff !== 0) return refDiff;

        // 2. 深度浅的优先
        const depthDiff = a.depth - b.depth;
        if (depthDiff !== 0) return depthDiff;

        // 3. 事件编号排序
        return String(a.event.id).localeCompare(String(b.event.id));
    });
}

function normalize(s) {
    return String(s || '').normalize('NFKC').replace(/[\u200B-\u200D\uFEFF]/g, '').trim();
}

// 从 summary 解析楼层范围：(#321-322) 或 (#321)
function parseFloorRange(summary) {
    if (!summary) return null;
    const match = String(summary).match(/\(#(\d+)(?:-(\d+))?\)/);
    if (!match) return null;
    const start = Math.max(0, parseInt(match[1], 10) - 1);
    const end = Math.max(0, (match[2] ? parseInt(match[2], 10) : parseInt(match[1], 10)) - 1);
    return { start, end };
}

function cleanForRecall(text) {
    // 1. 应用用户自定义过滤规则
    // 2. 移除 TTS 标记（硬编码）
    return filterText(text).replace(/\[tts:[^\]]*\]/gi, '').trim();
}

function buildExpDecayWeights(n, beta) {
    const last = n - 1;
    const w = Array.from({ length: n }, (_, i) => Math.exp(beta * (i - last)));
    const sum = w.reduce((a, b) => a + b, 0) || 1;
    return w.map(x => x / sum);
}

// ═══════════════════════════════════════════════════════════════════════════
// Query 构建
// ═══════════════════════════════════════════════════════════════════════════

function buildQuerySegments(chat, count, excludeLastAi, pendingUserMessage = null) {
    if (!chat?.length) return [];

    const { name1 } = getContext();

    let messages = chat;
    if (excludeLastAi && messages.length > 0 && !messages[messages.length - 1]?.is_user) {
        messages = messages.slice(0, -1);
    }

    // ★ 如果有待处理的用户消息且 chat 中最后一条不是它，追加虚拟消息
    if (pendingUserMessage) {
        const lastMsg = messages[messages.length - 1];
        const lastMsgText = lastMsg?.mes?.trim() || "";
        const pendingText = pendingUserMessage.trim();

        // 避免重复（如果 chat 已包含该消息则不追加）
        if (lastMsgText !== pendingText) {
            messages = [...messages, { is_user: true, name: name1 || "用户", mes: pendingUserMessage }];
        }
    }

    return messages.slice(-count).map((m, idx, arr) => {
        const speaker = m.name || (m.is_user ? (name1 || "用户") : "角色");
        const clean = cleanForRecall(m.mes);
        if (!clean) return '';
        const limit = idx === arr.length - 1 ? CONFIG.QUERY_MAX_CHARS : CONFIG.QUERY_CONTEXT_CHARS;
        return `${speaker}: ${clean.slice(0, limit)}`;
    }).filter(Boolean);
}

async function embedWeightedQuery(segments, vectorConfig) {
    if (!segments?.length) return null;

    const weights = buildExpDecayWeights(segments.length, CONFIG.QUERY_DECAY_BETA);
    const vecs = await embed(segments, vectorConfig);
    const dims = vecs?.[0]?.length || 0;
    if (!dims) return null;

    const out = new Array(dims).fill(0);
    for (let i = 0; i < vecs.length; i++) {
        for (let j = 0; j < dims; j++) out[j] += (vecs[i][j] || 0) * weights[i];
    }

    return { vector: normalizeVec(out), weights };
}

// ═══════════════════════════════════════════════════════════════════════════
// 实体抽取
// ═══════════════════════════════════════════════════════════════════════════

function buildEntityLexicon(store, allEvents) {
    const { name1 } = getContext();
    const userName = normalize(name1);
    const set = new Set();

    for (const e of allEvents || []) {
        for (const p of e.participants || []) {
            const s = normalize(p);
            if (s) set.add(s);
        }
    }

    const json = store?.json || {};

    for (const m of json.characters?.main || []) {
        const s = normalize(typeof m === 'string' ? m : m?.name);
        if (s) set.add(s);
    }

    for (const a of json.arcs || []) {
        const s = normalize(a?.name);
        if (s) set.add(s);
    }

    for (const w of json.world || []) {
        const t = normalize(w?.topic);
        if (t && !t.includes('::')) set.add(t);
    }

    for (const r of json.characters?.relationships || []) {
        const from = normalize(r?.from);
        const to = normalize(r?.to);
        if (from) set.add(from);
        if (to) set.add(to);
    }

    const stop = new Set([userName, '我', '你', '他', '她', '它', '用户', '角色', 'assistant'].map(normalize).filter(Boolean));

    return Array.from(set)
        .filter(s => s.length >= 2 && !stop.has(s) && !/^[\s\p{P}\p{S}]+$/u.test(s) && !/<[^>]+>/.test(s))
        .slice(0, 5000);
}

function extractEntities(text, lexicon) {
    const t = normalize(text);
    if (!t || !lexicon?.length) return [];

    const sorted = [...lexicon].sort((a, b) => b.length - a.length);
    const hits = [];
    for (const e of sorted) {
        if (t.includes(e)) hits.push(e);
        if (hits.length >= 20) break;
    }
    return hits;
}

// ═══════════════════════════════════════════════════════════════════════════
// MMR
// ═══════════════════════════════════════════════════════════════════════════

function mmrSelect(candidates, k, lambda, getVector, getScore) {
    const selected = [];
    const ids = new Set();

    while (selected.length < k && candidates.length) {
        let best = null, bestScore = -Infinity;

        for (const c of candidates) {
            if (ids.has(c._id)) continue;

            const rel = getScore(c);
            let div = 0;

            if (selected.length) {
                const vC = getVector(c);
                if (vC?.length) {
                    for (const s of selected) {
                        const sim = cosineSimilarity(vC, getVector(s));
                        if (sim > div) div = sim;
                    }
                }
            }

            const score = lambda * rel - (1 - lambda) * div;
            if (score > bestScore) {
                bestScore = score;
                best = c;
            }
        }

        if (!best) break;
        selected.push(best);
        ids.add(best._id);
    }

    return selected;
}

// ═══════════════════════════════════════════════════════════════════════════
// L1 Chunks 检索
// ═══════════════════════════════════════════════════════════════════════════

async function searchChunks(queryVector, vectorConfig, l0FloorBonus = new Map()) {
    const { chatId } = getContext();
    if (!chatId || !queryVector?.length) return [];

    const meta = await getMeta(chatId);
    const fp = getEngineFingerprint(vectorConfig);
    if (meta.fingerprint && meta.fingerprint !== fp) return [];

    const chunkVectors = await getAllChunkVectors(chatId);
    if (!chunkVectors.length) return [];

    const scored = chunkVectors.map(cv => {
        const match = String(cv.chunkId).match(/c-(\d+)-(\d+)/);
        const floor = match ? parseInt(match[1], 10) : 0;
        const baseSim = cosineSimilarity(queryVector, cv.vector);
        const l0Bonus = l0FloorBonus.get(floor) || 0;

        return {
            _id: cv.chunkId,
            chunkId: cv.chunkId,
            floor,
            chunkIdx: match ? parseInt(match[2], 10) : 0,
            similarity: baseSim + l0Bonus,
            _baseSimilarity: baseSim,
            _l0Bonus: l0Bonus,
            vector: cv.vector,
        };
    });

    // Pre-filter stats for logging
    const preFilterStats = {
        total: scored.length,
        passThreshold: scored.filter(s => s.similarity >= CONFIG.MIN_SIMILARITY_CHUNK).length,
        threshold: CONFIG.MIN_SIMILARITY_CHUNK,
        distribution: {
            '0.8+': scored.filter(s => s.similarity >= 0.8).length,
            '0.7-0.8': scored.filter(s => s.similarity >= 0.7 && s.similarity < 0.8).length,
            '0.6-0.7': scored.filter(s => s.similarity >= 0.6 && s.similarity < 0.7).length,
            '0.55-0.6': scored.filter(s => s.similarity >= 0.55 && s.similarity < 0.6).length,
            '<0.55': scored.filter(s => s.similarity < 0.55).length,
        },
    };

    const candidates = scored
        .filter(s => s.similarity >= CONFIG.MIN_SIMILARITY_CHUNK)
        .sort((a, b) => b.similarity - a.similarity)
        .slice(0, CONFIG.CANDIDATE_CHUNKS);

    // 动态 K：质量不够就少拿
    const dynamicK = Math.min(CONFIG.MAX_CHUNKS, candidates.length);

    const selected = mmrSelect(
        candidates,
        dynamicK,
        CONFIG.MMR_LAMBDA,
        c => c.vector,
        c => c.similarity
    );

    
// floor 稀疏去重：每个楼层只保留该楼层匹配度最高的那条
    const bestByFloor = new Map();
    for (const s of selected) {
        const prev = bestByFloor.get(s.floor);
        if (!prev || s.similarity > prev.similarity) {
            bestByFloor.set(s.floor, s);
        }
    }

    // 最终结果按匹配度降序
    const sparse = Array.from(bestByFloor.values()).sort((a, b) => b.similarity - a.similarity);

    const floors = [...new Set(sparse.map(c => c.floor))];
    const chunks = await getChunksByFloors(chatId, floors);
    const chunkMap = new Map(chunks.map(c => [c.chunkId, c]));

    const results = sparse.map(item => {
        const chunk = chunkMap.get(item.chunkId);
        if (!chunk) return null;
        return {
            chunkId: item.chunkId,
            floor: item.floor,
            chunkIdx: item.chunkIdx,
            speaker: chunk.speaker,
            isUser: chunk.isUser,
            text: chunk.text,
            similarity: item.similarity,
        };
    }).filter(Boolean);

    // Attach stats for logging
    if (results.length > 0) {
        results._preFilterStats = preFilterStats;
    }

    return results;
}

// ═══════════════════════════════════════════════════════════════════════════
// L2 Events 检索
// ═══════════════════════════════════════════════════════════════════════════

async function searchEvents(queryVector, allEvents, vectorConfig, store, queryEntities, l0FloorBonus = new Map()) {
    const { chatId, name1 } = getContext();
    if (!chatId || !queryVector?.length) {
        return [];
    }

    const meta = await getMeta(chatId);
    const fp = getEngineFingerprint(vectorConfig);
    if (meta.fingerprint && meta.fingerprint !== fp) return [];

    const eventVectors = await getAllEventVectors(chatId);
    const vectorMap = new Map(eventVectors.map(v => [v.eventId, v.vector]));
    if (!vectorMap.size) return [];

    const userName = normalize(name1);
    const queryNormList = (queryEntities || []).map(normalize).filter(Boolean);
    const querySet = new Set(queryNormList);

    // 只取硬约束类的 world topic
    const worldTopics = (store?.json?.world || [])
        .filter(w => ['inventory', 'rule', 'knowledge'].includes(String(w.category).toLowerCase()))
        .map(w => normalize(w.topic))
        .filter(Boolean);

    const scored = (allEvents || []).map((event, idx) => {
        const v = vectorMap.get(event.id);
        const sim = v ? cosineSimilarity(queryVector, v) : 0;

        let bonus = 0;
        const reasons = [];

        // participants 命中
        const participants = (event.participants || []).map(normalize).filter(Boolean);
        const hitCount = participants.filter(p => p !== userName && querySet.has(p)).length;
        const hasParticipantHit = hitCount > 0;
        if (hasParticipantHit) {
            bonus += CONFIG.BONUS_PARTICIPANT_HIT * Math.log2(hitCount + 1);
            reasons.push(hitCount > 1 ? `participant×${hitCount}` : 'participant');
        }

        // text 命中
        const text = normalize(`${event.title || ''} ${event.summary || ''}`);
        const textHitCount = queryNormList.filter(e => text.includes(e)).length;
        if (textHitCount > 0) {
            bonus += CONFIG.BONUS_TEXT_HIT * Math.log2(textHitCount + 1);
            reasons.push(textHitCount > 1 ? `text×${textHitCount}` : 'text');
        }

        // world topic 命中
        if (worldTopics.some(topic => querySet.has(topic) && text.includes(topic))) {
            bonus += CONFIG.BONUS_WORLD_TOPIC_HIT;
            reasons.push('world');
        }

        // L0 加权：事件覆盖楼层范围命中
        const range = parseFloorRange(event.summary);
        if (range) {
            for (let f = range.start; f <= range.end; f++) {
                if (l0FloorBonus.has(f)) {
                    bonus += l0FloorBonus.get(f);
                    reasons.push('L0');
                    break;
                }
            }
        }

        return {
            _id: event.id,
            _idx: idx,
            event,
            similarity: sim,
            bonus,
            finalScore: sim + bonus,
            reasons,
            isDirect: hasParticipantHit,
            vector: v,
        };
    });

    // ★ 记录过滤前的分布（用 finalScore，与显示一致）
    const preFilterDistribution = {
        total: scored.length,
        '0.85+': scored.filter(s => s.finalScore >= 0.85).length,
        '0.7-0.85': scored.filter(s => s.finalScore >= 0.7 && s.finalScore < 0.85).length,
        '0.6-0.7': scored.filter(s => s.finalScore >= 0.6 && s.finalScore < 0.7).length,
        '0.5-0.6': scored.filter(s => s.finalScore >= 0.5 && s.finalScore < 0.6).length,
        '<0.5': scored.filter(s => s.finalScore < 0.5).length,
        passThreshold: scored.filter(s => s.finalScore >= CONFIG.MIN_SIMILARITY_EVENT).length,
        threshold: CONFIG.MIN_SIMILARITY_EVENT,
    };

    // ★ 过滤改成用 finalScore（包含 bonus）
    const candidates = scored
        .filter(s => s.finalScore >= CONFIG.MIN_SIMILARITY_EVENT)
        .sort((a, b) => b.finalScore - a.finalScore)
        .slice(0, CONFIG.CANDIDATE_EVENTS);

    // 动态 K：质量不够就少拿
    const dynamicK = Math.min(CONFIG.MAX_EVENTS, candidates.length);

    const selected = mmrSelect(
        candidates,
        dynamicK,
        CONFIG.MMR_LAMBDA,
        c => c.vector,
        c => c.finalScore
    );

    return selected
        .sort((a, b) => b.finalScore - a.finalScore)
        .map(s => ({
            event: s.event,
            similarity: s.finalScore,
            _recallType: s.isDirect ? 'DIRECT' : 'SIMILAR',
            _recallReason: s.reasons.length ? s.reasons.join('+') : '相似',
            _preFilterDistribution: preFilterDistribution,
        }));
}

// ═══════════════════════════════════════════════════════════════════════════
// 日志：因果树格式化
// ═══════════════════════════════════════════════════════════════════════════


// ═══════════════════════════════════════════════════════════════════════════
// 日志：主报告
// ═══════════════════════════════════════════════════════════════════════════

function formatRecallLog({
    elapsed,
    segments,
    weights,
    chunkResults,
    eventResults,
    allEvents,
    queryEntities,
    causalEvents = [],
    chunkPreFilterStats = null,
    l0Results = [],
    l0PreFilterStats = null,
}) {
    const lines = [
        '\u2554' + '\u2550'.repeat(62) + '\u2557',
        '\u2551                    \u8bb0\u5fc6\u53ec\u56de\u62a5\u544a                              \u2551',
        '\u2560' + '\u2550'.repeat(62) + '\u2563',
        `\u2551  \u8017\u65f6: ${elapsed}ms`,
        '\u255a' + '\u2550'.repeat(62) + '\u255d',
        '',
        '\u250c' + '\u2500'.repeat(61) + '\u2510',
        '\u2502 \u3010\u67e5\u8be2\u6784\u5efa\u3011\u6700\u8fd1 5 \u6761\u6d88\u606f\uff0c\u6307\u6570\u8870\u51cf\u52a0\u6743 (\u03b2=0.7)              \u2502',
        '\u2514' + '\u2500'.repeat(61) + '\u2518',
    ];

    // Keep query previews only (the only place to keep raw text)
    const segmentsSorted = segments.map((s, i) => ({
        idx: i + 1,
        weight: weights?.[i] ?? 0,
        text: s,
    })).sort((a, b) => b.weight - a.weight);

    segmentsSorted.forEach((s, rank) => {
        const bar = '\u2588'.repeat(Math.round(s.weight * 20));
        const preview = s.text.length > 60 ? s.text.slice(0, 60) + '...' : s.text;
        const marker = rank === 0 ? ' \u25c0 \u4e3b\u5bfc' : '';
        lines.push(`  ${(s.weight * 100).toFixed(1).padStart(5)}% ${bar.padEnd(12)} ${preview}${marker}`);
    });

    lines.push('');
    lines.push('\u250c' + '\u2500'.repeat(61) + '\u2510');
    lines.push('\u2502 \u3010\u63d0\u53d6\u5b9e\u4f53\u3011                                                 \u2502');
    lines.push('\u2514' + '\u2500'.repeat(61) + '\u2518');
    lines.push(`  ${queryEntities?.length ? queryEntities.join('\u3001') : '(\u65e0)'}`);

    // Recall stats (numbers only)
    lines.push('');
    lines.push('\u250c' + '\u2500'.repeat(61) + '\u2510');
    lines.push('\u2502 \u3010\u53ec\u56de\u7edf\u8ba1\u3011                                                 \u2502');
    lines.push('\u2514' + '\u2500'.repeat(61) + '\u2518');

    // L0
    const l0Floors = [...new Set(l0Results.map(r => r.floor))].sort((a, b) => a - b);
    lines.push('  L0 \u8bed\u4e49\u951a\u70b9:');
    if (l0Results.length) {
        const l0Dist = {
            '0.8+': l0Results.filter(r => r.similarity >= 0.8).length,
            '0.7-0.8': l0Results.filter(r => r.similarity >= 0.7 && r.similarity < 0.8).length,
            '0.6-0.7': l0Results.filter(r => r.similarity >= 0.6 && r.similarity < 0.7).length,
            '0.55-0.6': l0Results.filter(r => r.similarity >= 0.55 && r.similarity < 0.6).length,
        };
        lines.push(`    \u9009\u5165: ${l0Results.length} \u6761 | \u5f71\u54cd\u697c\u5c42: ${l0Floors.join(', ')} (+${CONFIG.L0_FLOOR_BONUS_FACTOR} \u52a0\u6743)`);
        lines.push(`    \u5339\u914d\u5ea6: 0.8+: ${l0Dist['0.8+']} | 0.7-0.8: ${l0Dist['0.7-0.8']} | 0.6-0.7: ${l0Dist['0.6-0.7']} | 0.55-0.6: ${l0Dist['0.55-0.6']}`);
    } else {
        lines.push('    (\u65e0\u6570\u636e)');
    }

    // L1
    lines.push('');
    lines.push('  L1 \u539f\u6587\u7247\u6bb5:');
    if (chunkPreFilterStats) {
        const dist = chunkPreFilterStats.distribution || {};
        lines.push(`    \u5168\u91cf: ${chunkPreFilterStats.total} \u6761 | \u901a\u8fc7\u9608\u503c(\u2265${chunkPreFilterStats.threshold}): ${chunkPreFilterStats.passThreshold} \u6761 | \u6700\u7ec8: ${chunkResults.length} \u6761`);
        lines.push(`    \u5339\u914d\u5ea6: 0.8+: ${dist['0.8+'] || 0} | 0.7-0.8: ${dist['0.7-0.8'] || 0} | 0.6-0.7: ${dist['0.6-0.7'] || 0} | <0.6: ${(dist['0.55-0.6'] || 0) + (dist['<0.55'] || 0)}`);

        const floorCounts = new Map();
        chunkResults.forEach(c => floorCounts.set(c.floor, (floorCounts.get(c.floor) || 0) + 1));
        const floorStats = `\u8986\u76d6 ${floorCounts.size} \u4e2a\u697c\u5c42`;
        lines.push(`    ${floorStats}`);
    } else {
        lines.push(`    \u9009\u5165: ${chunkResults.length} \u6761`);
    }

    // L2
    const preFilterDist = eventResults[0]?._preFilterDistribution || {};
    const directCount = eventResults.filter(e => e._recallType === 'DIRECT').length;
    const similarCount = eventResults.filter(e => e._recallType === 'SIMILAR').length;

    lines.push('');
    lines.push('  L2 \u4e8b\u4ef6\u8bb0\u5fc6:');
    lines.push(`    \u603b\u4e8b\u4ef6: ${allEvents.length} \u6761 | \u901a\u8fc7\u9608\u503c(\u2265${preFilterDist.threshold || 0.65}): ${preFilterDist.passThreshold || 0} \u6761 | \u6700\u7ec8: ${eventResults.length} \u6761`);
    if (preFilterDist.total) {
        lines.push(`    \u5339\u914d\u5ea6: 0.85+: ${preFilterDist['0.85+'] || 0} | 0.7-0.85: ${preFilterDist['0.7-0.85'] || 0} | 0.6-0.7: ${preFilterDist['0.6-0.7'] || 0} | <0.6: ${(preFilterDist['0.5-0.6'] || 0) + (preFilterDist['<0.5'] || 0)}`);
    }
    lines.push(`    \u7c7b\u578b: DIRECT ${directCount} \u6761 | SIMILAR ${similarCount} \u6761`);

    // Causal chains
    if (causalEvents.length) {
        const maxRefs = Math.max(...causalEvents.map(c => c.chainFrom?.length || 0));
        const maxDepth = Math.max(...causalEvents.map(c => c.depth || 0));
        lines.push('');
        lines.push('  \u56e0\u679c\u94fe\u8ffd\u6eaf:');
        lines.push(`    \u8ffd\u6eaf: ${causalEvents.length} \u6761 | \u6700\u5927\u88ab\u5f15: ${maxRefs} \u6b21 | \u6700\u5927\u6df1\u5ea6: ${maxDepth}`);
    }

    lines.push('');
    return lines.join('\n');
}

// ═══════════════════════════════════════════════════════════════════════════
// 主入口
// ═══════════════════════════════════════════════════════════════════════════

export async function recallMemory(queryText, allEvents, vectorConfig, options = {}) {
    const T0 = performance.now();
    const { chat } = getContext();
    const store = getSummaryStore();
    const { pendingUserMessage = null } = options;

    if (!allEvents?.length) {
        return { events: [], chunks: [], elapsed: 0, logText: 'No events.' };
    }

    const segments = buildQuerySegments(chat, CONFIG.QUERY_MSG_COUNT, !!options.excludeLastAi, pendingUserMessage);

    let queryVector, weights;
    try {
        const result = await embedWeightedQuery(segments, vectorConfig);
        queryVector = result?.vector;
        weights = result?.weights;
    } catch (e) {
        xbLog.error(MODULE_ID, '查询向量生成失败', e);
        return { events: [], chunks: [], elapsed: Math.round(performance.now() - T0), logText: 'Query embedding failed.' };
    }

    if (!queryVector?.length) {
        return { events: [], chunks: [], elapsed: Math.round(performance.now() - T0), logText: 'Empty query vector.' };
    }

    const lexicon = buildEntityLexicon(store, allEvents);
    const queryEntities = extractEntities(segments.join('\n'), lexicon);

    // ════════════════════════════════════════════════════════════════════════
    // L0 召回
    // ════════════════════════════════════════════════════════════════════════
    let l0Results = [];
    let l0FloorBonus = new Map();
    let l0VirtualChunks = [];

    try {
        l0Results = await searchStateAtoms(queryVector, vectorConfig);
        l0FloorBonus = buildL0FloorBonus(l0Results, CONFIG.L0_FLOOR_BONUS_FACTOR);
        l0VirtualChunks = stateToVirtualChunks(l0Results);
    } catch (e) {
        xbLog.warn(MODULE_ID, 'L0 召回失败，降级处理', e);
    }

    const [chunkResults, eventResults] = await Promise.all([
        searchChunks(queryVector, vectorConfig, l0FloorBonus),
        searchEvents(queryVector, allEvents, vectorConfig, store, queryEntities, l0FloorBonus),
    ]);

    const chunkPreFilterStats = chunkResults._preFilterStats || null;

    // ════════════════════════════════════════════════════════════════════════
    // 合并 L0 虚拟 chunks 到 L1
    // ════════════════════════════════════════════════════════════════════════
    const mergedChunks = mergeAndSparsify(l0VirtualChunks, chunkResults, CONFIG.FLOOR_MAX_CHUNKS);

    // ─────────────────────────────────────────────────────────────────────
    // 因果链追溯：从 eventResults 出发找祖先事件
    // 注意：是否“额外注入”要去重（如果祖先事件本来已召回，就不额外注入）
    // ─────────────────────────────────────────────────────────────────────
    const eventIndex = buildEventIndex(allEvents);
    const causalMap = traceCausalAncestors(eventResults, eventIndex);

    const recalledIdSet = new Set(eventResults.map(x => x?.event?.id).filter(Boolean));
    const causalEvents = Array.from(causalMap.values())
        .filter(x => x?.event?.id && !recalledIdSet.has(x.event.id))
        .map(x => ({
            event: x.event,
            similarity: 0,
            _recallType: 'CAUSAL',
            _recallReason: `因果链(${x.chainFrom.join(',')})`,
            _causalDepth: x.depth,
            _chainFrom: x.chainFrom,
            chainFrom: x.chainFrom,
            depth: x.depth,
        }));

    // 排序：引用数 > 深度 > 编号，然后截断
    sortCausalEvents(causalEvents);
    const causalEventsTruncated = causalEvents.slice(0, CONFIG.CAUSAL_INJECT_MAX);

    const elapsed = Math.round(performance.now() - T0);
    const logText = formatRecallLog({
        elapsed,
        queryText,
        segments,
        weights,
        chunkResults: mergedChunks,
        eventResults,
        allEvents,
        queryEntities,
        causalEvents: causalEventsTruncated,
        chunkPreFilterStats,
        l0Results,
    });

    console.group('%c[Recall]', 'color: #7c3aed; font-weight: bold');
    console.log(`Elapsed: ${elapsed}ms | L0: ${l0Results.length} | Entities: ${queryEntities.join(', ') || '(none)'}`);
    console.log(`L1: ${mergedChunks.length} | L2: ${eventResults.length}/${allEvents.length} | Causal: ${causalEventsTruncated.length}`);
    console.groupEnd();

    return { events: eventResults, causalEvents: causalEventsTruncated, chunks: mergedChunks, elapsed, logText, queryEntities, l0Results };
}

export function buildQueryText(chat, count = 2, excludeLastAi = false) {
    if (!chat?.length) return '';

    let messages = chat;
    if (excludeLastAi && messages.length > 0 && !messages[messages.length - 1]?.is_user) {
        messages = messages.slice(0, -1);
    }

    return messages.slice(-count).map(m => {
        const text = cleanForRecall(m.mes);
        const speaker = m.name || (m.is_user ? '用户' : '角色');
        return `${speaker}: ${text.slice(0, 500)}`;
    }).filter(Boolean).join('\n');
}