openclaw-cortex-memory 0.1.0-Alpha.30 → 0.1.0-Alpha.32

package/dist/src/store/read_store.js

@@ -38,6 +38,12 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const module_1 = require("module");
 const http_post_1 = require("../net/http_post");
+function graphRelationKey(relation) {
+    const source = (relation.source || "").trim().toLowerCase();
+    const type = (relation.type || "related_to").trim().toLowerCase();
+    const target = (relation.target || "").trim().toLowerCase();
+    return `${source}|${type}|${target}`;
+}
 function buildEntityGraphSummaryDocs(graphDocs) {
     const entityEdges = new Map();
     const entityLatestTs = new Map();
@@ -339,8 +345,17 @@ function parseJsonlFile(filePath, sourceLabel, logger) {
         try {
             const parsed = JSON.parse(trimmed);
             const summaryText = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
+            const causeText = typeof parsed.cause === "string" ? parsed.cause.trim() : "";
+            const processText = typeof parsed.process === "string" ? parsed.process.trim() : "";
+            const resultText = typeof parsed.result === "string" ? parsed.result.trim() : "";
             const sourceText = typeof parsed.source_text === "string" ? parsed.source_text.trim() : "";
-            const text = summaryText || normalizeRecordText(parsed);
+            const activeContent = typeof parsed.content === "string" ? parsed.content.trim() : "";
+            const text = [
+                summaryText,
+                causeText ? `cause: ${causeText}` : "",
+                processText ? `process: ${processText}` : "",
+                resultText ? `result: ${resultText}` : "",
+            ].filter(Boolean).join("\n") || normalizeRecordText(parsed);
             if (!text.trim()) {
                 continue;
             }
@@ -350,7 +365,7 @@ function parseJsonlFile(filePath, sourceLabel, logger) {
                 id,
                 text,
                 summaryText: summaryText || text,
-                sourceText: sourceText || undefined,
+                sourceText: sourceText || activeContent || 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,
@@ -400,6 +415,209 @@ function parseMarkdownFile(filePath, sourceLabel) {
         },
     ];
 }
+function normalizeFactStatus(value) {
+    const token = (value || "").trim().toLowerCase();
+    if (!token)
+        return null;
+    if (token === "active")
+        return "active";
+    if (token === "pending" || token === "pending_conflict")
+        return "pending_conflict";
+    if (token === "superseded")
+        return "superseded";
+    if (token === "rejected")
+        return "rejected";
+    return null;
+}
+function uniqueStrings(values) {
+    const output = [];
+    const seen = new Set();
+    for (const value of values) {
+        const key = (value || "").trim();
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        output.push(key);
+    }
+    return output;
+}
+function buildGraphEvidenceIds(args) {
+    const relationKey = graphRelationKey({
+        source: args.source,
+        target: args.target,
+        type: args.type,
+    });
+    const evidenceIds = [
+        relationKey ? `graph:relation:${relationKey}` : "",
+        args.sourceEventId ? `graph:event:${args.sourceEventId}` : "",
+        args.evidenceSpan
+            ? `graph:evidence:${args.sourceEventId || relationKey}`
+            : "",
+        args.wikiRef
+            ? `wiki:${args.wikiRef}${args.wikiAnchor ? `#${args.wikiAnchor}` : ""}`
+            : "",
+    ];
+    return uniqueStrings(evidenceIds);
+}
+function toMemoryRelativePath(memoryRoot, filePath) {
+    return path.relative(memoryRoot, filePath).replace(/\\/g, "/");
+}
+function toAnchorToken(value) {
+    const token = (value || "")
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9\u4e00-\u9fa5]+/gi, "-")
+        .replace(/^-+|-+$/g, "");
+    return token || "facts";
+}
+function parseWikiRelationLine(line) {
+    const text = line.trim();
+    if (!text.startsWith("- "))
+        return null;
+    if (text === "- (none)")
+        return null;
+    const body = text.replace(/^-+\s*/, "");
+    const matched = body.match(/^(.+?)\s+--([^\/]+)\/([^-\s]+)-->\s+(.+?)\s*(?:\((.*)\))?$/);
+    if (!matched) {
+        return null;
+    }
+    const source = matched[1].trim();
+    const type = matched[2].trim();
+    const status = normalizeFactStatus(matched[3]);
+    const target = matched[4].trim();
+    const attrs = (matched[5] || "").trim();
+    if (!source || !target || !type) {
+        return null;
+    }
+    const attributeMap = new Map();
+    if (attrs) {
+        const parts = attrs.split(",").map(item => item.trim()).filter(Boolean);
+        for (const part of parts) {
+            const eq = part.indexOf("=");
+            if (eq <= 0)
+                continue;
+            const key = part.slice(0, eq).trim().toLowerCase();
+            const value = part.slice(eq + 1).trim();
+            if (!key)
+                continue;
+            attributeMap.set(key, value);
+        }
+    }
+    const evidenceSpanRaw = attributeMap.get("evidence") || "";
+    const confidenceRaw = attributeMap.get("confidence") || "";
+    const sourceEventIdRaw = attributeMap.get("source_event_id") || "";
+    const conflictIdRaw = attributeMap.get("conflict_id") || "";
+    const confidenceNum = confidenceRaw ? Number(confidenceRaw) : NaN;
+    const relationKey = graphRelationKey({ source, target, type });
+    return {
+        relation: {
+            source,
+            target,
+            type,
+            evidence_span: evidenceSpanRaw && evidenceSpanRaw.toLowerCase() !== "n/a" ? evidenceSpanRaw : undefined,
+            confidence: Number.isFinite(confidenceNum) ? confidenceNum : undefined,
+            fact_status: status || undefined,
+            source_event_id: sourceEventIdRaw && sourceEventIdRaw.toLowerCase() !== "n/a" ? sourceEventIdRaw : undefined,
+            conflict_id: conflictIdRaw && conflictIdRaw.toLowerCase() !== "n/a" ? conflictIdRaw : undefined,
+            relation_key: relationKey,
+        },
+    };
+}
+function parseWikiProjectionDocuments(memoryRoot, logger) {
+    const wikiRoot = path.join(memoryRoot, "wiki");
+    const folders = [
+        { dir: path.join(wikiRoot, "entities"), kind: "entity" },
+        { dir: path.join(wikiRoot, "topics"), kind: "topic" },
+        { dir: path.join(wikiRoot, "timelines"), kind: "timeline" },
+    ];
+    const docs = [];
+    for (const { dir, kind } of folders) {
+        if (!fs.existsSync(dir))
+            continue;
+        let files = [];
+        try {
+            files = fs.readdirSync(dir)
+                .filter(file => file.toLowerCase().endsWith(".md"))
+                .sort((a, b) => a.localeCompare(b));
+        }
+        catch (error) {
+            logger.debug(`Skipping wiki projection directory ${dir}: ${error}`);
+            continue;
+        }
+        for (const file of files) {
+            const filePath = path.join(dir, file);
+            const markdown = safeReadFile(filePath);
+            if (!markdown.trim())
+                continue;
+            const relativePath = toMemoryRelativePath(memoryRoot, filePath);
+            const mtime = (() => {
+                try {
+                    return fs.statSync(filePath).mtimeMs;
+                }
+                catch {
+                    return NaN;
+                }
+            })();
+            let section = "Facts";
+            const sectionCounters = new Map();
+            const lines = markdown.split(/\r?\n/);
+            for (const rawLine of lines) {
+                const line = rawLine.trim();
+                if (!line)
+                    continue;
+                if (line.startsWith("## ")) {
+                    section = line.replace(/^##\s+/, "").trim() || "Facts";
+                    continue;
+                }
+                const parsed = parseWikiRelationLine(line);
+                if (!parsed)
+                    continue;
+                const sectionToken = toAnchorToken(section);
+                const index = (sectionCounters.get(sectionToken) || 0) + 1;
+                sectionCounters.set(sectionToken, index);
+                const anchor = `${sectionToken}-${index}`;
+                const relation = parsed.relation;
+                const factStatus = relation.fact_status || "active";
+                const evidenceIds = buildGraphEvidenceIds({
+                    source: relation.source,
+                    target: relation.target,
+                    type: relation.type,
+                    sourceEventId: relation.source_event_id,
+                    evidenceSpan: relation.evidence_span,
+                    wikiRef: relativePath,
+                    wikiAnchor: anchor,
+                });
+                docs.push({
+                    id: `wiki:${relativePath}#${anchor}`,
+                    text: [
+                        `# Wiki Projection`,
+                        `wiki_kind: ${kind}`,
+                        `wiki_path: ${relativePath}`,
+                        `wiki_section: ${section}`,
+                        `fact_status: ${factStatus}`,
+                        `${relation.source} ${relation.type} ${relation.target}`,
+                        line,
+                    ].join("\n"),
+                    source: "sessions_graph_wiki",
+                    timestamp: Number.isFinite(mtime) ? Math.floor(mtime) : undefined,
+                    layer: "archive",
+                    sourceFile: relativePath,
+                    sourceMemoryId: relation.relation_key || `wiki:${relativePath}`,
+                    sourceEventId: relation.source_event_id,
+                    eventType: "graph_wiki_projection",
+                    qualityScore: 0.95,
+                    entities: uniqueStrings([relation.source, relation.target]),
+                    relations: [relation],
+                    factStatus,
+                    wikiRef: relativePath,
+                    wikiAnchor: anchor,
+                    evidenceIds,
+                });
+            }
+        }
+    }
+    return docs;
+}
 function extractPrioritizedRuleLines(text, maxRules) {
     if (!text.trim() || maxRules <= 0) {
         return [];
@@ -693,6 +911,95 @@ function sourceWeight(source, intent) {
     }
     return 1;
 }
+const QUERY_PLAN_STOPWORDS = new Set([
+    "what",
+    "is",
+    "the",
+    "a",
+    "an",
+    "of",
+    "for",
+    "to",
+    "in",
+    "on",
+    "and",
+    "or",
+    "with",
+    "about",
+    "this",
+    "that",
+    "这些",
+    "那些",
+    "这个",
+    "那个",
+    "之前",
+    "提到",
+    "提过",
+    "一下",
+    "请问",
+    "关于",
+    "相关",
+    "什么",
+    "怎么",
+    "如何",
+    "是否",
+    "有没有",
+    "是什么",
+    "哪些",
+    "哪个",
+]);
+function planQueryKeywords(query) {
+    const normalized = (query || "").trim().replace(/\s+/g, " ");
+    if (!normalized)
+        return [];
+    const output = [];
+    const seen = new Set();
+    const push = (value) => {
+        const item = (value || "").trim();
+        if (!item)
+            return;
+        const key = item.toLowerCase();
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        output.push(item);
+    };
+    push(normalized);
+    for (const match of normalized.matchAll(/["“”'‘’]([^"“”'‘’]{2,64})["“”'‘’]/g)) {
+        push(match[1]);
+    }
+    for (const match of normalized.match(/https?:\/\/[^\s]+/gi) || []) {
+        push(match);
+    }
+    for (const match of normalized.matchAll(/\b[A-Za-z0-9][A-Za-z0-9._/-]*(?:\s+[A-Za-z0-9][A-Za-z0-9._/-]*){0,3}\b/g)) {
+        const phrase = match[0].trim();
+        const words = phrase.split(/\s+/).filter(Boolean);
+        const hasStrongSignal = words.length >= 2 || /[A-Z]{2,}/.test(phrase);
+        if (hasStrongSignal && !QUERY_PLAN_STOPWORDS.has(phrase.toLowerCase())) {
+            push(phrase);
+        }
+    }
+    const normalizedForSplit = normalized
+        .replace(/[(){}\[\]<>]/g, " ")
+        .replace(/[，。！？；：,.!?;:、]/g, " ")
+        .replace(/(之前提到的|之前提到|提到的|提到|请问|一下|是什么|什么|哪个|哪篇|哪里|如何|怎么|有关|关于|以及|还有|并且|然后|能否|可以|帮我|给我)/g, " ");
+    for (const raw of normalizedForSplit.split(/[\/\-\s]+/)) {
+        const token = raw.trim();
+        if (!token || token.length < 2)
+            continue;
+        if (QUERY_PLAN_STOPWORDS.has(token.toLowerCase()))
+            continue;
+        push(token);
+    }
+    return output.slice(0, 5);
+}
+function shouldTriggerFulltextFallback(ranked, topK) {
+    const scoped = ranked.slice(0, Math.max(1, topK));
+    if (scoped.length === 0)
+        return true;
+    const summaryHits = scoped.filter(item => Array.isArray(item.reason_tags) && item.reason_tags.includes("summary_hit")).length;
+    return summaryHits === 0;
+}
 function mergeKeyFromDoc(doc) {
     const canonical = typeof doc.sourceMemoryCanonicalId === "string" ? doc.sourceMemoryCanonicalId.trim() : "";
     if (canonical) {
@@ -704,6 +1011,42 @@ function mergeKeyFromDoc(doc) {
     }
     return `id:${doc.id}`;
 }
+function docFactStatus(doc) {
+    const direct = normalizeFactStatus(typeof doc.factStatus === "string" ? doc.factStatus : "");
+    if (direct)
+        return direct;
+    const relation = Array.isArray(doc.relations) && doc.relations.length > 0 ? doc.relations[0] : null;
+    const relationStatus = normalizeFactStatus(typeof relation?.fact_status === "string" ? relation.fact_status : "");
+    if (relationStatus)
+        return relationStatus;
+    return "active";
+}
+function docEvidenceIds(doc) {
+    if (Array.isArray(doc.evidenceIds) && doc.evidenceIds.length > 0) {
+        return uniqueStrings(doc.evidenceIds);
+    }
+    const relation = Array.isArray(doc.relations) && doc.relations.length > 0 ? doc.relations[0] : null;
+    const source = relation?.source || "";
+    const target = relation?.target || "";
+    const type = relation?.type || "";
+    const evidence = source && target && type
+        ? buildGraphEvidenceIds({
+            source,
+            target,
+            type,
+            sourceEventId: relation?.source_event_id || doc.sourceEventId,
+            evidenceSpan: relation?.evidence_span,
+            wikiRef: doc.wikiRef,
+            wikiAnchor: doc.wikiAnchor,
+        })
+        : [];
+    return uniqueStrings([
+        ...evidence,
+        doc.sourceEventId ? `graph:event:${doc.sourceEventId}` : "",
+        doc.wikiRef ? `wiki:${doc.wikiRef}${doc.wikiAnchor ? `#${doc.wikiAnchor}` : ""}` : "",
+        `doc:${doc.id}`,
+    ]);
+}
 function customChannelWeight(source, options) {
     const weights = options?.channelWeights;
     if (!weights)
@@ -1111,6 +1454,24 @@ function createReadStore(options) {
             return hitStatsCache;
         }
     }
+    function directorySignature(dirPath, extension) {
+        try {
+            if (!fs.existsSync(dirPath)) {
+                return `${dirPath}:missing`;
+            }
+            const files = fs.readdirSync(dirPath)
+                .filter(file => file.toLowerCase().endsWith(extension.toLowerCase()))
+                .sort((a, b) => a.localeCompare(b));
+            if (files.length === 0) {
+                return `${dirPath}:empty`;
+            }
+            const signatures = files.map(file => fileSignature(path.join(dirPath, file)));
+            return `${dirPath}:${signatures.join("|")}`;
+        }
+        catch {
+            return `${dirPath}:error`;
+        }
+    }
     function saveHitStats(state) {
         try {
             const dir = path.dirname(hitStatsPath);
@@ -1169,16 +1530,26 @@ function createReadStore(options) {
     }
     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 supersededRelationPath = path.join(memoryRoot, "graph", "superseded_relations.jsonl");
+        const conflictQueuePath = path.join(memoryRoot, "graph", "conflict_queue.jsonl");
+        const wikiEntitiesDir = path.join(memoryRoot, "wiki", "entities");
+        const wikiTopicsDir = path.join(memoryRoot, "wiki", "topics");
+        const wikiTimelinesDir = path.join(memoryRoot, "wiki", "timelines");
+        const wikiProjectionIndexPath = path.join(memoryRoot, "wiki", ".projection_index.json");
         const signature = [
             fileSignature(cortexRulesPath),
-            fileSignature(memoryMdPath),
             fileSignature(activeSessionsPath),
             fileSignature(archiveSessionsPath),
             fileSignature(graphMemoryPath),
+            fileSignature(supersededRelationPath),
+            fileSignature(conflictQueuePath),
+            directorySignature(wikiEntitiesDir, ".md"),
+            directorySignature(wikiTopicsDir, ".md"),
+            directorySignature(wikiTimelinesDir, ".md"),
+            fileSignature(wikiProjectionIndexPath),
         ].join("|");
         if (docsCache && docsCache.signature === signature) {
             return docsCache.docs;
@@ -1202,6 +1573,25 @@ function createReadStore(options) {
             }
         }
         const graphDocs = [];
+        const supersededRelationKeys = new Set();
+        if (fs.existsSync(supersededRelationPath)) {
+            const supersededContent = safeReadFile(supersededRelationPath);
+            for (const line of supersededContent.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    const relationKey = typeof parsed.relation_key === "string" ? parsed.relation_key.trim().toLowerCase() : "";
+                    if (relationKey) {
+                        supersededRelationKeys.add(relationKey);
+                    }
+                }
+                catch (error) {
+                    options.logger.debug(`Skipping invalid superseded relation line: ${error}`);
+                }
+            }
+        }
         if (fs.existsSync(graphMemoryPath)) {
             const graphContent = safeReadFile(graphMemoryPath);
             for (const line of graphContent.split(/\r?\n/)) {
@@ -1211,12 +1601,21 @@ function createReadStore(options) {
                 try {
                     const parsed = JSON.parse(trimmed);
                     const id = typeof parsed.id === "string" ? parsed.id : "";
+                    const summary = typeof parsed.summary === "string" ? parsed.summary.trim() : "";
+                    const sourceTextNav = typeof parsed.source_text_nav === "object" && parsed.source_text_nav !== null && !Array.isArray(parsed.source_text_nav)
+                        ? parsed.source_text_nav
+                        : undefined;
                     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 navSourceEventId = typeof sourceTextNav?.source_event_id === "string" ? sourceTextNav.source_event_id.trim() : "";
+                    const navSourceMemoryId = typeof sourceTextNav?.source_memory_id === "string" ? sourceTextNav.source_memory_id.trim() : "";
+                    const navSessionId = typeof sourceTextNav?.session_id === "string" ? sourceTextNav.session_id.trim() : "";
+                    const navSourceLayer = typeof sourceTextNav?.layer === "string" ? sourceTextNav.layer.trim() : "";
+                    const navSourceFile = typeof sourceTextNav?.source_file === "string" ? sourceTextNav.source_file.trim() : "";
+                    const eventRefId = navSourceMemoryId || archiveEventId || navSourceEventId || sourceEventId;
+                    const sessionId = navSessionId || (typeof parsed.session_id === "string" ? parsed.session_id : "");
+                    const sourceLayer = navSourceLayer || (typeof parsed.source_layer === "string" ? parsed.source_layer : "");
+                    const sourceFile = navSourceFile || (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)
@@ -1224,65 +1623,114 @@ function createReadStore(options) {
                     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 relations = Array.isArray(parsed.relations) ? parsed.relations : [];
                     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()) {
+                    let relationCount = 0;
+                    for (const relationRaw of relations) {
+                        if (typeof relationRaw !== "object" || relationRaw === null)
+                            continue;
+                        const relationRecord = relationRaw;
+                        const source = typeof relationRecord.source === "string" ? relationRecord.source.trim() : "";
+                        const target = typeof relationRecord.target === "string" ? relationRecord.target.trim() : "";
+                        const type = typeof relationRecord.type === "string" ? relationRecord.type.trim() : "related_to";
+                        if (!source || !target)
+                            continue;
+                        relationCount += 1;
+                        const relationKey = graphRelationKey({ source, target, type });
+                        const factStatus = supersededRelationKeys.has(relationKey) ? "superseded" : "active";
+                        const evidenceSpan = typeof relationRecord.evidence_span === "string" && relationRecord.evidence_span.trim()
+                            ? relationRecord.evidence_span.trim()
+                            : undefined;
+                        const confidenceValue = typeof relationRecord.confidence === "number" && Number.isFinite(relationRecord.confidence)
+                            ? relationRecord.confidence
+                            : undefined;
+                        const relationOrigin = typeof relationRecord.relation_origin === "string" && relationRecord.relation_origin.trim()
+                            ? relationRecord.relation_origin.trim()
+                            : undefined;
+                        const relationDefinition = typeof relationRecord.relation_definition === "string" && relationRecord.relation_definition.trim()
+                            ? relationRecord.relation_definition.trim()
+                            : undefined;
+                        const contextChunk = typeof relationRecord.context_chunk === "string" && relationRecord.context_chunk.trim()
+                            ? relationRecord.context_chunk.trim()
+                            : undefined;
+                        const relation = {
+                            source,
+                            target,
+                            type,
+                            relation_origin: relationOrigin,
+                            relation_definition: relationDefinition,
+                            evidence_span: evidenceSpan,
+                            context_chunk: contextChunk,
+                            confidence: confidenceValue,
+                            fact_status: factStatus,
+                            source_event_id: sourceEventId || archiveEventId || undefined,
+                            relation_key: relationKey,
+                        };
+                        const relationEntities = uniqueStrings([...entities, source, target]);
+                        const entityLines = relationEntities.length > 0
+                            ? relationEntities.map((entity, index) => {
+                                const entityType = entityTypes[entity];
+                                return `${index + 1}. ${entity}${entityType ? ` (${entityType})` : ""}`;
+                            }).join("\n")
+                            : "none";
+                        const text = [
+                            `# Graph Relation`,
+                            `record_id: ${id}`,
+                            `relation_index: ${relationCount}`,
+                            `relation_key: ${relationKey}`,
+                            `fact_status: ${factStatus}`,
+                            `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"}`,
+                            `evidence_span: ${evidenceSpan || "n/a"}`,
+                            `context_chunk: ${contextChunk || "n/a"}`,
+                            `relation_origin: ${relationOrigin || "n/a"}`,
+                            `relation_definition: ${relationDefinition || "n/a"}`,
+                            `confidence: ${typeof confidenceValue === "number" ? confidenceValue : "n/a"}`,
+                            ``,
+                            `## Summary`,
+                            summary || "n/a",
+                            ``,
+                            `## Source References`,
+                            `source_event_id: ${navSourceEventId || sourceEventId || archiveEventId || "unknown"}`,
+                            `source_memory_id: ${navSourceMemoryId || eventRefId || "unknown"}`,
+                            `source_layer: ${sourceLayer || "unknown"}`,
+                            `source_file: ${sourceFile || "unknown"}`,
+                            `session_id: ${sessionId || "unknown"}`,
+                            ``,
+                            `## Entities`,
+                            entityLines,
+                            ``,
+                            `## Relation`,
+                            `${source} -[${type}/${factStatus}]-> ${target}`,
+                        ].join("\n");
                         graphDocs.push({
-                            id,
+                            id: `${id || "graph"}:rel:${relationCount}`,
                             text,
                             source: "sessions_graph",
                             timestamp: Number.isFinite(timestamp) ? timestamp : undefined,
                             layer: sourceLayer === "active_only" ? "active" : "archive",
+                            summaryText: summary || undefined,
+                            sourceText: contextChunk || undefined,
                             sourceMemoryId: eventRefId || id,
-                            sourceEventId: sourceEventId || archiveEventId || undefined,
+                            sourceEventId: navSourceEventId || sourceEventId || archiveEventId || undefined,
+                            sourceFile: sourceFile || undefined,
                             sessionId,
-                            entities,
-                            relations,
+                            entities: relationEntities,
+                            relations: [relation],
+                            eventType: eventType || undefined,
+                            qualityScore: typeof parsed.confidence === "number" && Number.isFinite(parsed.confidence) ? parsed.confidence : 1,
+                            factStatus,
+                            evidenceIds: buildGraphEvidenceIds({
+                                source,
+                                target,
+                                type,
+                                sourceEventId: relation.source_event_id,
+                                evidenceSpan,
+                            }),
                         });
                     }
                 }
@@ -1291,14 +1739,152 @@ function createReadStore(options) {
                 }
             }
         }
-        const entitySummaryDocs = buildEntityGraphSummaryDocs(graphDocs);
+        if (fs.existsSync(conflictQueuePath)) {
+            const queueContent = safeReadFile(conflictQueuePath);
+            for (const line of queueContent.split(/\r?\n/)) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    const status = normalizeFactStatus(typeof parsed.status === "string" ? parsed.status : "");
+                    if (status !== "pending_conflict" && status !== "rejected") {
+                        continue;
+                    }
+                    const conflictId = typeof parsed.conflict_id === "string" ? parsed.conflict_id.trim() : "";
+                    const sourceEventId = typeof parsed.source_event_id === "string" ? parsed.source_event_id.trim() : "";
+                    const sessionId = typeof parsed.session_id === "string" ? parsed.session_id.trim() : "";
+                    const sourceFile = typeof parsed.source_file === "string" ? parsed.source_file.trim() : "";
+                    const sourceLayer = typeof parsed.source_layer === "string" ? parsed.source_layer.trim() : "";
+                    const updatedAt = typeof parsed.updated_at === "string" ? Date.parse(parsed.updated_at) : NaN;
+                    const candidate = typeof parsed.candidate === "object" && parsed.candidate !== null
+                        ? parsed.candidate
+                        : {};
+                    const candidateSummary = typeof candidate.summary === "string" ? candidate.summary.trim() : "";
+                    const candidateSourceTextNav = typeof candidate.source_text_nav === "object" && candidate.source_text_nav !== null && !Array.isArray(candidate.source_text_nav)
+                        ? candidate.source_text_nav
+                        : undefined;
+                    const navSourceEventId = typeof candidateSourceTextNav?.source_event_id === "string" ? candidateSourceTextNav.source_event_id.trim() : "";
+                    const navSourceMemoryId = typeof candidateSourceTextNav?.source_memory_id === "string" ? candidateSourceTextNav.source_memory_id.trim() : "";
+                    const navSourceLayer = typeof candidateSourceTextNav?.layer === "string" ? candidateSourceTextNav.layer.trim() : "";
+                    const navSourceFile = typeof candidateSourceTextNav?.source_file === "string" ? candidateSourceTextNav.source_file.trim() : "";
+                    const navSessionId = typeof candidateSourceTextNav?.session_id === "string" ? candidateSourceTextNav.session_id.trim() : "";
+                    const candidateEventType = typeof candidate.event_type === "string" ? candidate.event_type.trim() : "";
+                    const candidateRelations = Array.isArray(candidate.relations) ? candidate.relations : [];
+                    let relationIndex = 0;
+                    for (const relationRaw of candidateRelations) {
+                        if (typeof relationRaw !== "object" || relationRaw === null)
+                            continue;
+                        const relationRecord = relationRaw;
+                        const source = typeof relationRecord.source === "string" ? relationRecord.source.trim() : "";
+                        const target = typeof relationRecord.target === "string" ? relationRecord.target.trim() : "";
+                        const type = typeof relationRecord.type === "string" ? relationRecord.type.trim() : "related_to";
+                        if (!source || !target)
+                            continue;
+                        relationIndex += 1;
+                        const relationKey = graphRelationKey({ source, target, type });
+                        const evidenceSpan = typeof relationRecord.evidence_span === "string" && relationRecord.evidence_span.trim()
+                            ? relationRecord.evidence_span.trim()
+                            : undefined;
+                        const confidenceValue = typeof relationRecord.confidence === "number" && Number.isFinite(relationRecord.confidence)
+                            ? relationRecord.confidence
+                            : undefined;
+                        const relationOrigin = typeof relationRecord.relation_origin === "string" && relationRecord.relation_origin.trim()
+                            ? relationRecord.relation_origin.trim()
+                            : undefined;
+                        const relationDefinition = typeof relationRecord.relation_definition === "string" && relationRecord.relation_definition.trim()
+                            ? relationRecord.relation_definition.trim()
+                            : undefined;
+                        const contextChunk = typeof relationRecord.context_chunk === "string" && relationRecord.context_chunk.trim()
+                            ? relationRecord.context_chunk.trim()
+                            : undefined;
+                        const relation = {
+                            source,
+                            target,
+                            type,
+                            relation_origin: relationOrigin,
+                            relation_definition: relationDefinition,
+                            evidence_span: evidenceSpan,
+                            context_chunk: contextChunk,
+                            confidence: confidenceValue,
+                            fact_status: status,
+                            source_event_id: sourceEventId || undefined,
+                            conflict_id: conflictId || undefined,
+                            relation_key: relationKey,
+                        };
+                        const evidenceIds = uniqueStrings([
+                            ...buildGraphEvidenceIds({
+                                source,
+                                target,
+                                type,
+                                sourceEventId: sourceEventId || undefined,
+                                evidenceSpan,
+                            }),
+                            conflictId ? `graph:conflict:${conflictId}` : "",
+                        ]);
+                        const text = [
+                            `# Graph Conflict Candidate`,
+                            `conflict_id: ${conflictId || "unknown"}`,
+                            `fact_status: ${status}`,
+                            `source_event_id: ${sourceEventId || "unknown"}`,
+                            `source_layer: ${sourceLayer || "unknown"}`,
+                            `event_type: ${candidateEventType || "unknown"}`,
+                            `session_id: ${sessionId || "unknown"}`,
+                            `source_file: ${sourceFile || "unknown"}`,
+                            `relation_key: ${relationKey}`,
+                            `evidence_span: ${evidenceSpan || "n/a"}`,
+                            `context_chunk: ${contextChunk || "n/a"}`,
+                            `relation_origin: ${relationOrigin || "n/a"}`,
+                            `relation_definition: ${relationDefinition || "n/a"}`,
+                            `confidence: ${typeof confidenceValue === "number" ? confidenceValue : "n/a"}`,
+                            ``,
+                            `## Summary`,
+                            candidateSummary || "n/a",
+                            ``,
+                            `## Source References`,
+                            `source_event_id: ${navSourceEventId || sourceEventId || "unknown"}`,
+                            `source_memory_id: ${navSourceMemoryId || sourceEventId || "unknown"}`,
+                            `source_layer: ${navSourceLayer || sourceLayer || "unknown"}`,
+                            `source_file: ${navSourceFile || sourceFile || "unknown"}`,
+                            `session_id: ${navSessionId || sessionId || "unknown"}`,
+                            ``,
+                            `${source} -[${type}/${status}]-> ${target}`,
+                        ].join("\n");
+                        graphDocs.push({
+                            id: `gcf:${conflictId || "unknown"}:rel:${relationIndex}`,
+                            text,
+                            source: "sessions_graph_conflict",
+                            timestamp: Number.isFinite(updatedAt) ? updatedAt : undefined,
+                            layer: (navSourceLayer || sourceLayer) === "active_only" ? "active" : "archive",
+                            summaryText: candidateSummary || undefined,
+                            sourceText: contextChunk || undefined,
+                            sourceMemoryId: navSourceMemoryId || relationKey,
+                            sourceEventId: navSourceEventId || sourceEventId || undefined,
+                            sourceFile: navSourceFile || sourceFile || undefined,
+                            sessionId: navSessionId || sessionId || undefined,
+                            entities: uniqueStrings([source, target]),
+                            relations: [relation],
+                            eventType: candidateEventType || "graph_conflict",
+                            qualityScore: typeof confidenceValue === "number" ? confidenceValue : 0.8,
+                            factStatus: status,
+                            evidenceIds,
+                        });
+                    }
+                }
+                catch (error) {
+                    options.logger.debug(`Skipping invalid conflict queue line: ${error}`);
+                }
+            }
+        }
+        const entitySummaryDocs = buildEntityGraphSummaryDocs(graphDocs.filter(item => item.factStatus === "active"));
+        const wikiProjectionDocs = parseWikiProjectionDocuments(memoryRoot, options.logger);
         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,
+            ...wikiProjectionDocs,
         ];
         docsCache = { signature, docs };
         return docs;
@@ -1312,24 +1898,32 @@ function createReadStore(options) {
         vectorFallbackCache = { signature, docs };
         return docs;
     }
-    function getBm25Tokens(doc, signature) {
+    function getBm25Tokens(doc, signature, channel) {
         if (bm25TokenCacheSignature !== signature) {
             bm25TokenCacheSignature = signature;
             bm25TokenCache = new Map();
         }
-        const key = `${doc.source}|${doc.id}|${doc.text.length}|${doc.text.slice(0, 64)}`;
+        const channelText = channel === "fulltext"
+            ? ((doc.sourceText || "").trim() || (doc.summaryText || doc.text || ""))
+            : ((doc.summaryText || doc.text || "").trim());
+        const key = `${channel}:${doc.source}|${doc.id}|${channelText.length}|${channelText.slice(0, 64)}`;
         const cached = bm25TokenCache.get(key);
         if (cached) {
             return cached;
         }
-        const tokens = tokenize(doc.text);
+        const tokens = tokenize(channelText);
         bm25TokenCache.set(key, tokens);
         return tokens;
     }
     async function searchMemory(args) {
         const query = args.query?.trim();
         if (!query) {
-            return { results: [] };
+            return {
+                results: [],
+                semantic_results: [],
+                keyword_results: [],
+                strategy: "vector_sentence_and_keyword_parallel",
+            };
         }
         const mode = args.mode === "lightweight" ? "lightweight" : "default";
         const lightweightMode = mode === "lightweight";
@@ -1337,6 +1931,11 @@ function createReadStore(options) {
         const hitStats = loadHitStats();
         const intent = classifyIntent(query);
         const preferredTypes = preferredEventTypes(intent);
+        const plannedQueriesRaw = lightweightMode ? [query] : planQueryKeywords(query);
+        const plannedQueries = plannedQueriesRaw.length > 0 ? plannedQueriesRaw : [query];
+        const summaryChannelWeight = 1;
+        const fulltextChannelWeight = 0.35;
+        const maxCandidatePool = Math.max(1, Math.max(args.topK, 20));
         let queryEmbedding = null;
         const embeddingModel = options.embedding?.model || "";
         const embeddingApiKey = options.embedding?.apiKey || "";
@@ -1393,11 +1992,11 @@ function createReadStore(options) {
             }
         }
         const graphDocs = docs
-            .filter(doc => doc.source === "sessions_graph" || doc.source === "sessions_graph_entity")
+            .filter(doc => doc.source.startsWith("sessions_graph"))
             .map(doc => {
             const graphText = [
                 doc.text,
-                ...(doc.relations || []).map(relation => `${relation.source} ${relation.type} ${relation.target}`),
+                ...(doc.relations || []).map(relation => `${relation.source} ${relation.type} ${relation.target} ${relation.fact_status || doc.factStatus || "active"}`),
             ].join(" | ");
             return {
                 ...doc,
@@ -1406,153 +2005,302 @@ function createReadStore(options) {
         });
         const rulesDocs = docs.filter(doc => doc.source === "CORTEX_RULES.md");
         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(",")}`;
-        const bm25Stats = buildBm25Stats(bm25Corpus, bm25Terms, doc => getBm25Tokens(doc, bm25Signature));
-        const combinedCandidates = [];
-        const channels = {
-            rules: [],
-            archive: [],
-            vector: [],
-            graph: [],
+        const rankByQuery = (plannedQuery, includeFulltext) => {
+            const bm25Terms = tokenize(plannedQuery);
+            const bm25StatsSummary = buildBm25Stats(bm25Corpus, bm25Terms, doc => getBm25Tokens(doc, bm25Signature, "summary"));
+            const bm25StatsFulltext = includeFulltext
+                ? buildBm25Stats(bm25Corpus, bm25Terms, doc => getBm25Tokens(doc, bm25Signature, "fulltext"))
+                : { avgDocLen: 1, docFreq: new Map() };
+            const channels = {
+                rules: [],
+                archive: [],
+                vector: [],
+                graph: [],
+            };
+            const evaluateDoc = (doc, source) => {
+                const summaryText = (doc.summaryText || doc.text || "").trim();
+                const fulltextText = (doc.sourceText || "").trim();
+                const summaryBm25 = bm25Score({
+                    queryTerms: bm25Terms,
+                    docText: summaryText,
+                    docTokens: getBm25Tokens(doc, bm25Signature, "summary"),
+                    docCount: bm25Corpus.length,
+                    avgDocLen: bm25StatsSummary.avgDocLen,
+                    docFreq: bm25StatsSummary.docFreq,
+                });
+                const fulltextBm25 = includeFulltext
+                    ? bm25Score({
+                        queryTerms: bm25Terms,
+                        docText: fulltextText,
+                        docTokens: getBm25Tokens(doc, bm25Signature, "fulltext"),
+                        docCount: bm25Corpus.length,
+                        avgDocLen: bm25StatsFulltext.avgDocLen,
+                        docFreq: bm25StatsFulltext.docFreq,
+                    })
+                    : 0;
+                const summaryCombined = scoreText(plannedQuery, summaryText) + summaryBm25 * readTuning.scoring.bm25Scale;
+                const fulltextCombined = includeFulltext
+                    ? scoreText(plannedQuery, fulltextText) + fulltextBm25 * readTuning.scoring.bm25Scale
+                    : 0;
+                const lexicalCombined = summaryCombined * summaryChannelWeight + fulltextCombined * fulltextChannelWeight;
+                const semantic = plannedQuery === query && 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;
+                }
+                if (source === "graph") {
+                    const status = docFactStatus(doc);
+                    if (status === "superseded" || status === "rejected") {
+                        return null;
+                    }
+                }
+                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)
+                    : 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 = (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 {
+                    doc,
+                    source,
+                    lexical: lexicalCombined,
+                    bm25: summaryBm25 + fulltextBm25,
+                    semantic,
+                    recency,
+                    quality,
+                    typeMatch,
+                    graphMatch,
+                    decayFactor,
+                    weighted,
+                    summaryCombined,
+                    fulltextCombined,
+                };
+            };
+            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);
+            }
+            const rrfMap = new Map();
+            const weightedMap = new Map();
+            const rrfK = readTuning.rrf.k;
+            for (const key of Object.keys(channels)) {
+                const list = channels[key].sort((a, b) => b.weighted - a.weighted);
+                const capped = list.slice(0, channelQuota(key, args.topK, options.fusion));
+                for (let i = 0; i < capped.length; i += 1) {
+                    const candidate = capped[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);
+                    }
+                }
+            }
+            return [...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 || "",
+                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 || "",
+                fact_status: docFactStatus(candidate.doc),
+                wiki_ref: candidate.doc.wikiRef || "",
+                quality_score: candidate.quality,
+                timestamp: candidate.doc.timestamp ? new Date(candidate.doc.timestamp).toISOString() : "",
+                evidence_ids: docEvidenceIds(candidate.doc),
+                score: candidate.weighted + (rrfMap.get(mergeKey) || 0) * readTuning.rrf.weight,
+                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)),
+                    summary: Number(candidate.summaryCombined.toFixed(4)),
+                    fulltext: Number(candidate.fulltextCombined.toFixed(4)),
+                    decay: Number(candidate.decayFactor.toFixed(4)),
+                    rrf: Number(((rrfMap.get(mergeKey) || 0) * readTuning.rrf.weight).toFixed(4)),
+                    weighted: Number(candidate.weighted.toFixed(4)),
+                },
+                reason_tags: [
+                    `intent:${intent.toLowerCase()}`,
+                    candidate.summaryCombined > 0 ? "summary_hit" : "",
+                    candidate.fulltextCombined > 0 ? "fulltext_hit" : "",
+                    candidate.semantic > 0 ? "vector_hit" : "",
+                    candidate.lexical > 0 ? "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}`,
+                    `query_term:${plannedQuery}`,
+                ].filter(Boolean),
+                matched_keywords: [plannedQuery],
+            }))
+                .sort((a, b) => b.score - a.score)
+                .slice(0, maxCandidatePool);
         };
-        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 * 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 queryRuns = await Promise.all(plannedQueries.map(async (plannedQuery) => {
+            const stage1 = rankByQuery(plannedQuery, false);
+            const needFallback = shouldTriggerFulltextFallback(stage1, args.topK);
+            if (!needFallback || lightweightMode) {
+                return { plannedQuery, ranked: stage1, fulltextFallback: false };
+            }
+            const stage2 = rankByQuery(plannedQuery, true);
+            const merged = new Map();
+            for (const item of [...stage1, ...stage2]) {
+                const mergeKey = item.merge_key || item.id || "";
+                const existing = merged.get(mergeKey);
+                if (!existing) {
+                    merged.set(mergeKey, { ...item });
+                    continue;
+                }
+                const best = Number(item.score || 0) > Number(existing.score || 0)
+                    ? { ...existing, ...item }
+                    : { ...item, ...existing };
+                const mergedReasonTags = uniqueStrings([
+                    ...(Array.isArray(existing.reason_tags) ? existing.reason_tags.map(v => String(v)) : []),
+                    ...(Array.isArray(item.reason_tags) ? item.reason_tags.map(v => String(v)) : []),
+                ]);
+                const mergedEvidenceIds = uniqueStrings([
+                    ...(Array.isArray(existing.evidence_ids) ? existing.evidence_ids.map(v => String(v)) : []),
+                    ...(Array.isArray(item.evidence_ids) ? item.evidence_ids.map(v => String(v)) : []),
+                ]);
+                const mergedKeywords = uniqueStrings([
+                    ...(Array.isArray(existing.matched_keywords) ? existing.matched_keywords.map(v => String(v)) : []),
+                    ...(Array.isArray(item.matched_keywords) ? item.matched_keywords.map(v => String(v)) : []),
+                ]);
+                merged.set(mergeKey, {
+                    ...best,
+                    score: Math.max(existing.score || 0, item.score || 0),
+                    reason_tags: mergedReasonTags,
+                    evidence_ids: mergedEvidenceIds,
+                    matched_keywords: mergedKeywords,
+                });
             }
-            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)
-                : 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 = (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 {
-                doc,
-                source,
-                lexical: lexicalCombined,
-                bm25,
-                semantic,
-                recency,
-                quality,
-                typeMatch,
-                graphMatch,
-                decayFactor,
-                weighted,
+                plannedQuery,
+                ranked: [...merged.values()]
+                    .sort((a, b) => Number(b.score || 0) - Number(a.score || 0))
+                    .slice(0, maxCandidatePool)
+                    .map((item) => ({
+                    ...item,
+                    reason_tags: uniqueStrings([
+                        ...(Array.isArray(item.reason_tags) ? item.reason_tags.map((v) => String(v)) : []),
+                        "fulltext_fallback",
+                    ]),
+                })),
+                fulltextFallback: true,
             };
-        };
-        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 = readTuning.rrf.k;
-        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 mergedByQuery = new Map();
+        for (const run of queryRuns) {
+            for (const item of run.ranked) {
+                const mergeKey = item.merge_key || item.id || "";
+                const existing = mergedByQuery.get(mergeKey);
+                if (!existing) {
+                    mergedByQuery.set(mergeKey, {
+                        ...item,
+                        matched_keywords: uniqueStrings([run.plannedQuery]),
+                        fulltext_fallback_used: run.fulltextFallback,
+                    });
+                    continue;
                 }
+                const mergedReasonTags = uniqueStrings([
+                    ...(Array.isArray(existing.reason_tags) ? existing.reason_tags.map(v => String(v)) : []),
+                    ...(Array.isArray(item.reason_tags) ? item.reason_tags.map(v => String(v)) : []),
+                ]);
+                const mergedEvidenceIds = uniqueStrings([
+                    ...(Array.isArray(existing.evidence_ids) ? existing.evidence_ids.map(v => String(v)) : []),
+                    ...(Array.isArray(item.evidence_ids) ? item.evidence_ids.map(v => String(v)) : []),
+                ]);
+                const matchedKeywords = uniqueStrings([
+                    ...(Array.isArray(existing.matched_keywords) ? existing.matched_keywords.map(v => String(v)) : []),
+                    run.plannedQuery,
+                ]);
+                const preferred = Number(item.score || 0) > Number(existing.score || 0)
+                    ? { ...existing, ...item }
+                    : { ...item, ...existing };
+                mergedByQuery.set(mergeKey, {
+                    ...preferred,
+                    score: Math.max(existing.score || 0, item.score || 0),
+                    reason_tags: mergedReasonTags,
+                    evidence_ids: mergedEvidenceIds,
+                    matched_keywords: matchedKeywords,
+                    fulltext_fallback_used: Boolean(existing.fulltext_fallback_used) || run.fulltextFallback,
+                });
             }
         }
-        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 || "",
-            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) * readTuning.rrf.weight,
-            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) * readTuning.rrf.weight).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, Math.max(args.topK, 20)));
-        const lexicalRanked = preRanked
-            .map(doc => {
-            const boost = withRecencyBoost(doc.score, doc.timestamp ? Date.parse(doc.timestamp) : undefined, readTuning.recency.buckets);
-            return { ...doc, score: Number(boost.toFixed(4)) };
-        });
+        const lexicalRanked = [...mergedByQuery.values()]
+            .map((item) => {
+            const matchedKeywords = Array.isArray(item.matched_keywords)
+                ? uniqueStrings(item.matched_keywords.map(v => String(v)))
+                : [query];
+            const keywordBonus = Math.max(0, matchedKeywords.length - 1) * 0.12;
+            const boosted = withRecencyBoost(Number(item.score || 0) + keywordBonus, typeof item.timestamp === "string" ? Date.parse(item.timestamp) : undefined, readTuning.recency.buckets);
+            return {
+                ...item,
+                matched_keywords: matchedKeywords,
+                query_plan_keywords: plannedQueries,
+                score: Number(boosted.toFixed(4)),
+                reason_tags: uniqueStrings([
+                    ...(Array.isArray(item.reason_tags) ? item.reason_tags.map((v) => String(v)) : []),
+                    `keyword_hits:${matchedKeywords.length}`,
+                    `query_plan:${plannedQueries.length}`,
+                    Boolean(item.fulltext_fallback_used) ? "fulltext_fallback_used" : "",
+                ]),
+            };
+        })
+            .sort((a, b) => Number(b.score || 0) - Number(a.score || 0))
+            .slice(0, maxCandidatePool);
+        const isVectorSource = (value) => value.startsWith("vector_");
+        const semanticResults = lexicalRanked
+            .filter(item => isVectorSource(item.source) && Array.isArray(item.reason_tags) && item.reason_tags.includes("vector_hit"))
+            .slice(0, Math.max(1, args.topK));
+        const keywordResults = lexicalRanked
+            .filter(item => isVectorSource(item.source) && Array.isArray(item.reason_tags) && item.reason_tags.includes("lexical_hit"))
+            .slice(0, Math.max(1, args.topK));
         const rerankerModel = options.reranker?.model || "";
         const rerankerApiKey = options.reranker?.apiKey || "";
         const rerankerBaseUrl = normalizeBaseUrl(options.reranker?.baseURL || options.reranker?.baseUrl);
@@ -1604,8 +2352,11 @@ function createReadStore(options) {
                 source: item.source,
                 layer: hit?.layer || "",
                 event_type: hit?.event_type || "",
+                fact_status: hit?.fact_status || "active",
+                wiki_ref: hit?.wiki_ref || "",
                 quality_score: hit?.quality_score ?? 0,
                 timestamp: hit?.timestamp || "",
+                evidence_ids: Array.isArray(hit?.evidence_ids) ? hit?.evidence_ids : [],
                 score: Number(item.score.toFixed(4)),
                 score_breakdown: hit?.score_breakdown || {},
                 reason_tags: Array.isArray(hit?.reason_tags) ? hit?.reason_tags : [],
@@ -1618,6 +2369,9 @@ function createReadStore(options) {
                     channel: item.source,
                     source_file: hit?.source_file || "",
                     layer: hit?.layer || "",
+                    fact_status: hit?.fact_status || "active",
+                    wiki_ref: hit?.wiki_ref || "",
+                    evidence_ids: Array.isArray(hit?.evidence_ids) ? hit?.evidence_ids : [],
                     score_breakdown: hit?.score_breakdown || {},
                     reason_tags: Array.isArray(hit?.reason_tags) ? hit?.reason_tags : [],
                 },
@@ -1647,8 +2401,11 @@ function createReadStore(options) {
                     source: item.source,
                     layer: item.layer,
                     event_type: item.event_type,
+                    fact_status: item.fact_status || "active",
+                    wiki_ref: item.wiki_ref || "",
                     quality_score: item.quality_score,
                     timestamp: item.timestamp,
+                    evidence_ids: Array.isArray(item.evidence_ids) ? item.evidence_ids : [],
                     score: Number(item.score.toFixed(4)),
                     score_breakdown: item.score_breakdown || {},
                     reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
@@ -1661,6 +2418,9 @@ function createReadStore(options) {
                         channel: item.source,
                         source_file: item.source_file || "",
                         layer: item.layer,
+                        fact_status: item.fact_status || "active",
+                        wiki_ref: item.wiki_ref || "",
+                        evidence_ids: Array.isArray(item.evidence_ids) ? item.evidence_ids : [],
                         score_breakdown: item.score_breakdown || {},
                         reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
                     },
@@ -1689,8 +2449,11 @@ function createReadStore(options) {
                     source: item.source,
                     layer: item.layer,
                     event_type: item.event_type,
+                    fact_status: item.fact_status || "active",
+                    wiki_ref: item.wiki_ref || "",
                     quality_score: item.quality_score,
                     timestamp: item.timestamp,
+                    evidence_ids: Array.isArray(item.evidence_ids) ? item.evidence_ids : [],
                     score: Number(item.score.toFixed(4)),
                     score_breakdown: item.score_breakdown || {},
                     reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
@@ -1703,6 +2466,9 @@ function createReadStore(options) {
                         channel: item.source,
                         source_file: item.source_file || "",
                         layer: item.layer,
+                        fact_status: item.fact_status || "active",
+                        wiki_ref: item.wiki_ref || "",
+                        evidence_ids: Array.isArray(item.evidence_ids) ? item.evidence_ids : [],
                         score_breakdown: item.score_breakdown || {},
                         reason_tags: Array.isArray(item.reason_tags) ? item.reason_tags : [],
                     },
@@ -1742,6 +2508,18 @@ function createReadStore(options) {
                     if (!Array.isArray(fusion.evidence_ids) || fusion.evidence_ids.length === 0) {
                         throw new Error("fusion_missing_whitelisted_evidence");
                     }
+                    const fusedEvidenceIds = uniqueStrings(fusion.evidence_ids.flatMap(item => {
+                        const linked = ranked.find(candidate => candidate.id === item);
+                        if (!linked)
+                            return [item];
+                        const linkedEvidence = Array.isArray(linked.evidence_ids) ? linked.evidence_ids : [];
+                        return linkedEvidence.length > 0 ? linkedEvidence : [item];
+                    }));
+                    const wikiRefs = uniqueStrings(fusion.evidence_ids.flatMap(item => {
+                        const linked = ranked.find(candidate => candidate.id === item);
+                        const wikiRef = typeof linked?.wiki_ref === "string" ? linked.wiki_ref : "";
+                        return wikiRef ? [wikiRef] : [];
+                    }));
                     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 ||
@@ -1777,21 +2555,33 @@ function createReadStore(options) {
                         fused_risks: fusion.risks || [],
                         fused_action_items: fusion.action_items || [],
                         fused_conflicts: fusion.conflicts,
-                        fused_evidence_ids: fusion.evidence_ids,
+                        evidence_ids: fusedEvidenceIds,
+                        wiki_refs: wikiRefs,
+                        fused_evidence_ids: fusedEvidenceIds,
                         fused_need_fulltext_event_ids: fusion.need_fulltext_event_ids || [],
                         fulltext_fetch_hints: fulltextFetchHints,
                     };
                     const authoritative = options.fusion?.authoritative !== false;
                     if (authoritative) {
                         markHit(Array.isArray(fusion.evidence_ids) ? fusion.evidence_ids : []);
-                        return { results: [fusedItem] };
+                        return {
+                            results: [fusedItem],
+                            semantic_results: semanticResults,
+                            keyword_results: keywordResults,
+                            strategy: "vector_sentence_and_keyword_parallel",
+                        };
                     }
                     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)) };
+                    return {
+                        results: merged.slice(0, Math.max(1, args.topK)),
+                        semantic_results: semanticResults,
+                        keyword_results: keywordResults,
+                        strategy: "vector_sentence_and_keyword_parallel",
+                    };
                 }
             }
             catch (error) {
@@ -1800,7 +2590,12 @@ function createReadStore(options) {
         }
         const finalRanked = ranked.slice(0, Math.max(1, args.topK));
         markHit(finalRanked.map(item => item.id));
-        return { results: finalRanked };
+        return {
+            results: finalRanked,
+            semantic_results: semanticResults,
+            keyword_results: keywordResults,
+            strategy: "vector_sentence_and_keyword_parallel",
+        };
     }
     async function getHotContext(args) {
         const limit = Math.max(1, args.limit);