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

package/dist/src/engine/ts_engine.js

@@ -39,8 +39,10 @@ const path = __importStar(require("path"));
 const ontology_1 = require("../graph/ontology");
 const http_post_1 = require("../net/http_post");
 const llm_output_validator_1 = require("../quality/llm_output_validator");
+const wiki_projector_1 = require("../wiki/wiki_projector");
+const wiki_linter_1 = require("../wiki/wiki_linter");
 const PROMPT_VERSIONS = {
-    write_gate: "write-gate.v1.2.0",
+    write_gate: "write-gate.v1.7.9",
     session_end_write: "session-end-write.v1.2.0",
     read_fusion: "read-fusion.v1.2.0",
 };
@@ -160,39 +162,12 @@ function createTsEngine(deps) {
                 : (typeof record.text === "string" ? record.text.trim() : "");
             return content;
         }
+        const sourceText = typeof record.source_text === "string" ? record.source_text.trim() : "";
+        if (sourceText) {
+            return sourceText;
+        }
         const summary = typeof record.summary === "string" ? record.summary.trim() : "";
-        const eventType = typeof record.event_type === "string" ? record.event_type.trim() : "insight";
-        const outcome = typeof record.outcome === "string" ? record.outcome.trim() : "";
-        const sourceFile = typeof record.source_file === "string" ? record.source_file.trim() : "";
-        const actor = typeof record.actor === "string" ? record.actor.trim() : "";
-        const entities = Array.isArray(record.entities)
-            ? record.entities.filter(v => typeof v === "string").map(v => String(v).trim()).filter(Boolean)
-            : [];
-        const relations = Array.isArray(record.relations)
-            ? record.relations
-                .map(v => {
-                if (!v || typeof v !== "object")
-                    return "";
-                const relation = v;
-                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 "";
-                return `${source} -[${type}]-> ${target}`;
-            })
-                .filter(Boolean)
-            : [];
-        const lines = [
-            `event_type: ${eventType}`,
-            `summary: ${summary}`,
-            `outcome: ${outcome}`,
-            `entities: ${entities.join(", ")}`,
-            `source_file: ${sourceFile}`,
-            `actor: ${actor}`,
-            relations.length > 0 ? `relations: ${relations.join(" ; ")}` : "",
-        ].filter(Boolean);
-        return lines.join("\n").trim();
+        return summary;
     }
     function splitTextChunks(text, chunkSize, chunkOverlap) {
         const normalizedSize = Number.isFinite(chunkSize) && chunkSize >= 200 ? Math.floor(chunkSize) : 600;
@@ -245,6 +220,32 @@ function createTsEngine(deps) {
         }
         return output;
     }
+    function pickEvidenceChunks(chunks, maxCount) {
+        if (!chunks.length || maxCount <= 0)
+            return [];
+        if (chunks.length <= maxCount)
+            return chunks;
+        const picked = new Map();
+        picked.set(chunks[0].index, chunks[0]);
+        if (maxCount >= 2) {
+            const mid = chunks[Math.floor(chunks.length / 2)];
+            picked.set(mid.index, mid);
+        }
+        if (maxCount >= 3) {
+            const last = chunks[chunks.length - 1];
+            picked.set(last.index, last);
+        }
+        if (picked.size < maxCount) {
+            for (const chunk of chunks) {
+                if (!picked.has(chunk.index)) {
+                    picked.set(chunk.index, chunk);
+                }
+                if (picked.size >= maxCount)
+                    break;
+            }
+        }
+        return [...picked.values()].sort((a, b) => a.index - b.index).slice(0, maxCount);
+    }
     function upsertJsonFile(filePath, patch) {
         const current = parseJsonFile(filePath) || {};
         const next = { ...current, ...patch };
@@ -468,6 +469,27 @@ function createTsEngine(deps) {
                     : typeof rawArgs.event?.outcome === "string"
                         ? String(rawArgs.event.outcome)
                         : "";
+            const causeValue = typeof rawArgs.cause === "string"
+                ? rawArgs.cause
+                : typeof rawArgs.input?.cause === "string"
+                    ? String(rawArgs.input.cause)
+                    : typeof rawArgs.event?.cause === "string"
+                        ? String(rawArgs.event.cause)
+                        : "";
+            const processValue = typeof rawArgs.process === "string"
+                ? rawArgs.process
+                : typeof rawArgs.input?.process === "string"
+                    ? String(rawArgs.input.process)
+                    : typeof rawArgs.event?.process === "string"
+                        ? String(rawArgs.event.process)
+                        : "";
+            const resultValue = typeof rawArgs.result === "string"
+                ? rawArgs.result
+                : typeof rawArgs.input?.result === "string"
+                    ? String(rawArgs.input.result)
+                    : typeof rawArgs.event?.result === "string"
+                        ? String(rawArgs.event.result)
+                        : "";
             const entityTypesInput = typeof rawArgs.entity_types === "object" && rawArgs.entity_types !== null
                 ? rawArgs.entity_types
                 : typeof rawArgs.input?.entity_types === "object"
@@ -490,6 +512,9 @@ function createTsEngine(deps) {
                 {
                     event_type: "manual_event",
                     summary: normalizedSummary,
+                    cause: causeValue.trim() || normalizedSummary,
+                    process: processValue.trim() || normalizedSummary,
+                    result: resultValue.trim() || outcomeValue.trim() || normalizedSummary,
                     entities,
                     relations,
                     entity_types: entityTypes,
@@ -506,12 +531,23 @@ function createTsEngine(deps) {
             }
             const storedId = result.stored[0].id;
             if (deps.graphMemoryStore && entities.length > 0 && Object.keys(entityTypes).length > 0 && relations.length > 0) {
+                const graphSummary = normalizedSummary.toLowerCase().includes("entities:")
+                    ? normalizedSummary
+                    : `${normalizedSummary} Entities: ${entities.join(", ")}.`;
                 const graphResult = await deps.graphMemoryStore.append({
                     sourceEventId: storedId,
                     sourceLayer: "archive_event",
                     archiveEventId: storedId,
                     sessionId: "manual",
                     sourceFile: "ts_store_event",
+                    summary: graphSummary,
+                    source_text_nav: {
+                        layer: "archive_event",
+                        session_id: "manual",
+                        source_file: "ts_store_event",
+                        source_memory_id: storedId,
+                        source_event_id: storedId,
+                    },
                     eventType: "manual_event",
                     entities,
                     entity_types: entityTypes,
@@ -544,30 +580,19 @@ function createTsEngine(deps) {
         const pathTo = typeof args.path_to === "string" && args.path_to.trim() ? args.path_to.trim() : "";
         const maxDepth = Math.max(2, Math.min(4, typeof args.max_depth === "number" ? Math.floor(args.max_depth) : 3));
         const graphMemoryPath = path.join(deps.memoryRoot, "graph", "memory.jsonl");
+        const projectionIndexPath = path.join(deps.memoryRoot, "wiki", ".projection_index.json");
         const nodes = new Map();
         const edges = [];
-        const adjacency = new Map();
         const pathAdjacency = new Map();
         const relationTypeDistribution = new Map();
         const edgeKeySet = new Set();
-        function pushEdge(source, target, type) {
-            const key = `${source}|${type}|${target}`;
-            if (edgeKeySet.has(key)) {
-                return;
-            }
-            edgeKeySet.add(key);
-            edges.push({ source, target, type });
-            relationTypeDistribution.set(type, (relationTypeDistribution.get(type) || 0) + 1);
-            if (!adjacency.has(source)) {
-                adjacency.set(source, []);
-            }
-            adjacency.get(source)?.push({ next: target, edge: { source, target, type } });
-            if (!adjacency.has(target)) {
-                adjacency.set(target, []);
-            }
-            adjacency.get(target)?.push({ next: source, edge: { source, target, type } });
+        const allEdges = [];
+        function relationKeyOf(source, type, target) {
+            return `${source.trim().toLowerCase()}|${type.trim().toLowerCase()}|${target.trim().toLowerCase()}`;
         }
-        function pushPathEdge(source, target, type) {
+        function pushPathEdge(edge) {
+            const source = edge.source;
+            const target = edge.target;
             if (!pathAdjacency.has(source)) {
                 pathAdjacency.set(source, []);
             }
@@ -575,69 +600,170 @@ function createTsEngine(deps) {
                 pathAdjacency.set(target, []);
             }
             if (direction === "incoming") {
-                pathAdjacency.get(target)?.push({ next: source, edge: { source, target, type } });
+                pathAdjacency.get(target)?.push({ next: source, edge });
             }
             else if (direction === "outgoing") {
-                pathAdjacency.get(source)?.push({ next: target, edge: { source, target, type } });
+                pathAdjacency.get(source)?.push({ next: target, edge });
             }
             else {
-                pathAdjacency.get(source)?.push({ next: target, edge: { source, target, type } });
-                pathAdjacency.get(target)?.push({ next: source, edge: { source, target, type } });
+                pathAdjacency.get(source)?.push({ next: target, edge });
+                pathAdjacency.get(target)?.push({ next: source, edge });
             }
         }
-        const graphRecords = fs.existsSync(graphMemoryPath) ? readJsonl(graphMemoryPath) : [];
-        for (const record of graphRecords) {
-            const entities = Array.isArray(record.entities) ? record.entities : [];
-            const named = entities.map((e) => (typeof e === "string" ? e.trim() : "")).filter(Boolean);
-            const relations = Array.isArray(record.relations) ? record.relations : [];
-            let explicitMatched = false;
-            for (const relationRaw of relations) {
-                if (typeof relationRaw !== "object" || relationRaw === null) {
-                    continue;
-                }
-                const relation = relationRaw;
-                const source = typeof relation.source === "string" ? relation.source.trim() : "";
-                const target = typeof relation.target === "string" ? relation.target.trim() : "";
-                const type = (0, ontology_1.normalizeRelationType)(typeof relation.type === "string" && relation.type.trim() ? relation.type.trim() : "related_to", graphSchema);
-                if (!source || !target) {
-                    continue;
-                }
-                if (relFilter && type !== relFilter) {
+        function normalizeStatus(value) {
+            const token = (value || "").trim().toLowerCase();
+            if (token === "pending" || token === "pending_conflict")
+                return "pending_conflict";
+            if (token === "superseded")
+                return "superseded";
+            if (token === "rejected")
+                return "rejected";
+            return "active";
+        }
+        const viewData = deps.graphMemoryStore?.exportGraphView();
+        if (viewData && Array.isArray(viewData.edges)) {
+            for (const edge of viewData.edges) {
+                const source = typeof edge.source === "string" ? edge.source.trim() : "";
+                const target = typeof edge.target === "string" ? edge.target.trim() : "";
+                const type = (0, ontology_1.normalizeRelationType)(typeof edge.type === "string" ? edge.type : "related_to", graphSchema);
+                if (!source || !target)
                     continue;
+                const relationKey = typeof edge.relation_key === "string" && edge.relation_key.trim()
+                    ? edge.relation_key.trim().toLowerCase()
+                    : relationKeyOf(source, type, target);
+                allEdges.push({
+                    source,
+                    target,
+                    type,
+                    fact_status: normalizeStatus(typeof edge.status === "string" ? edge.status : "active"),
+                    relation_key: relationKey,
+                    source_event_id: typeof edge.source_event_id === "string" ? edge.source_event_id : undefined,
+                    evidence_span: typeof edge.evidence_span === "string" ? edge.evidence_span : undefined,
+                    confidence: typeof edge.confidence === "number" ? edge.confidence : undefined,
+                    conflict_id: typeof edge.conflict_id === "string" ? edge.conflict_id : undefined,
+                    evidence_ids: [],
+                });
+            }
+        }
+        if (allEdges.length === 0) {
+            const graphRecords = deps.graphMemoryStore
+                ? deps.graphMemoryStore.loadAll()
+                : (fs.existsSync(graphMemoryPath) ? readJsonl(graphMemoryPath) : []);
+            for (const record of graphRecords) {
+                const sourceEventId = typeof record.source_event_id === "string" ? record.source_event_id.trim() : "";
+                const relations = Array.isArray(record.relations) ? record.relations : [];
+                for (const relationRaw of relations) {
+                    if (typeof relationRaw !== "object" || relationRaw === null)
+                        continue;
+                    const relation = relationRaw;
+                    const source = typeof relation.source === "string" ? relation.source.trim() : "";
+                    const target = typeof relation.target === "string" ? relation.target.trim() : "";
+                    const type = (0, ontology_1.normalizeRelationType)(typeof relation.type === "string" && relation.type.trim() ? relation.type.trim() : "related_to", graphSchema);
+                    if (!source || !target)
+                        continue;
+                    allEdges.push({
+                        source,
+                        target,
+                        type,
+                        fact_status: "active",
+                        relation_key: relationKeyOf(source, type, target),
+                        source_event_id: sourceEventId || undefined,
+                        evidence_span: typeof relation.evidence_span === "string" ? relation.evidence_span.trim() : undefined,
+                        confidence: typeof relation.confidence === "number" ? relation.confidence : undefined,
+                        evidence_ids: [],
+                    });
                 }
-                pushPathEdge(source, target, type);
-                const outgoingMatch = source === entity;
-                const incomingMatch = target === entity;
-                const directionMatched = direction === "both" ? (outgoingMatch || incomingMatch)
-                    : direction === "outgoing" ? outgoingMatch
-                        : incomingMatch;
-                if (!directionMatched) {
-                    continue;
+            }
+        }
+        const projectionIndex = parseJsonFile(projectionIndexPath);
+        const entityWikiPathByName = new Map();
+        const topicWikiPathByType = new Map();
+        const projectionEntities = Array.isArray(projectionIndex?.entities) ? projectionIndex.entities : [];
+        const projectionTopics = Array.isArray(projectionIndex?.topics) ? projectionIndex.topics : [];
+        for (const item of projectionEntities) {
+            if (!item || typeof item !== "object")
+                continue;
+            const row = item;
+            const name = typeof row.name === "string" ? row.name.trim() : "";
+            const wikiPath = typeof row.path === "string" ? row.path.trim() : "";
+            if (!name || !wikiPath)
+                continue;
+            entityWikiPathByName.set(name.toLowerCase(), wikiPath);
+        }
+        for (const item of projectionTopics) {
+            if (!item || typeof item !== "object")
+                continue;
+            const row = item;
+            const topic = typeof row.type === "string" ? row.type.trim() : "";
+            const wikiPath = typeof row.path === "string" ? row.path.trim() : "";
+            if (!topic || !wikiPath)
+                continue;
+            topicWikiPathByType.set(topic.toLowerCase(), wikiPath);
+        }
+        function statusAnchor(status) {
+            if (status === "active")
+                return "current-facts";
+            if (status === "pending_conflict")
+                return "disputed-facts";
+            return "history";
+        }
+        function buildEvidenceIdsForEdge(edge) {
+            const ids = [
+                `graph:relation:${edge.relation_key}`,
+                edge.source_event_id ? `graph:event:${edge.source_event_id}` : "",
+                edge.evidence_span ? `graph:evidence:${edge.source_event_id || edge.relation_key}` : "",
+                edge.conflict_id ? `graph:conflict:${edge.conflict_id}` : "",
+            ];
+            const anchor = statusAnchor(edge.fact_status);
+            for (const name of [edge.source, edge.target]) {
+                const wikiPath = entityWikiPathByName.get(name.toLowerCase());
+                if (wikiPath) {
+                    ids.push(`wiki:${wikiPath}#${anchor}`);
                 }
-                explicitMatched = true;
-                if (!nodes.has(source))
-                    nodes.set(source, { id: source, type: "entity" });
-                if (!nodes.has(target))
-                    nodes.set(target, { id: target, type: "entity" });
-                pushEdge(source, target, type);
             }
-            if (explicitMatched) {
+            const topicPath = topicWikiPathByType.get(edge.type.toLowerCase());
+            if (topicPath) {
+                ids.push(`wiki:${topicPath}#relations`);
+            }
+            return [...new Set(ids.filter(Boolean))];
+        }
+        let explicitMatched = false;
+        for (const edge of allEdges) {
+            if (relFilter && edge.type !== relFilter) {
                 continue;
             }
-            if (!named.includes(entity)) {
+            const pathEligible = edge.fact_status === "active" || edge.fact_status === "pending_conflict";
+            if (pathEligible) {
+                pushPathEdge(edge);
+            }
+            const outgoingMatch = edge.source === entity;
+            const incomingMatch = edge.target === entity;
+            const directionMatched = direction === "both" ? (outgoingMatch || incomingMatch)
+                : direction === "outgoing" ? outgoingMatch
+                    : incomingMatch;
+            if (!directionMatched) {
                 continue;
             }
-            for (const name of named) {
-                if (!nodes.has(name)) {
-                    nodes.set(name, { id: name, type: "entity" });
-                }
+            explicitMatched = true;
+            const edgeKey = `${edge.relation_key}|${edge.fact_status}|${edge.conflict_id || ""}`;
+            if (edgeKeySet.has(edgeKey)) {
+                continue;
             }
-            for (const name of named) {
-                if (name !== entity) {
-                    if (!relFilter || relFilter === "co_occurrence") {
-                        pushEdge(entity, name, "co_occurrence");
-                    }
-                }
+            edgeKeySet.add(edgeKey);
+            const enrichedEdge = {
+                ...edge,
+                evidence_ids: buildEvidenceIdsForEdge(edge),
+            };
+            edges.push(enrichedEdge);
+            relationTypeDistribution.set(enrichedEdge.type, (relationTypeDistribution.get(enrichedEdge.type) || 0) + 1);
+            if (!nodes.has(enrichedEdge.source))
+                nodes.set(enrichedEdge.source, { id: enrichedEdge.source, type: "entity" });
+            if (!nodes.has(enrichedEdge.target))
+                nodes.set(enrichedEdge.target, { id: enrichedEdge.target, type: "entity" });
+        }
+        if (!explicitMatched) {
+            if (!nodes.has(entity)) {
+                nodes.set(entity, { id: entity, type: "entity" });
             }
         }
         let graphPath = [];
@@ -671,6 +797,34 @@ function createTsEngine(deps) {
                 }
             }
         }
+        const statusCounts = {
+            active: 0,
+            pending_conflict: 0,
+            superseded: 0,
+            rejected: 0,
+        };
+        const wikiRefSet = new Set();
+        if (entityWikiPathByName.has(entity.toLowerCase())) {
+            wikiRefSet.add(`wiki/${entityWikiPathByName.get(entity.toLowerCase())}`);
+        }
+        for (const edge of edges) {
+            statusCounts[edge.fact_status] += 1;
+            for (const name of [edge.source, edge.target]) {
+                const wikiPath = entityWikiPathByName.get(name.toLowerCase());
+                if (wikiPath) {
+                    wikiRefSet.add(`wiki/${wikiPath}`);
+                }
+            }
+            const topicPath = topicWikiPathByType.get(edge.type.toLowerCase());
+            if (topicPath) {
+                wikiRefSet.add(`wiki/${topicPath}`);
+            }
+        }
+        const evidenceIds = [...new Set(edges.flatMap(edge => edge.evidence_ids).filter(Boolean))];
+        const conflictEdges = edges.filter(edge => edge.fact_status === "pending_conflict" || edge.fact_status === "rejected");
+        const pendingCount = conflictEdges.filter(edge => edge.fact_status === "pending_conflict").length;
+        const rejectedCount = conflictEdges.filter(edge => edge.fact_status === "rejected").length;
+        const conflictIds = [...new Set(conflictEdges.map(edge => edge.conflict_id).filter((item) => !!item))];
         return {
             success: true,
             data: {
@@ -679,13 +833,61 @@ function createTsEngine(deps) {
                 dir: direction,
                 nodes: [...nodes.values()],
                 edges,
+                status_counts: statusCounts,
                 path_to: pathTo || "",
                 max_depth: maxDepth,
                 path: graphPath,
+                wiki_refs: [...wikiRefSet],
+                evidence_ids: evidenceIds,
+                conflict_hint: conflictEdges.length > 0
+                    ? {
+                        pending_count: pendingCount,
+                        rejected_count: rejectedCount,
+                        conflict_ids: conflictIds,
+                        suggestion: pendingCount > 0
+                            ? "Pending graph conflicts found. Call list_graph_conflicts first, then resolve_graph_conflict(accept/reject)."
+                            : "Rejected candidate facts exist. Submit stronger evidence if you want to update the graph.",
+                    }
+                    : undefined,
                 relation_type_distribution: [...relationTypeDistribution.entries()].map(([type, count]) => ({ type, count })),
             },
         };
     }
+    async function exportGraphView(args, _context) {
+        if (!deps.graphMemoryStore) {
+            return { success: false, error: "Graph memory store is not available." };
+        }
+        const writeSnapshot = args.write_snapshot !== false;
+        const view = deps.graphMemoryStore.exportGraphView();
+        const projection = writeSnapshot
+            ? (0, wiki_projector_1.writeGraphViewProjection)({
+                memoryRoot: deps.memoryRoot,
+                view,
+            })
+            : null;
+        return {
+            success: true,
+            data: {
+                ...view,
+                snapshot_written: writeSnapshot,
+                projection,
+            },
+        };
+    }
+    async function lintMemoryWiki(_args, _context) {
+        if (!deps.graphMemoryStore) {
+            return { success: false, error: "Graph memory store is not available." };
+        }
+        const graphView = deps.graphMemoryStore.exportGraphView();
+        const report = (0, wiki_linter_1.lintMemoryWiki)({
+            memoryRoot: deps.memoryRoot,
+            graphView,
+        });
+        return {
+            success: true,
+            data: report,
+        };
+    }
     async function deleteMemory(args, _context) {
         const targetId = args.memory_id?.trim();
         if (!targetId) {
@@ -814,6 +1016,16 @@ function createTsEngine(deps) {
         if (layer === "all" || layer === "archive") {
             targetFiles.push({ layer: "archive", filePath: archivePath });
         }
+        const vectorJsonlPath = path.join(deps.memoryRoot, "vector", "lancedb_events.jsonl");
+        const vectorJsonlRecords = readJsonl(vectorJsonlPath);
+        const vectorSourceIndex = new Set();
+        for (const row of vectorJsonlRecords) {
+            const rowLayer = row.layer === "active" || row.layer === "archive" ? row.layer : "";
+            const sourceMemoryId = typeof row.source_memory_id === "string" ? row.source_memory_id.trim() : "";
+            if (!rowLayer || !sourceMemoryId)
+                continue;
+            vectorSourceIndex.add(`${rowLayer}|${sourceMemoryId}`);
+        }
         const queue = [];
         const recordsByFile = new Map();
         for (const target of targetFiles) {
@@ -827,6 +1039,7 @@ function createTsEngine(deps) {
                 }
                 const status = typeof record.embedding_status === "string" ? record.embedding_status.trim() : "";
                 const hasEmbedding = Array.isArray(record.embedding) && record.embedding.length > 0;
+                const hasVectorRows = vectorSourceIndex.has(`${target.layer}|${id}`);
                 if (forceRebuild) {
                     queue.push({ layer: target.layer, filePath: target.filePath, index: i });
                     continue;
@@ -836,7 +1049,7 @@ function createTsEngine(deps) {
                         continue;
                     }
                 }
-                else if (status === "ok" || hasEmbedding) {
+                else if ((status === "ok" || hasEmbedding) && hasVectorRows) {
                     continue;
                 }
                 const failCountRaw = failureCountState[id];
@@ -882,7 +1095,48 @@ function createTsEngine(deps) {
                 }
                 const chunkSize = deps.vectorChunking?.chunkSize ?? 600;
                 const chunkOverlap = deps.vectorChunking?.chunkOverlap ?? 100;
-                const chunks = splitTextChunks(text, chunkSize, chunkOverlap);
+                const evidenceMaxChunks = typeof deps.vectorChunking?.evidenceMaxChunks === "number"
+                    ? Math.max(0, Math.min(8, Math.floor(deps.vectorChunking.evidenceMaxChunks)))
+                    : 2;
+                let chunks = [];
+                if (item.layer === "archive") {
+                    const summaryText = typeof record.summary === "string" ? record.summary.trim() : "";
+                    const sourceText = typeof record.source_text === "string" ? record.source_text.trim() : "";
+                    const summaryChunk = summaryText
+                        ? [{
+                                index: 0,
+                                start: 0,
+                                end: summaryText.length,
+                                text: summaryText,
+                                source_field: "summary",
+                            }]
+                        : [];
+                    const evidenceChunks = sourceText
+                        ? pickEvidenceChunks(splitTextChunks(sourceText, chunkSize, chunkOverlap), evidenceMaxChunks)
+                        : [];
+                    chunks = [
+                        ...summaryChunk,
+                        ...evidenceChunks.map((chunk, idx) => ({
+                            index: idx + summaryChunk.length,
+                            start: chunk.start,
+                            end: chunk.end,
+                            text: chunk.text,
+                            source_field: "evidence",
+                        })),
+                    ];
+                    if (chunks.length === 0 && text) {
+                        chunks = splitTextChunks(text, chunkSize, chunkOverlap).map(chunk => ({
+                            ...chunk,
+                            source_field: "summary",
+                        }));
+                    }
+                }
+                else {
+                    chunks = splitTextChunks(text, chunkSize, chunkOverlap).map(chunk => ({
+                        ...chunk,
+                        source_field: "summary",
+                    }));
+                }
                 if (chunks.length === 0) {
                     record.embedding_status = "failed";
                     failed += 1;
@@ -920,6 +1174,8 @@ function createTsEngine(deps) {
                             layer: item.layer,
                             source_memory_id: id,
                             source_memory_canonical_id: typeof record.canonical_id === "string" ? record.canonical_id : id,
+                            source_event_id: typeof record.source_event_id === "string" ? record.source_event_id : id,
+                            source_field: chunk.source_field,
                             outcome: typeof record.outcome === "string" ? record.outcome : "",
                             entities: Array.isArray(record.entities) ? record.entities.filter(v => typeof v === "string") : [],
                             relations: Array.isArray(record.relations)
@@ -1222,6 +1478,9 @@ function createTsEngine(deps) {
             const refId = stringField(record, "source_event_id") || stringField(record, "archive_event_id");
             return sourceLayer === "archive_event" && !!refId && archiveIdSet.has(refId);
         }).length;
+        const graphConflictStats = deps.graphMemoryStore
+            ? deps.graphMemoryStore.getConflictStats()
+            : { pending: 0, accepted: 0, rejected: 0 };
         const schemaIssueTotal = Object.values(activeFieldIssues).reduce((sum, n) => sum + n, 0)
             + Object.values(archiveFieldIssues).reduce((sum, n) => sum + n, 0)
             + Object.values(vectorFieldIssues).reduce((sum, n) => sum + n, 0)
@@ -1273,6 +1532,7 @@ function createTsEngine(deps) {
                     },
                     graph_rules: {
                         graph_mutation_log_exists: fs.existsSync(path.join(deps.memoryRoot, "graph", "mutation_log.jsonl")),
+                        graph_conflicts: graphConflictStats,
                         rules_exists: fs.existsSync(path.join(deps.memoryRoot, "CORTEX_RULES.md")),
                     },
                 },
@@ -1347,7 +1607,15 @@ function createTsEngine(deps) {
             query,
             topK: typeof topKRaw === "number" && topKRaw > 0 ? Math.floor(topKRaw) : 3,
         });
-        return { success: true, data: result.results };
+        return {
+            success: true,
+            data: {
+                results: result.results,
+                vector_semantic_results: result.semantic_results,
+                vector_keyword_results: result.keyword_results,
+                vector_search_strategy: result.strategy,
+            },
+        };
     }
     async function getHotContext(args, _context) {
         const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 20;
@@ -1382,6 +1650,49 @@ function createTsEngine(deps) {
         }
         return { success: true, data: result };
     }
+    async function listGraphConflicts(args, _context) {
+        if (!deps.graphMemoryStore) {
+            return { success: false, error: "Graph memory store is not available." };
+        }
+        const status = args.status === "pending" || args.status === "accepted" || args.status === "rejected" || args.status === "all"
+            ? args.status
+            : "pending";
+        const limit = typeof args.limit === "number" && Number.isFinite(args.limit) && args.limit > 0
+            ? Math.min(500, Math.floor(args.limit))
+            : 50;
+        const items = deps.graphMemoryStore.listConflicts({ status, limit });
+        return { success: true, data: { status, count: items.length, items } };
+    }
+    async function resolveGraphConflict(args, _context) {
+        if (!deps.graphMemoryStore) {
+            return { success: false, error: "Graph memory store is not available." };
+        }
+        const conflictId = (args.conflict_id || "").trim();
+        const action = args.action === "accept" || args.action === "reject" ? args.action : null;
+        if (!conflictId) {
+            return { success: false, error: "Invalid input provided. Missing 'conflict_id' parameter." };
+        }
+        if (!action) {
+            return { success: false, error: "Invalid input provided. 'action' must be accept or reject." };
+        }
+        const note = typeof args.note === "string" ? args.note.trim() : undefined;
+        const result = await deps.graphMemoryStore.resolveConflict({
+            conflictId,
+            action,
+            note,
+        });
+        if (!result.success) {
+            return { success: false, error: result.reason || "resolve_graph_conflict_failed" };
+        }
+        return {
+            success: true,
+            data: {
+                conflict_id: conflictId,
+                action,
+                applied_record_id: result.appliedRecordId,
+            },
+        };
+    }
     async function syncMemory(_args, _context) {
         try {
             const result = await deps.sessionSync.syncMemory();
@@ -1475,6 +1786,10 @@ function createTsEngine(deps) {
         getAutoContext,
         storeEvent,
         queryGraph,
+        exportGraphView,
+        lintMemoryWiki,
+        listGraphConflicts,
+        resolveGraphConflict,
         reflectMemory,
         syncMemory,
         promoteMemory,