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

package/dist/src/store/read_store.js

@@ -37,6 +37,177 @@ exports.createReadStore = createReadStore;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const module_1 = require("module");
+function buildEntityGraphSummaryDocs(graphDocs) {
+    const entityEdges = new Map();
+    const entityLatestTs = new Map();
+    const entitySession = new Map();
+    for (const doc of graphDocs) {
+        const ts = typeof doc.timestamp === "number" ? doc.timestamp : 0;
+        const sessionId = typeof doc.sessionId === "string" ? doc.sessionId : "";
+        const relations = Array.isArray(doc.relations) ? doc.relations : [];
+        for (const relation of relations) {
+            const source = (relation.source || "").trim();
+            const target = (relation.target || "").trim();
+            const type = (relation.type || "").trim();
+            if (!source || !target || !type)
+                continue;
+            if (!entityEdges.has(source))
+                entityEdges.set(source, []);
+            if (!entityEdges.has(target))
+                entityEdges.set(target, []);
+            entityEdges.get(source)?.push({ source, target, type });
+            entityEdges.get(target)?.push({ source, target, type });
+            entityLatestTs.set(source, Math.max(entityLatestTs.get(source) || 0, ts));
+            entityLatestTs.set(target, Math.max(entityLatestTs.get(target) || 0, ts));
+            if (sessionId) {
+                if (!entitySession.has(source))
+                    entitySession.set(source, sessionId);
+                if (!entitySession.has(target))
+                    entitySession.set(target, sessionId);
+            }
+        }
+    }
+    const output = [];
+    for (const [entity, edges] of entityEdges.entries()) {
+        if (!edges.length)
+            continue;
+        const outgoing = edges.filter(edge => edge.source === entity);
+        const incoming = edges.filter(edge => edge.target === entity);
+        const typeCounter = new Map();
+        for (const edge of edges) {
+            typeCounter.set(edge.type, (typeCounter.get(edge.type) || 0) + 1);
+        }
+        const typeSummary = [...typeCounter.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([type, count]) => `${type}:${count}`)
+            .join(", ");
+        const sortedOutgoing = [...outgoing].sort((a, b) => a.type.localeCompare(b.type));
+        const sortedIncoming = [...incoming].sort((a, b) => a.type.localeCompare(b.type));
+        const cappedOutgoing = sortedOutgoing.slice(0, 20);
+        const cappedIncoming = sortedIncoming.slice(0, 20);
+        const relationFacts = edges
+            .slice(0, 40)
+            .map(edge => `${edge.source} ${edge.type} ${edge.target}`)
+            .join(" | ");
+        const outgoingBlock = cappedOutgoing.length > 0
+            ? cappedOutgoing.map((edge, index) => `${index + 1}. ${edge.source} -[${edge.type}]-> ${edge.target}`).join("\n")
+            : "none";
+        const incomingBlock = cappedIncoming.length > 0
+            ? cappedIncoming.map((edge, index) => `${index + 1}. ${edge.source} -[${edge.type}]-> ${edge.target}`).join("\n")
+            : "none";
+        const summaryText = [
+            `# Graph Entity Summary`,
+            `entity: ${entity}`,
+            ``,
+            `## Stats`,
+            `relation_total: ${edges.length}`,
+            `outgoing_total: ${outgoing.length}`,
+            `incoming_total: ${incoming.length}`,
+            typeSummary ? `relation_type_distribution: ${typeSummary}` : "relation_type_distribution: none",
+            ``,
+            `## Outgoing Relations`,
+            outgoingBlock,
+            outgoing.length > cappedOutgoing.length ? `...truncated_outgoing: ${outgoing.length - cappedOutgoing.length}` : "",
+            ``,
+            `## Incoming Relations`,
+            incomingBlock,
+            incoming.length > cappedIncoming.length ? `...truncated_incoming: ${incoming.length - cappedIncoming.length}` : "",
+            ``,
+            `## Relation Facts`,
+            relationFacts || "none",
+        ].filter(Boolean).join("\n");
+        output.push({
+            id: `gph_entity_${entity.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/gi, "_")}`,
+            text: summaryText,
+            source: "sessions_graph_entity",
+            timestamp: (entityLatestTs.get(entity) || 0) > 0 ? entityLatestTs.get(entity) : undefined,
+            layer: "archive",
+            sourceMemoryId: entity,
+            sessionId: entitySession.get(entity) || undefined,
+            entities: [entity],
+            relations: edges,
+            eventType: "graph_summary",
+            qualityScore: 1,
+        });
+    }
+    return output;
+}
+const DEFAULT_READ_TUNING = {
+    scoring: {
+        lexicalWeight: 0.2,
+        bm25Scale: 2,
+        semanticWeight: 0.3,
+        recencyWeight: 0.1,
+        qualityWeight: 0.15,
+        typeMatchWeight: 0.15,
+        graphMatchWeight: 0.1,
+    },
+    rrf: {
+        k: 60,
+        weight: 1.5,
+    },
+    recency: {
+        buckets: [
+            { maxAgeHours: 12, score: 1, bonus: 0.6 },
+            { maxAgeHours: 24, score: 0.8, bonus: 0.6 },
+            { maxAgeHours: 72, score: 0.6, bonus: 0.3 },
+            { maxAgeHours: 168, score: 0.4, bonus: 0.3 },
+            { maxAgeHours: 720, score: 0.2, bonus: 0 },
+            { maxAgeHours: Number.POSITIVE_INFINITY, score: 0.05, bonus: 0 },
+        ],
+    },
+    autoContext: {
+        queryMaxChars: 80,
+        lightweightSearch: true,
+    },
+};
+function resolveReadTuning(options) {
+    const configuredBuckets = Array.isArray(options?.recency?.buckets)
+        ? options?.recency?.buckets
+            .filter(item => item &&
+            Number.isFinite(item.maxAgeHours) &&
+            item.maxAgeHours > 0 &&
+            Number.isFinite(item.score) &&
+            item.score >= 0 &&
+            Number.isFinite(item.bonus))
+            .map(item => ({
+            maxAgeHours: item.maxAgeHours,
+            score: Math.max(0, item.score),
+            bonus: Math.max(0, item.bonus),
+        }))
+        : [];
+    const sortedBuckets = configuredBuckets
+        .sort((a, b) => a.maxAgeHours - b.maxAgeHours);
+    const buckets = sortedBuckets.length > 0 ? sortedBuckets : DEFAULT_READ_TUNING.recency.buckets;
+    const numberOr = (value, fallback, min) => {
+        if (typeof value !== "number" || !Number.isFinite(value) || value < min) {
+            return fallback;
+        }
+        return value;
+    };
+    return {
+        scoring: {
+            lexicalWeight: numberOr(options?.scoring?.lexicalWeight, DEFAULT_READ_TUNING.scoring.lexicalWeight, 0),
+            bm25Scale: numberOr(options?.scoring?.bm25Scale, DEFAULT_READ_TUNING.scoring.bm25Scale, 0),
+            semanticWeight: numberOr(options?.scoring?.semanticWeight, DEFAULT_READ_TUNING.scoring.semanticWeight, 0),
+            recencyWeight: numberOr(options?.scoring?.recencyWeight, DEFAULT_READ_TUNING.scoring.recencyWeight, 0),
+            qualityWeight: numberOr(options?.scoring?.qualityWeight, DEFAULT_READ_TUNING.scoring.qualityWeight, 0),
+            typeMatchWeight: numberOr(options?.scoring?.typeMatchWeight, DEFAULT_READ_TUNING.scoring.typeMatchWeight, 0),
+            graphMatchWeight: numberOr(options?.scoring?.graphMatchWeight, DEFAULT_READ_TUNING.scoring.graphMatchWeight, 0),
+        },
+        rrf: {
+            k: Math.floor(numberOr(options?.rrf?.k, DEFAULT_READ_TUNING.rrf.k, 1)),
+            weight: numberOr(options?.rrf?.weight, DEFAULT_READ_TUNING.rrf.weight, 0),
+        },
+        recency: {
+            buckets,
+        },
+        autoContext: {
+            queryMaxChars: Math.floor(numberOr(options?.autoContext?.queryMaxChars, DEFAULT_READ_TUNING.autoContext.queryMaxChars, 20)),
+            lightweightSearch: options?.autoContext?.lightweightSearch !== false,
+        },
+    };
+}
 function safeReadFile(filePath) {
     try {
         if (!fs.existsSync(filePath)) {
@@ -116,6 +287,14 @@ function bm25Score(args) {
     return score;
 }
 function normalizeRecordText(record) {
+    const summary = typeof record.summary === "string" ? record.summary.trim() : "";
+    const sourceText = typeof record.source_text === "string" ? record.source_text.trim() : "";
+    if (summary && sourceText) {
+        return [
+            `summary: ${summary}`,
+            `source_text: ${sourceText}`,
+        ].join("\n");
+    }
     const direct = [record.content, record.summary, record.text, record.message]
         .find(v => typeof v === "string" && v.trim());
     if (direct) {
@@ -158,33 +337,21 @@ function parseJsonlFile(filePath, sourceLabel, logger) {
         }
         try {
             const parsed = JSON.parse(trimmed);
-            const text = normalizeRecordText(parsed);
+            const summaryText = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
+            const sourceText = typeof parsed.source_text === "string" ? parsed.source_text.trim() : "";
+            const text = summaryText || normalizeRecordText(parsed);
             if (!text.trim()) {
                 continue;
             }
             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,
+                summaryText: summaryText || text,
+                sourceText: sourceText || undefined,
+                sourceEventId: typeof parsed.source_event_id === "string" ? parsed.source_event_id : undefined,
+                sourceFile: typeof parsed.source_file === "string" ? parsed.source_file : undefined,
                 source: sourceLabel,
                 timestamp: Number.isFinite(timestampValue) ? timestampValue : undefined,
                 layer: parsed.layer === "active" || parsed.layer === "archive"
@@ -202,8 +369,8 @@ function parseJsonlFile(filePath, sourceLabel, logger) {
                 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,
+                entities: [],
+                relations: [],
             });
         }
         catch (error) {
@@ -232,35 +399,83 @@ function parseMarkdownFile(filePath, sourceLabel) {
         },
     ];
 }
-function withRecencyBoost(score, timestamp) {
+function extractPrioritizedRuleLines(text, maxRules) {
+    if (!text.trim() || maxRules <= 0) {
+        return [];
+    }
+    const lines = text
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(line => !/^core rules and knowledge extracted/i.test(line))
+        .filter(line => !/^core rules\b/i.test(line));
+    if (lines.length === 0) {
+        return [];
+    }
+    const dedupedFromTail = [];
+    const seen = new Set();
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        const line = lines[i];
+        const key = line.toLowerCase().replace(/\s+/g, " ").trim();
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        dedupedFromTail.push(line);
+    }
+    const scored = dedupedFromTail.map((line, indexFromTail) => {
+        let score = 0;
+        if (/(must|should|ensure|avoid|prefer|always|never|fallback|verify|validate|retry|sanitize)/i.test(line)) {
+            score += 3;
+        }
+        if (/(fix|resolved|success|stable|deploy|release|incident|rollback|constraint|decision)/i.test(line)) {
+            score += 2;
+        }
+        if (/(确保|避免|优先|必须|建议|回退|重试|校验|稳定|发布|决策)/.test(line)) {
+            score += 2;
+        }
+        if (line.length >= 30 && line.length <= 220) {
+            score += 2;
+        }
+        else if (line.length > 220) {
+            score -= 1;
+        }
+        if (/[.!?]$/.test(line)) {
+            score += 1;
+        }
+        score += Math.max(0, 2 - indexFromTail * 0.08);
+        return { line, score, indexFromTail };
+    });
+    const selected = scored
+        .sort((a, b) => (b.score - a.score) || (a.indexFromTail - b.indexFromTail))
+        .slice(0, maxRules)
+        .sort((a, b) => a.indexFromTail - b.indexFromTail)
+        .map(item => item.line);
+    return selected;
+}
+function withRecencyBoost(score, timestamp, buckets) {
     if (!timestamp) {
         return score;
     }
     const ageHours = (Date.now() - timestamp) / (1000 * 60 * 60);
-    if (ageHours < 24) {
-        return score + 0.6;
-    }
-    if (ageHours < 168) {
-        return score + 0.3;
+    for (const bucket of buckets) {
+        if (ageHours <= bucket.maxAgeHours) {
+            return score + bucket.bonus;
+        }
     }
     return score;
 }
-function recencyScore(timestamp) {
+function recencyScore(timestamp, buckets) {
     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;
+    for (const bucket of buckets) {
+        if (ageHours <= bucket.maxAgeHours) {
+            return bucket.score;
+        }
+    }
+    return 0;
 }
 function eventTypeHalfLifeDays(eventType, options) {
     const fallback = typeof options?.defaultHalfLifeDays === "number" && options.defaultHalfLifeDays > 0
@@ -322,10 +537,11 @@ function normalizeBaseUrl(value) {
         return "";
     return value.endsWith("/") ? value.slice(0, -1) : value;
 }
-const READ_FUSION_PROMPT_VERSION = "read-fusion.v1.1.0";
+const READ_FUSION_PROMPT_VERSION = "read-fusion.v1.2.0";
 const READ_FUSION_REGRESSION_SAMPLES = [
-    "样例A: 同一 source_memory_id 同时出现在 archive 与 vector，输出中只保留一条主事实并在证据链保留两者关联。",
-    "样例B: 新旧决策冲突时，将冲突写入 conflicts，并在 canonical_answer 标注优先级依据（时间、质量、明确性）。",
+    "Example A: if archive and vector refer to the same source_memory_id, keep one main conclusion and keep the rest as supporting evidence.",
+    "Example B: if conclusions conflict, write conflicts and explain prioritization in canonical_answer (time, quality, explicitness).",
+    "Example C: if summary/excerpt is insufficient, return event ids in need_fulltext_event_ids for full-text lookup.",
 ];
 function cosineSimilarity(left, right) {
     if (left.length === 0 || right.length === 0) {
@@ -450,19 +666,19 @@ async function requestRerank(args) {
 }
 function classifyIntent(query) {
     const text = query.toLowerCase();
-    const relationHints = /(关系|依赖|关联|上下游|graph|relation|entity|拓扑)/i;
+    const relationHints = /(关系|依赖|关联|上下游|图谱|拓扑|graph|relation|entity|dependency)/i;
     if (relationHints.test(text))
         return "RELATION_DISCOVERY";
-    const troubleHints = /(报错|错误|异常|失败|超时|无法|崩溃|error|failed|timeout|fix)/i;
+    const troubleHints = /(报错|错误|异常|失败|超时|无法|崩溃|故障|修复|bug|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;
+    const timelineHints = /(最近|上次|之前|时间线|历史|timeline|history)/i;
     if (timelineHints.test(text))
         return "TIMELINE_REVIEW";
-    const decisionHints = /(方案|决策|选择|建议|取舍|tradeoff|plan)/i;
+    const decisionHints = /(方案|决策|选择|建议|取舍|权衡|tradeoff|plan)/i;
     if (decisionHints.test(text))
         return "DECISION_SUPPORT";
     return "FACT_LOOKUP";
@@ -546,6 +762,50 @@ function channelQuota(source, topK, options) {
         return Math.max(8, topK * 3);
     return Math.max(12, topK * 4);
 }
+function parseJsonStringArray(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .map(item => (typeof item === "string" ? item.trim() : ""))
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function parseJsonRelations(value) {
+    if (typeof value !== "string" || !value.trim()) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .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() ? relation.type.trim() : "related_to";
+            if (!source || !target)
+                return null;
+            return { source, target, type };
+        })
+            .filter((item) => Boolean(item));
+    }
+    catch {
+        return [];
+    }
+}
 async function searchLanceDb(args) {
     try {
         const require = (0, module_1.createRequire)(__filename);
@@ -585,12 +845,8 @@ async function searchLanceDb(args) {
             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)
-                : [];
+            const entities = parseJsonStringArray(record.entities_json);
+            const relations = parseJsonRelations(record.relations_json);
             docs.push({
                 id,
                 text: summary,
@@ -599,6 +855,10 @@ async function searchLanceDb(args) {
                 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,
+                sourceEventId: typeof record.source_event_id === "string" ? record.source_event_id : undefined,
+                sourceField: record.source_field === "summary" || record.source_field === "evidence"
+                    ? record.source_field
+                    : 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,
@@ -659,6 +919,10 @@ function parseVectorFallback(filePath, logger) {
                 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,
+                sourceEventId: typeof parsed.source_event_id === "string" ? parsed.source_event_id : undefined,
+                sourceField: parsed.source_field === "summary" || parsed.source_field === "evidence"
+                    ? parsed.source_field
+                    : 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,
@@ -676,34 +940,75 @@ function parseVectorFallback(filePath, logger) {
     return docs;
 }
 async function requestFusion(args) {
+    const candidateIdSet = new Set(args.candidates.map(item => item.id));
     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}`)
+        .map((item, index) => {
+        const excerpt = (item.source_excerpt || "").trim();
+        const sourceFile = (item.source_file || "").trim();
+        const sourceMemoryId = (item.source_memory_id || "").trim();
+        const sourceMemoryCanonicalId = (item.source_memory_canonical_id || "").trim();
+        const sourceLayer = (item.source_layer || "").trim();
+        const sourceEventId = (item.source_event_id || "").trim();
+        const sourceField = (item.source_field || "").trim();
+        const extraParts = [];
+        if (sourceMemoryId)
+            extraParts.push(`source_memory_id=${sourceMemoryId}`);
+        if (sourceMemoryCanonicalId)
+            extraParts.push(`source_memory_canonical_id=${sourceMemoryCanonicalId}`);
+        if (sourceLayer)
+            extraParts.push(`source_layer=${sourceLayer}`);
+        if (sourceEventId)
+            extraParts.push(`source_event_id=${sourceEventId}`);
+        if (sourceField)
+            extraParts.push(`source_field=${sourceField}`);
+        if (sourceFile)
+            extraParts.push(`source_file=${sourceFile}`);
+        if (excerpt)
+            extraParts.push(`source_excerpt=${excerpt}`);
+        const extra = extraParts.length > 0 ? `\n   ${extraParts.join("\n   ")}` : "";
+        return `${index + 1}. [${item.id}] (${item.source}, score=${item.score.toFixed(4)}) ${item.text}${extra}`;
+    })
         .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 的候选只保留一条主结论，其余作为证据补充",
+        "You are a memory retrieval fusion engine. Fuse multi-channel evidence into a structured answer package for the agent.",
+        "Core values and principles:",
+        "A) Truthfulness first: do not fabricate; do not infer beyond evidence.",
+        "B) Evidence first: every key conclusion must be traceable via evidence_ids.",
+        "C) Make conflicts explicit: write conflicts instead of silently overriding.",
+        "D) Be transparent about uncertainty: put uncertain parts in coverage_note.",
+        "E) Summary-first: prefer summary evidence for conclusions; source_excerpt is supporting evidence.",
+        "F) Same-source dedup: merge duplicate evidence from the same source_memory_id/source_memory_canonical_id.",
+        "G) Full-text recall: if summary/excerpt is insufficient, return event ids in need_fulltext_event_ids.",
+        "Source channel semantics:",
+        "- rules: policy/constraints; use for what should be done.",
+        "- archive: event-level stable facts (summary-first).",
+        "- vector: semantic neighbors for recall; source_field=summary/evidence indicates chunk role.",
+        "- graph: entity-relation structure; prefer for dependency/relationship questions.",
+        "Query alignment:",
+        "- answer the user query first; ignore evidence unrelated to the query.",
+        "- when evidence conflicts, prioritize recency + quality + explicitness and record the conflict.",
+        "Return strict JSON only:",
+        "{\"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[], \"need_fulltext_event_ids\": string[], \"confidence\": number}",
+        "Output constraints:",
+        "1) canonical_answer must be directly usable.",
+        "2) facts: usually 3-12 items; prefer high-quality evidence.",
+        "3) evidence_ids must come from input candidate ids.",
+        "4) conflicts must be [] when no conflict exists.",
+        "5) confidence must be within [0, 1].",
+        "6) uncertain parts must be explicitly stated in coverage_note.",
         ...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}` },
+            { role: "system", content: "Output JSON only. No extra text." },
+            { role: "user", content: `${prompt}\n\nQuery:\n${args.query}\n\nCandidate Evidence:\n${evidenceText}` },
         ],
     };
     let lastError = null;
@@ -739,6 +1044,13 @@ async function requestFusion(args) {
             const evidenceIds = Array.isArray(parsed.evidence_ids)
                 ? parsed.evidence_ids.filter(item => typeof item === "string" && item.trim())
                 : [];
+            const whitelistedEvidenceIds = [...new Set(evidenceIds.filter(id => candidateIdSet.has(id)))];
+            const needFulltextEventIds = Array.isArray(parsed.need_fulltext_event_ids)
+                ? [...new Set(parsed.need_fulltext_event_ids
+                        .filter(item => typeof item === "string")
+                        .map(item => item.trim())
+                        .filter(Boolean))]
+                : [];
             return {
                 canonical_answer: parsed.canonical_answer.trim().slice(0, 6000),
                 coverage_note: typeof parsed.coverage_note === "string" ? parsed.coverage_note.trim().slice(0, 1200) : "",
@@ -751,7 +1063,8 @@ async function requestFusion(args) {
                 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,
+                evidence_ids: whitelistedEvidenceIds,
+                need_fulltext_event_ids: needFulltextEventIds,
                 confidence: typeof parsed.confidence === "number"
                     ? Math.max(0, Math.min(1, parsed.confidence))
                     : 0.5,
@@ -772,6 +1085,13 @@ function createReadStore(options) {
     let vectorFallbackCache = null;
     let bm25TokenCacheSignature = "";
     let bm25TokenCache = new Map();
+    let hitStatsCache = null;
+    let hitStatsDirty = false;
+    let hitStatsPendingMutations = 0;
+    let lastHitStatsFlushAt = 0;
+    const hitStatsFlushIntervalMs = 5000;
+    const hitStatsFlushBatch = 24;
+    const readTuning = resolveReadTuning(options.readTuning);
     function fileSignature(filePath) {
         try {
             if (!fs.existsSync(filePath)) {
@@ -785,22 +1105,30 @@ function createReadStore(options) {
         }
     }
     function loadHitStats() {
+        if (hitStatsCache) {
+            return hitStatsCache;
+        }
         try {
             if (!fs.existsSync(hitStatsPath)) {
-                return { items: {} };
+                hitStatsCache = { items: {} };
+                return hitStatsCache;
             }
             const content = fs.readFileSync(hitStatsPath, "utf-8").trim();
             if (!content) {
-                return { items: {} };
+                hitStatsCache = { items: {} };
+                return hitStatsCache;
             }
             const parsed = JSON.parse(content);
             if (!parsed || typeof parsed !== "object" || !parsed.items || typeof parsed.items !== "object") {
-                return { items: {} };
+                hitStatsCache = { items: {} };
+                return hitStatsCache;
             }
-            return parsed;
+            hitStatsCache = parsed;
+            return hitStatsCache;
         }
         catch {
-            return { items: {} };
+            hitStatsCache = { items: {} };
+            return hitStatsCache;
         }
     }
     function saveHitStats(state) {
@@ -815,6 +1143,21 @@ function createReadStore(options) {
             options.logger.warn(`Failed to persist read hit stats: ${error}`);
         }
     }
+    function maybeFlushHitStats(force) {
+        if (!hitStatsDirty || !hitStatsCache) {
+            return;
+        }
+        const now = Date.now();
+        if (!force &&
+            hitStatsPendingMutations < hitStatsFlushBatch &&
+            (now - lastHitStatsFlushAt) < hitStatsFlushIntervalMs) {
+            return;
+        }
+        saveHitStats(hitStatsCache);
+        hitStatsDirty = false;
+        hitStatsPendingMutations = 0;
+        lastHitStatsFlushAt = now;
+    }
     function markHit(ids) {
         if (!ids.length) {
             return;
@@ -839,27 +1182,143 @@ function createReadStore(options) {
         })
             .slice(0, 20000);
         state.items = Object.fromEntries(entries);
-        saveHitStats(state);
+        hitStatsCache = state;
+        hitStatsDirty = true;
+        hitStatsPendingMutations += ids.length;
+        maybeFlushHitStats(false);
     }
     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");
+        const graphMemoryPath = path.join(memoryRoot, "graph", "memory.jsonl");
         const signature = [
             fileSignature(cortexRulesPath),
             fileSignature(memoryMdPath),
             fileSignature(activeSessionsPath),
             fileSignature(archiveSessionsPath),
+            fileSignature(graphMemoryPath),
         ].join("|");
         if (docsCache && docsCache.signature === signature) {
             return docsCache.docs;
         }
+        const archiveEventTypeById = new Map();
+        if (fs.existsSync(archiveSessionsPath)) {
+            const archiveContent = safeReadFile(archiveSessionsPath);
+            for (const line of archiveContent.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    const id = typeof parsed.id === "string" ? parsed.id.trim() : "";
+                    const eventType = typeof parsed.event_type === "string" ? parsed.event_type.trim() : "";
+                    if (id && eventType) {
+                        archiveEventTypeById.set(id, eventType);
+                    }
+                }
+                catch { }
+            }
+        }
+        const graphDocs = [];
+        if (fs.existsSync(graphMemoryPath)) {
+            const graphContent = safeReadFile(graphMemoryPath);
+            for (const line of graphContent.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 sourceEventId = typeof parsed.source_event_id === "string" ? parsed.source_event_id : "";
+                    const archiveEventId = typeof parsed.archive_event_id === "string" ? parsed.archive_event_id : "";
+                    const eventRefId = archiveEventId || sourceEventId;
+                    const sessionId = typeof parsed.session_id === "string" ? parsed.session_id : "";
+                    const sourceLayer = typeof parsed.source_layer === "string" ? parsed.source_layer : "";
+                    const sourceFile = typeof parsed.source_file === "string" ? parsed.source_file : "";
+                    const timestamp = 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 entityTypes = typeof parsed.entity_types === "object" && parsed.entity_types !== null
+                        ? parsed.entity_types
+                        : {};
+                    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))
+                        : [];
+                    const eventType = (typeof parsed.event_type === "string" ? parsed.event_type : "") || archiveEventTypeById.get(eventRefId) || "";
+                    const entityLines = entities.length > 0
+                        ? entities.map((entity, index) => {
+                            const entityType = entityTypes[entity];
+                            return `${index + 1}. ${entity}${entityType ? ` (${entityType})` : ""}`;
+                        }).join("\n")
+                        : "none";
+                    const relationLines = relations.length > 0
+                        ? relations.map((relation, index) => `${index + 1}. ${relation.source} -[${relation.type}]-> ${relation.target}`).join("\n")
+                        : "none";
+                    const relationFacts = relations.length > 0
+                        ? relations.map(relation => `${relation.source} ${relation.type} ${relation.target}`).join(" | ")
+                        : "none";
+                    const text = [
+                        `# Graph Record`,
+                        `record_id: ${id}`,
+                        `source_event_id: ${sourceEventId || archiveEventId || "unknown"}`,
+                        `source_layer: ${sourceLayer || "unknown"}`,
+                        `archive_event_id: ${archiveEventId || "n/a"}`,
+                        `event_type: ${eventType || "unknown"}`,
+                        `session_id: ${sessionId || "unknown"}`,
+                        `source_file: ${sourceFile || "unknown"}`,
+                        ``,
+                        `## Entities`,
+                        entityLines,
+                        ``,
+                        `## Relations`,
+                        relationLines,
+                        ``,
+                        `## Relation Facts`,
+                        relationFacts,
+                    ].join("\n");
+                    if (id && text.trim()) {
+                        graphDocs.push({
+                            id,
+                            text,
+                            source: "sessions_graph",
+                            timestamp: Number.isFinite(timestamp) ? timestamp : undefined,
+                            layer: sourceLayer === "active_only" ? "active" : "archive",
+                            sourceMemoryId: eventRefId || id,
+                            sourceEventId: sourceEventId || archiveEventId || undefined,
+                            sessionId,
+                            entities,
+                            relations,
+                        });
+                    }
+                }
+                catch (error) {
+                    options.logger.debug(`Skipping invalid graph memory line: ${error}`);
+                }
+            }
+        }
+        const entitySummaryDocs = buildEntityGraphSummaryDocs(graphDocs);
         const docs = [
             ...parseMarkdownFile(cortexRulesPath, "CORTEX_RULES.md"),
             ...parseMarkdownFile(memoryMdPath, "MEMORY.md"),
             ...parseJsonlFile(activeSessionsPath, "sessions_active", options.logger),
             ...parseJsonlFile(archiveSessionsPath, "sessions_archive", options.logger),
+            ...graphDocs,
+            ...entitySummaryDocs,
         ];
         docsCache = { signature, docs };
         return docs;
@@ -892,6 +1351,8 @@ function createReadStore(options) {
         if (!query) {
             return { results: [] };
         }
+        const mode = args.mode === "lightweight" ? "lightweight" : "default";
+        const lightweightMode = mode === "lightweight";
         const docs = loadAllDocuments();
         const hitStats = loadHitStats();
         const intent = classifyIntent(query);
@@ -900,7 +1361,7 @@ function createReadStore(options) {
         const embeddingModel = options.embedding?.model || "";
         const embeddingApiKey = options.embedding?.apiKey || "";
         const embeddingBaseUrl = normalizeBaseUrl(options.embedding?.baseURL || options.embedding?.baseUrl);
-        if (embeddingModel && embeddingApiKey && embeddingBaseUrl) {
+        if (!lightweightMode && embeddingModel && embeddingApiKey && embeddingBaseUrl) {
             try {
                 queryEmbedding = await requestEmbedding({
                     text: query,
@@ -921,8 +1382,38 @@ function createReadStore(options) {
             ? []
             : loadVectorFallbackCached();
         const vectorDocs = [...vectorDocsFromLance, ...vectorDocsFallback];
+        const archiveSourceById = new Map();
+        for (const doc of docs) {
+            if (doc.source !== "sessions_archive")
+                continue;
+            const key = (doc.sourceMemoryId || doc.id || "").trim();
+            if (!key)
+                continue;
+            archiveSourceById.set(key, {
+                sourceText: doc.sourceText,
+                summaryText: doc.summaryText || doc.text,
+                sourceFile: doc.sourceFile,
+            });
+        }
+        for (const doc of vectorDocs) {
+            const key = (doc.sourceMemoryId || "").trim();
+            if (!key)
+                continue;
+            const linked = archiveSourceById.get(key);
+            if (!linked)
+                continue;
+            if (!doc.sourceText && linked.sourceText) {
+                doc.sourceText = linked.sourceText;
+            }
+            if (!doc.summaryText && linked.summaryText) {
+                doc.summaryText = linked.summaryText;
+            }
+            if (!doc.sourceFile && linked.sourceFile) {
+                doc.sourceFile = linked.sourceFile;
+            }
+        }
         const graphDocs = docs
-            .filter(doc => Array.isArray(doc.relations) && doc.relations.length > 0)
+            .filter(doc => doc.source === "sessions_graph" || doc.source === "sessions_graph_entity")
             .map(doc => {
             const graphText = [
                 doc.text,
@@ -934,7 +1425,7 @@ function createReadStore(options) {
             };
         });
         const rulesDocs = docs.filter(doc => doc.source === "CORTEX_RULES.md");
-        const archiveDocs = docs.filter(doc => doc.source.startsWith("sessions_"));
+        const archiveDocs = docs.filter(doc => doc.source === "sessions_active" || doc.source === "sessions_archive");
         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(",")}`;
@@ -956,14 +1447,14 @@ function createReadStore(options) {
                 avgDocLen: bm25Stats.avgDocLen,
                 docFreq: bm25Stats.docFreq,
             });
-            const lexicalCombined = lexical + bm25 * 2;
+            const lexicalCombined = lexical + bm25 * readTuning.scoring.bm25Scale;
             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 recency = recencyScore(doc.timestamp, readTuning.recency.buckets);
             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)
@@ -972,12 +1463,12 @@ function createReadStore(options) {
             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 baseWeighted = (readTuning.scoring.lexicalWeight * lexicalCombined +
+                readTuning.scoring.semanticWeight * (semantic * lengthNorm) +
+                readTuning.scoring.recencyWeight * recency +
+                readTuning.scoring.qualityWeight * quality +
+                readTuning.scoring.typeMatchWeight * typeMatch +
+                readTuning.scoring.graphMatchWeight * graphMatch) * sourceBaseWeight * sourceConfigWeight;
             const decayFactor = computeDecayFactor(doc.id, doc.eventType, doc.timestamp, options.memoryDecay, hitStats);
             const weighted = baseWeighted * decayFactor;
             return {
@@ -1020,7 +1511,7 @@ function createReadStore(options) {
         }
         const rrfMap = new Map();
         const weightedMap = new Map();
-        const rrfK = 60;
+        const rrfK = readTuning.rrf.k;
         for (const key of Object.keys(channels)) {
             const list = channels[key];
             for (let i = 0; i < list.length; i += 1) {
@@ -1040,13 +1531,18 @@ function createReadStore(options) {
             merge_key: mergeKey,
             source_memory_id: candidate.doc.sourceMemoryId || "",
             source_memory_canonical_id: candidate.doc.sourceMemoryCanonicalId || "",
-            text: candidate.doc.text,
+            source_event_id: candidate.doc.sourceEventId || "",
+            source_field: candidate.doc.sourceField || "",
+            text: candidate.doc.summaryText || candidate.doc.text,
+            source_text: candidate.doc.sourceText ? candidate.doc.sourceText.slice(0, 4000) : "",
+            source_excerpt: candidate.doc.sourceText ? candidate.doc.sourceText.slice(0, 360) : "",
+            source_file: candidate.doc.sourceFile || "",
             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: candidate.weighted + (rrfMap.get(mergeKey) || 0) * readTuning.rrf.weight,
             score_breakdown: {
                 lexical: Number(candidate.lexical.toFixed(4)),
                 bm25: Number(candidate.bm25.toFixed(4)),
@@ -1056,7 +1552,7 @@ function createReadStore(options) {
                 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)),
+                rrf: Number(((rrfMap.get(mergeKey) || 0) * readTuning.rrf.weight).toFixed(4)),
                 weighted: Number(candidate.weighted.toFixed(4)),
             },
             reason_tags: [
@@ -1074,13 +1570,13 @@ function createReadStore(options) {
             .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);
+            const boost = withRecencyBoost(doc.score, doc.timestamp ? Date.parse(doc.timestamp) : undefined, readTuning.recency.buckets);
             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 fusionEnabled = !lightweightMode && options.fusion?.enabled !== false;
         const llmModel = options.llm?.model || "";
         const llmApiKey = options.llm?.apiKey || "";
         const llmBaseUrl = normalizeBaseUrl(options.llm?.baseURL || options.llm?.baseUrl);
@@ -1093,7 +1589,7 @@ function createReadStore(options) {
             source: item.source,
             score: item.score,
         }));
-        if (rerankerModel && rerankerApiKey && rerankerBaseUrl && lexicalRanked.length > 1 && !skipRerankerForFusion) {
+        if (!lightweightMode && rerankerModel && rerankerApiKey && rerankerBaseUrl && lexicalRanked.length > 1 && !skipRerankerForFusion) {
             try {
                 rerankedSimple = await requestRerank({
                     query,
@@ -1118,7 +1614,13 @@ function createReadStore(options) {
                 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 || "",
+                source_event_id: hit?.source_event_id || "",
+                source_field: hit?.source_field || "",
+                fulltext_event_id: (hit?.source_event_id || hit?.source_memory_id || item.id || ""),
                 text: item.text,
+                source_text: hit?.source_text || "",
+                source_excerpt: hit?.source_excerpt || "",
+                source_file: hit?.source_file || "",
                 source: item.source,
                 layer: hit?.layer || "",
                 event_type: hit?.event_type || "",
@@ -1131,7 +1633,10 @@ function createReadStore(options) {
                     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 || "",
+                    source_event_id: hit?.source_event_id || "",
+                    source_field: hit?.source_field || "",
                     channel: item.source,
+                    source_file: hit?.source_file || "",
                     layer: hit?.layer || "",
                     score_breakdown: hit?.score_breakdown || {},
                     reason_tags: Array.isArray(hit?.reason_tags) ? hit?.reason_tags : [],
@@ -1152,7 +1657,13 @@ function createReadStore(options) {
                     merge_key: item.merge_key,
                     source_memory_id: item.source_memory_id,
                     source_memory_canonical_id: item.source_memory_canonical_id,
+                    source_event_id: item.source_event_id || "",
+                    source_field: item.source_field || "",
+                    fulltext_event_id: item.source_event_id || item.source_memory_id || item.id,
                     text: item.text,
+                    source_text: item.source_text || "",
+                    source_excerpt: item.source_excerpt || "",
+                    source_file: item.source_file || "",
                     source: item.source,
                     layer: item.layer,
                     event_type: item.event_type,
@@ -1165,7 +1676,10 @@ function createReadStore(options) {
                         merge_key: item.merge_key,
                         source_memory_id: item.source_memory_id,
                         source_memory_canonical_id: item.source_memory_canonical_id,
+                        source_event_id: item.source_event_id || "",
+                        source_field: item.source_field || "",
                         channel: item.source,
+                        source_file: item.source_file || "",
                         layer: item.layer,
                         score_breakdown: item.score_breakdown || {},
                         reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
@@ -1185,7 +1699,13 @@ function createReadStore(options) {
                     merge_key: item.merge_key,
                     source_memory_id: item.source_memory_id,
                     source_memory_canonical_id: item.source_memory_canonical_id,
+                    source_event_id: item.source_event_id || "",
+                    source_field: item.source_field || "",
+                    fulltext_event_id: item.source_event_id || item.source_memory_id || item.id,
                     text: item.text,
+                    source_text: item.source_text || "",
+                    source_excerpt: item.source_excerpt || "",
+                    source_file: item.source_file || "",
                     source: item.source,
                     layer: item.layer,
                     event_type: item.event_type,
@@ -1198,7 +1718,10 @@ function createReadStore(options) {
                         merge_key: item.merge_key,
                         source_memory_id: item.source_memory_id,
                         source_memory_canonical_id: item.source_memory_canonical_id,
+                        source_event_id: item.source_event_id || "",
+                        source_field: item.source_field || "",
                         channel: item.source,
+                        source_file: item.source_file || "",
                         layer: item.layer,
                         score_breakdown: item.score_breakdown || {},
                         reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
@@ -1215,6 +1738,13 @@ function createReadStore(options) {
                     candidates: ranked.slice(0, maxCandidates).map(item => ({
                         id: item.id,
                         text: item.text,
+                        source_excerpt: typeof item.source_excerpt === "string" ? item.source_excerpt : "",
+                        source_file: typeof item.source_file === "string" ? item.source_file : "",
+                        source_memory_id: typeof item.source_memory_id === "string" ? item.source_memory_id : "",
+                        source_memory_canonical_id: typeof item.source_memory_canonical_id === "string" ? item.source_memory_canonical_id : "",
+                        source_layer: typeof item.layer === "string" ? item.layer : "",
+                        source_event_id: typeof item.source_event_id === "string" ? item.source_event_id : "",
+                        source_field: item.source_field === "summary" || item.source_field === "evidence" ? item.source_field : "",
                         source: item.source,
                         event_type: item.event_type,
                         quality_score: item.quality_score,
@@ -1229,6 +1759,20 @@ function createReadStore(options) {
                     },
                 });
                 if (fusion && fusion.canonical_answer) {
+                    if (!Array.isArray(fusion.evidence_ids) || fusion.evidence_ids.length === 0) {
+                        throw new Error("fusion_missing_whitelisted_evidence");
+                    }
+                    const fulltextFetchHints = (Array.isArray(fusion.need_fulltext_event_ids) ? fusion.need_fulltext_event_ids : [])
+                        .map(eventId => {
+                        const linked = ranked.find(item => item.source_memory_id === eventId ||
+                            item.source_memory_canonical_id === eventId ||
+                            item.id === eventId);
+                        return {
+                            event_id: eventId,
+                            source_file: linked?.source_file || "",
+                            source_excerpt: linked?.source_excerpt || "",
+                        };
+                    });
                     const fusedItem = {
                         id: `fusion_${Date.now().toString(36)}`,
                         text: fusion.canonical_answer,
@@ -1254,6 +1798,8 @@ function createReadStore(options) {
                         fused_action_items: fusion.action_items || [],
                         fused_conflicts: fusion.conflicts,
                         fused_evidence_ids: fusion.evidence_ids,
+                        fused_need_fulltext_event_ids: fusion.need_fulltext_event_ids || [],
+                        fulltext_fetch_hints: fulltextFetchHints,
                     };
                     const authoritative = options.fusion?.authoritative !== false;
                     if (authoritative) {
@@ -1280,6 +1826,7 @@ function createReadStore(options) {
         const limit = Math.max(1, args.limit);
         const docs = loadAllDocuments();
         const coreRules = docs.find(doc => doc.source === "CORTEX_RULES.md");
+        const ruleBudget = Math.max(1, Math.min(6, Math.floor(limit / 3)));
         const archiveDocs = docs
             .filter(doc => doc.source === "sessions_archive")
             .sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0))
@@ -1290,7 +1837,14 @@ function createReadStore(options) {
             .slice(0, 2);
         const result = [];
         if (coreRules) {
-            result.push({ id: coreRules.id, text: coreRules.text, source: coreRules.source });
+            const selectedRules = extractPrioritizedRuleLines(coreRules.text, ruleBudget);
+            if (selectedRules.length > 0) {
+                result.push({
+                    id: `${coreRules.id}.hot`,
+                    text: `# Hot Rules\n${selectedRules.map((line, index) => `${index + 1}. ${line}`).join("\n")}`,
+                    source: coreRules.source,
+                });
+            }
         }
         for (const doc of [...issueFixPairs, ...archiveDocs]) {
             result.push({ id: doc.id, text: doc.text, source: doc.source });
@@ -1312,9 +1866,14 @@ function createReadStore(options) {
                 .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 });
+                const autoQuery = latest.text.slice(0, Math.max(20, readTuning.autoContext.queryMaxChars));
+                const light = await searchMemory({
+                    query: autoQuery,
+                    topK: 3,
+                    mode: readTuning.autoContext.lightweightSearch ? "lightweight" : "default",
+                });
                 result.auto_search = {
-                    query: latest.text.slice(0, 80),
+                    query: autoQuery,
                     results: light.results,
                     age_seconds: 0,
                 };