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

package/dist/src/store/graph_memory_store.js

@@ -39,6 +39,15 @@ const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
 const ontology_1 = require("../graph/ontology");
 const llm_output_validator_1 = require("../quality/llm_output_validator");
+const wiki_queue_1 = require("../wiki/wiki_queue");
+const wiki_logger_1 = require("../wiki/wiki_logger");
+const wiki_maintainer_1 = require("../wiki/wiki_maintainer");
+const SINGLE_VALUE_RELATION_TYPES = new Set([
+    "birthday_on",
+    "anniversary_on",
+    "has_spouse",
+    "lives_in",
+]);
 function ensureDirForFile(filePath) {
     const dir = path.dirname(filePath);
     if (!fs.existsSync(dir)) {
@@ -48,10 +57,362 @@ function ensureDirForFile(filePath) {
 function generateGraphId() {
     return `gph_${Date.now().toString(36)}_${crypto.randomBytes(4).toString("hex")}`;
 }
+function generateConflictId() {
+    return `gcf_${Date.now().toString(36)}_${crypto.randomBytes(4).toString("hex")}`;
+}
+function relationKey(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 relationBucketKey(relation) {
+    const source = (relation.source || "").trim().toLowerCase();
+    const type = (relation.type || "related_to").trim().toLowerCase();
+    return `${source}|${type}`;
+}
+function normalizeSummary(value) {
+    return String(value || "").trim().replace(/\s+/g, " ").toLowerCase();
+}
+function buildStructureSignature(record) {
+    const entities = (record.entities || [])
+        .map(item => String(item || "").trim().toLowerCase())
+        .filter(Boolean)
+        .sort();
+    const relations = (record.relations || [])
+        .map(item => {
+        const source = String(item.source || "").trim().toLowerCase();
+        const type = String(item.type || "").trim().toLowerCase();
+        const target = String(item.target || "").trim().toLowerCase();
+        const evidence = String(item.evidence_span || "").trim().toLowerCase();
+        const context = String(item.context_chunk || "").trim().toLowerCase();
+        return `${source}|${type}|${target}|${evidence}|${context}`;
+    })
+        .filter(Boolean)
+        .sort();
+    return `${entities.join("||")}#${relations.join("||")}`;
+}
+function buildFallbackSummary(entities, relations) {
+    const entityText = (entities || []).map(item => String(item || "").trim()).filter(Boolean).join(", ");
+    const relationText = (relations || [])
+        .slice(0, 3)
+        .map(item => `${item.source} ${item.type} ${item.target}`)
+        .join("; ");
+    return `Graph memory update covering entities [${entityText || "n/a"}] with relations [${relationText || "n/a"}].`;
+}
+function toConflictSummary(record) {
+    return {
+        conflict_id: record.conflict_id,
+        status: record.status,
+        created_at: record.created_at,
+        updated_at: record.updated_at,
+        source_event_id: record.source_event_id,
+        session_id: record.session_id,
+        conflict_reason: record.conflict_reason,
+        conflict_types: record.conflict_types,
+        existing_relation_keys: record.existing_relation_keys,
+        candidate_relations: (record.candidate.relations || []).map(rel => ({
+            source: rel.source,
+            type: rel.type,
+            target: rel.target,
+        })),
+        resolution: record.resolution,
+    };
+}
 function createGraphMemoryStore(options) {
     const graphMemoryPath = path.join(options.memoryRoot, "graph", "memory.jsonl");
     const mutationLogPath = path.join(options.memoryRoot, "graph", "mutation_log.jsonl");
+    const conflictQueuePath = path.join(options.memoryRoot, "graph", "conflict_queue.jsonl");
+    const supersededRelationPath = path.join(options.memoryRoot, "graph", "superseded_relations.jsonl");
     const graphSchema = (0, ontology_1.loadGraphSchema)(options.projectRoot);
+    const wikiProjectionEnabled = options.wikiProjection?.enabled === true && options.wikiProjection?.mode !== "off";
+    const wikiProjectionMaxBatch = typeof options.wikiProjection?.maxBatch === "number" && Number.isFinite(options.wikiProjection.maxBatch)
+        ? Math.max(1, Math.min(1000, Math.floor(options.wikiProjection.maxBatch)))
+        : 100;
+    function triggerWikiMaintenance(input) {
+        if (!wikiProjectionEnabled) {
+            return;
+        }
+        try {
+            (0, wiki_queue_1.appendWikiRebuildEvent)({
+                memoryRoot: options.memoryRoot,
+                type: input.type,
+                source_event_id: input.sourceEventId,
+                conflict_id: input.conflictId,
+                entities: input.entities,
+                relation_types: input.relationTypes,
+            });
+            (0, wiki_logger_1.appendWikiLog)({
+                memoryRoot: options.memoryRoot,
+                type: input.type,
+                source_event_id: input.sourceEventId,
+                conflict_id: input.conflictId,
+                message: input.message,
+            });
+            const graphView = exportGraphView();
+            (0, wiki_maintainer_1.maintainWikiProjection)({
+                memoryRoot: options.memoryRoot,
+                graphView,
+                maxBatch: wikiProjectionMaxBatch,
+                logger: options.logger,
+            });
+        }
+        catch (error) {
+            options.logger.warn(`wiki_projection_maintenance_failed reason=${String(error)}`);
+        }
+    }
+    function loadSupersededRelationEntries() {
+        if (!fs.existsSync(supersededRelationPath)) {
+            return [];
+        }
+        const lines = fs.readFileSync(supersededRelationPath, "utf-8").split(/\r?\n/).filter(Boolean);
+        const entries = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                const relationKeyRaw = typeof parsed.relation_key === "string" ? parsed.relation_key.trim().toLowerCase() : "";
+                if (!relationKeyRaw) {
+                    continue;
+                }
+                entries.push({
+                    relation_key: relationKeyRaw,
+                    superseded_at: typeof parsed.superseded_at === "string" ? parsed.superseded_at : "",
+                    conflict_id: typeof parsed.conflict_id === "string" ? parsed.conflict_id : undefined,
+                    note: typeof parsed.note === "string" ? parsed.note : undefined,
+                });
+            }
+            catch {
+                options.logger.warn(`graph_superseded_parse_error line=${line.slice(0, 120)}`);
+            }
+        }
+        return entries;
+    }
+    function loadSupersededRelationKeys() {
+        const keys = new Set();
+        for (const entry of loadSupersededRelationEntries()) {
+            if (entry.relation_key) {
+                keys.add(entry.relation_key);
+            }
+        }
+        return keys;
+    }
+    function appendSupersededRelationEntries(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        ensureDirForFile(supersededRelationPath);
+        const lines = entries.map(item => JSON.stringify(item));
+        fs.appendFileSync(supersededRelationPath, `${lines.join("\n")}\n`, "utf-8");
+    }
+    function filterRecordBySuperseded(record, supersededKeys) {
+        const relations = Array.isArray(record.relations)
+            ? record.relations.filter(rel => !supersededKeys.has(relationKey(rel)))
+            : [];
+        if (relations.length === 0) {
+            return null;
+        }
+        return {
+            ...record,
+            relations,
+        };
+    }
+    function loadAllRaw() {
+        if (!fs.existsSync(graphMemoryPath)) {
+            return [];
+        }
+        const content = fs.readFileSync(graphMemoryPath, "utf-8");
+        const lines = content.split(/\r?\n/).filter(Boolean);
+        const records = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed && parsed.id && (parsed.source_event_id || parsed.archive_event_id)) {
+                    if (!parsed.source_event_id && parsed.archive_event_id) {
+                        parsed.source_event_id = parsed.archive_event_id;
+                        parsed.source_layer = "archive_event";
+                    }
+                    records.push(parsed);
+                }
+            }
+            catch {
+                options.logger.warn(`graph_memory_parse_error line=${line.slice(0, 100)}`);
+            }
+        }
+        return records;
+    }
+    function loadAllEffective() {
+        const supersededKeys = loadSupersededRelationKeys();
+        const raw = loadAllRaw();
+        const output = [];
+        for (const record of raw) {
+            const filtered = filterRecordBySuperseded(record, supersededKeys);
+            if (filtered) {
+                output.push(filtered);
+            }
+        }
+        return output;
+    }
+    function shouldRejectStaleSummary(record) {
+        const sameSourceRecords = loadAllEffective()
+            .filter(item => item.source_event_id === record.source_event_id)
+            .sort((a, b) => Date.parse(b.timestamp || "") - Date.parse(a.timestamp || ""));
+        if (sameSourceRecords.length === 0) {
+            return false;
+        }
+        const latest = sameSourceRecords[0];
+        const previousSummary = normalizeSummary(latest.summary);
+        const nextSummary = normalizeSummary(record.summary);
+        if (!previousSummary || !nextSummary || previousSummary !== nextSummary) {
+            return false;
+        }
+        const previousSignature = buildStructureSignature(latest);
+        const nextSignature = buildStructureSignature(record);
+        return previousSignature !== nextSignature;
+    }
+    function loadConflictQueue() {
+        if (!fs.existsSync(conflictQueuePath)) {
+            return [];
+        }
+        const lines = fs.readFileSync(conflictQueuePath, "utf-8").split(/\r?\n/).filter(Boolean);
+        const records = [];
+        for (const line of lines) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed && typeof parsed.conflict_id === "string" && parsed.conflict_id.trim()) {
+                    records.push(parsed);
+                }
+            }
+            catch {
+                options.logger.warn(`graph_conflict_parse_error line=${line.slice(0, 120)}`);
+            }
+        }
+        return records;
+    }
+    function saveConflictQueue(records) {
+        ensureDirForFile(conflictQueuePath);
+        const lines = records.map(item => JSON.stringify(item));
+        fs.writeFileSync(conflictQueuePath, `${lines.join("\n")}${lines.length > 0 ? "\n" : ""}`, "utf-8");
+    }
+    function appendGraphRecord(args) {
+        const line = JSON.stringify(args.record);
+        const qualityCheck = (0, llm_output_validator_1.validateGraphJsonlLine)(line);
+        if (!qualityCheck.valid) {
+            throw new Error(`graph_record_quality_invalid:${qualityCheck.errors.join("|")}`);
+        }
+        if (qualityCheck.warnings.length > 0) {
+            options.logger.warn(`graph_quality_warning source_event_id=${args.record.source_event_id} warnings=${qualityCheck.warnings.join("|")}`);
+        }
+        const mutationEntry = {
+            op: args.conflictId ? "insert_graph_conflict_resolved" : "insert_graph",
+            id: args.record.id,
+            source_event_id: args.record.source_event_id,
+            source_layer: args.record.source_layer,
+            archive_event_id: args.record.archive_event_id,
+            timestamp: args.record.timestamp,
+            session_id: args.record.session_id,
+            gate_source: args.record.gate_source,
+            entity_count: args.record.entities.length,
+            relation_count: args.record.relations.length,
+            conflict_id: args.conflictId,
+            note: args.note,
+        };
+        ensureDirForFile(graphMemoryPath);
+        ensureDirForFile(mutationLogPath);
+        fs.appendFileSync(graphMemoryPath, `${line}\n`, "utf-8");
+        fs.appendFileSync(mutationLogPath, `${JSON.stringify(mutationEntry)}\n`, "utf-8");
+    }
+    function appendSupersedeMutationLogs(entries, conflictId, sourceEventId) {
+        if (entries.length === 0) {
+            return;
+        }
+        ensureDirForFile(mutationLogPath);
+        const nowIso = new Date().toISOString();
+        const lines = entries.map(item => JSON.stringify({
+            op: "supersede_relation",
+            id: `sup_${crypto.createHash("sha1").update(`${item.relation_key}|${item.superseded_at}`).digest("hex").slice(0, 12)}`,
+            source_event_id: sourceEventId || "conflict_resolution",
+            source_layer: "active_only",
+            timestamp: nowIso,
+            session_id: "system",
+            gate_source: "manual",
+            entity_count: 0,
+            relation_count: 0,
+            relation_key: item.relation_key,
+            conflict_id: conflictId,
+            note: item.note,
+        }));
+        fs.appendFileSync(mutationLogPath, `${lines.join("\n")}\n`, "utf-8");
+    }
+    function detectConflicts(candidate) {
+        const existing = loadAllEffective();
+        const candidateSingleValued = (candidate.relations || []).filter(rel => SINGLE_VALUE_RELATION_TYPES.has((rel.type || "").trim().toLowerCase()));
+        if (candidateSingleValued.length === 0) {
+            return {
+                hasConflict: false,
+                reason: "",
+                conflictTypes: [],
+                existingRelations: [],
+                existingRelationKeys: [],
+            };
+        }
+        const existingByBucket = new Map();
+        for (const record of existing) {
+            for (const rel of record.relations || []) {
+                const type = (rel.type || "").trim().toLowerCase();
+                if (!SINGLE_VALUE_RELATION_TYPES.has(type)) {
+                    continue;
+                }
+                const key = relationKey(rel);
+                const bucket = relationBucketKey(rel);
+                if (!existingByBucket.has(bucket)) {
+                    existingByBucket.set(bucket, []);
+                }
+                existingByBucket.get(bucket)?.push({ key, relation: rel });
+            }
+        }
+        const conflictTypes = new Set();
+        const existingRelations = [];
+        const existingRelationKeySet = new Set();
+        for (const rel of candidateSingleValued) {
+            const candidateKey = relationKey(rel);
+            const bucket = relationBucketKey(rel);
+            const sameBucket = existingByBucket.get(bucket) || [];
+            for (const existingItem of sameBucket) {
+                if (existingItem.key === candidateKey) {
+                    continue;
+                }
+                existingRelationKeySet.add(existingItem.key);
+                existingRelations.push(existingItem);
+                conflictTypes.add((rel.type || "").trim().toLowerCase());
+            }
+        }
+        const existingRelationKeys = [...existingRelationKeySet].sort();
+        if (existingRelationKeys.length === 0) {
+            return {
+                hasConflict: false,
+                reason: "",
+                conflictTypes: [],
+                existingRelations: [],
+                existingRelationKeys: [],
+            };
+        }
+        return {
+            hasConflict: true,
+            reason: `single_value_relation_conflict:${[...conflictTypes].sort().join(",")}`,
+            conflictTypes: [...conflictTypes].sort(),
+            existingRelations,
+            existingRelationKeys,
+        };
+    }
+    function buildConflictFingerprint(input) {
+        const payload = JSON.stringify({
+            source_event_id: input.sourceEventId,
+            conflict_types: [...input.conflictTypes].sort(),
+            existing_relation_keys: [...input.existingRelationKeys].sort(),
+            candidate_relation_keys: input.candidateRelations.map(relationKey).sort(),
+        });
+        return crypto.createHash("sha1").update(payload).digest("hex");
+    }
     options.logger.info(`Graph memory store initialized at ${graphMemoryPath}`);
     async function append(input) {
         const validation = (0, ontology_1.validateGraphPayload)({
@@ -60,6 +421,8 @@ function createGraphMemoryStore(options) {
             archiveEventId: input.archiveEventId,
             sessionId: input.sessionId,
             sourceFile: input.sourceFile,
+            source_text_nav: input.source_text_nav,
+            summary: input.summary,
             eventType: input.eventType,
             entities: input.entities,
             entity_types: input.entity_types,
@@ -80,66 +443,98 @@ function createGraphMemoryStore(options) {
         const record = validation.normalized;
         record.id = generateGraphId();
         record.timestamp = new Date().toISOString();
-        const line = JSON.stringify(record);
-        const qualityCheck = (0, llm_output_validator_1.validateGraphJsonlLine)(line);
-        if (!qualityCheck.valid) {
-            const reason = `graph_record_quality_invalid:${qualityCheck.errors.join("|")}`;
+        if (shouldRejectStaleSummary(record)) {
+            options.logger.info(`graph_skip_reason=stale_summary_after_update source_event_id=${record.source_event_id}`);
+            return { success: false, reason: "stale_summary_after_update" };
+        }
+        const conflictDetection = detectConflicts(record);
+        if (conflictDetection.hasConflict) {
+            const queue = loadConflictQueue();
+            const fingerprint = buildConflictFingerprint({
+                sourceEventId: record.source_event_id,
+                conflictTypes: conflictDetection.conflictTypes,
+                existingRelationKeys: conflictDetection.existingRelationKeys,
+                candidateRelations: record.relations,
+            });
+            const existingPending = queue.find(item => item.status === "pending" && item.fingerprint === fingerprint);
+            if (existingPending) {
+                options.logger.info(`graph_conflict_pending_reuse conflict_id=${existingPending.conflict_id} source_event_id=${record.source_event_id}`);
+                return { success: false, reason: `graph_conflict_pending:${existingPending.conflict_id}` };
+            }
+            const now = new Date().toISOString();
+            const conflictRecord = {
+                conflict_id: generateConflictId(),
+                status: "pending",
+                created_at: now,
+                updated_at: now,
+                source_event_id: record.source_event_id,
+                source_layer: record.source_layer,
+                session_id: record.session_id,
+                source_file: record.source_file,
+                conflict_reason: conflictDetection.reason,
+                conflict_types: conflictDetection.conflictTypes,
+                existing_relation_keys: conflictDetection.existingRelationKeys,
+                existing_relations: conflictDetection.existingRelations,
+                candidate: {
+                    summary: record.summary,
+                    source_text_nav: record.source_text_nav,
+                    entities: record.entities,
+                    entity_types: record.entity_types,
+                    relations: record.relations,
+                    event_type: record.event_type,
+                    gate_source: record.gate_source,
+                    confidence: record.confidence,
+                    source_text: input.sourceText,
+                },
+                fingerprint,
+            };
+            queue.push(conflictRecord);
+            saveConflictQueue(queue);
+            options.logger.info(`graph_conflict_pending id=${conflictRecord.conflict_id} source_event_id=${record.source_event_id} types=${conflictRecord.conflict_types.join(",")}`);
+            triggerWikiMaintenance({
+                type: "conflict_pending",
+                message: "Conflict pending and awaiting confirmation",
+                sourceEventId: record.source_event_id,
+                conflictId: conflictRecord.conflict_id,
+                entities: record.entities,
+                relationTypes: (record.relations || []).map(item => item.type),
+            });
+            return { success: false, reason: `graph_conflict_pending:${conflictRecord.conflict_id}` };
+        }
+        try {
+            appendGraphRecord({ record });
+            options.logger.info(`graph_write id=${record.id} source_event_id=${record.source_event_id} source_layer=${record.source_layer} entities=${record.entities.length} relations=${record.relations.length} gate_source=${record.gate_source}`);
+            triggerWikiMaintenance({
+                type: "graph_append",
+                message: "Graph relation appended",
+                sourceEventId: record.source_event_id,
+                entities: record.entities,
+                relationTypes: (record.relations || []).map(item => item.type),
+            });
+            return { success: true, record };
+        }
+        catch (error) {
+            const reason = String(error);
             options.logger.warn(`graph_skip_reason=${reason} source_event_id=${input.sourceEventId}`);
             return { success: false, reason };
         }
-        if (qualityCheck.warnings.length > 0) {
-            options.logger.warn(`graph_quality_warning source_event_id=${input.sourceEventId} warnings=${qualityCheck.warnings.join("|")}`);
-        }
-        const mutationEntry = {
-            op: "insert_graph",
-            id: record.id,
-            source_event_id: record.source_event_id,
-            source_layer: record.source_layer,
-            archive_event_id: record.archive_event_id,
-            timestamp: record.timestamp,
-            session_id: record.session_id,
-            gate_source: record.gate_source,
-            entity_count: record.entities.length,
-            relation_count: record.relations.length,
-        };
-        const mutationLine = JSON.stringify(mutationEntry);
-        ensureDirForFile(graphMemoryPath);
-        ensureDirForFile(mutationLogPath);
-        fs.appendFileSync(graphMemoryPath, `${line}\n`, "utf-8");
-        fs.appendFileSync(mutationLogPath, `${mutationLine}\n`, "utf-8");
-        options.logger.info(`graph_write id=${record.id} source_event_id=${record.source_event_id} source_layer=${record.source_layer} entities=${record.entities.length} relations=${record.relations.length} gate_source=${record.gate_source}`);
-        return { success: true, record };
     }
     function loadAll() {
-        if (!fs.existsSync(graphMemoryPath)) {
-            return [];
-        }
-        const content = fs.readFileSync(graphMemoryPath, "utf-8");
-        const lines = content.split(/\r?\n/).filter(Boolean);
-        const records = [];
-        for (const line of lines) {
-            try {
-                const parsed = JSON.parse(line);
-                if (parsed && parsed.id && (parsed.source_event_id || parsed.archive_event_id)) {
-                    if (!parsed.source_event_id && parsed.archive_event_id) {
-                        parsed.source_event_id = parsed.archive_event_id;
-                        parsed.source_layer = "archive_event";
-                    }
-                    records.push(parsed);
-                }
-            }
-            catch {
-                options.logger.warn(`graph_memory_parse_error line=${line.slice(0, 100)}`);
-            }
-        }
-        return records;
+        return loadAllEffective();
     }
     function loadByArchiveEventId(archiveEventId) {
         return loadAll().filter(record => record.archive_event_id === archiveEventId || record.source_event_id === archiveEventId);
     }
     function loadByEntity(entityName) {
-        const normalized = entityName.trim().toLowerCase();
-        return loadAll().filter(record => record.entities.some(entity => entity.trim().toLowerCase() === normalized));
+        const normalized = entityName.trim();
+        const queryKeySet = new Set((0, ontology_1.getEntityMatchKeys)(normalized, graphSchema));
+        if (queryKeySet.size === 0) {
+            return [];
+        }
+        return loadAll().filter(record => record.entities.some(entity => {
+            const entityKeys = (0, ontology_1.getEntityMatchKeys)(entity, graphSchema);
+            return entityKeys.some(key => queryKeySet.has(key));
+        }));
     }
     function getStats() {
         const all = loadAll();
@@ -157,12 +552,290 @@ function createGraphMemoryStore(options) {
             totalRelations,
         };
     }
+    function parseRelationKey(key) {
+        const parts = key.split("|");
+        return {
+            source: parts[0] || "",
+            type: parts[1] || "related_to",
+            target: parts.slice(2).join("|") || "",
+        };
+    }
+    function exportGraphView() {
+        const rawRecords = loadAllRaw();
+        const activeRecords = loadAllEffective();
+        const conflictQueue = loadConflictQueue();
+        const supersededEntries = loadSupersededRelationEntries();
+        const nodes = new Map();
+        const edges = [];
+        const dedupe = new Set();
+        let latestTimestampMs = 0;
+        function updateLatest(iso) {
+            const ms = Date.parse(iso || "");
+            if (Number.isFinite(ms) && ms > latestTimestampMs) {
+                latestTimestampMs = ms;
+            }
+        }
+        function addNode(id) {
+            const trimmed = id.trim();
+            if (!trimmed) {
+                return;
+            }
+            const key = trimmed.toLowerCase();
+            if (!nodes.has(key)) {
+                nodes.set(key, { id: trimmed, type: "entity" });
+            }
+        }
+        function addEdge(input) {
+            const source = input.source.trim();
+            const target = input.target.trim();
+            const type = (input.type || "related_to").trim().toLowerCase();
+            if (!source || !target || !type) {
+                return;
+            }
+            const relation_key = `${source.toLowerCase()}|${type}|${target.toLowerCase()}`;
+            const dedupeKey = `${relation_key}|${input.status}|${(input.conflict_id || "").trim().toLowerCase()}`;
+            if (dedupe.has(dedupeKey)) {
+                return;
+            }
+            dedupe.add(dedupeKey);
+            addNode(source);
+            addNode(target);
+            edges.push({
+                source,
+                target,
+                type,
+                status: input.status,
+                relation_key,
+                source_event_id: input.source_event_id,
+                evidence_span: input.evidence_span,
+                confidence: input.confidence,
+                conflict_id: input.conflict_id,
+            });
+        }
+        const relationMetaByKey = new Map();
+        for (const record of rawRecords) {
+            updateLatest(record.timestamp);
+            for (const rel of record.relations || []) {
+                const key = relationKey(rel);
+                const prev = relationMetaByKey.get(key);
+                if (!prev || Date.parse(record.timestamp || "") >= Date.parse(prev.timestamp || "")) {
+                    relationMetaByKey.set(key, {
+                        source_event_id: record.source_event_id,
+                        evidence_span: rel.evidence_span,
+                        confidence: rel.confidence,
+                        timestamp: record.timestamp,
+                    });
+                }
+            }
+        }
+        for (const record of activeRecords) {
+            updateLatest(record.timestamp);
+            for (const rel of record.relations || []) {
+                addEdge({
+                    source: rel.source,
+                    target: rel.target,
+                    type: rel.type,
+                    status: "active",
+                    source_event_id: record.source_event_id,
+                    evidence_span: rel.evidence_span,
+                    confidence: rel.confidence,
+                });
+            }
+        }
+        for (const entry of supersededEntries) {
+            updateLatest(entry.superseded_at);
+            const parsed = parseRelationKey(entry.relation_key);
+            const meta = relationMetaByKey.get(entry.relation_key);
+            addEdge({
+                source: parsed.source,
+                target: parsed.target,
+                type: parsed.type,
+                status: "superseded",
+                source_event_id: meta?.source_event_id,
+                evidence_span: meta?.evidence_span,
+                confidence: meta?.confidence,
+                conflict_id: entry.conflict_id,
+            });
+        }
+        for (const item of conflictQueue) {
+            updateLatest(item.updated_at);
+            if (item.status !== "pending" && item.status !== "rejected") {
+                continue;
+            }
+            const status = item.status === "pending" ? "pending_conflict" : "rejected";
+            for (const rel of item.candidate.relations || []) {
+                addEdge({
+                    source: rel.source,
+                    target: rel.target,
+                    type: rel.type,
+                    status,
+                    source_event_id: item.source_event_id,
+                    evidence_span: rel.evidence_span,
+                    confidence: rel.confidence,
+                    conflict_id: item.conflict_id,
+                });
+            }
+        }
+        const status_counts = {
+            active: 0,
+            pending_conflict: 0,
+            superseded: 0,
+            rejected: 0,
+        };
+        for (const edge of edges) {
+            status_counts[edge.status] += 1;
+        }
+        edges.sort((a, b) => {
+            const left = `${a.status}|${a.source.toLowerCase()}|${a.type}|${a.target.toLowerCase()}|${a.conflict_id || ""}`;
+            const right = `${b.status}|${b.source.toLowerCase()}|${b.type}|${b.target.toLowerCase()}|${b.conflict_id || ""}`;
+            return left.localeCompare(right);
+        });
+        const nodeList = [...nodes.values()].sort((a, b) => a.id.toLowerCase().localeCompare(b.id.toLowerCase()));
+        return {
+            nodes: nodeList,
+            edges,
+            status_counts,
+            updated_at: latestTimestampMs > 0 ? new Date(latestTimestampMs).toISOString() : new Date().toISOString(),
+        };
+    }
+    function listConflicts(args) {
+        const status = 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 queue = loadConflictQueue();
+        const filtered = queue
+            .filter(item => status === "all" ? true : item.status === status)
+            .sort((a, b) => Date.parse(b.updated_at) - Date.parse(a.updated_at));
+        return filtered.slice(0, limit).map(toConflictSummary);
+    }
+    function getConflictStats() {
+        const queue = loadConflictQueue();
+        let pending = 0;
+        let accepted = 0;
+        let rejected = 0;
+        for (const item of queue) {
+            if (item.status === "pending")
+                pending += 1;
+            if (item.status === "accepted")
+                accepted += 1;
+            if (item.status === "rejected")
+                rejected += 1;
+        }
+        return { pending, accepted, rejected };
+    }
+    async function resolveConflict(args) {
+        const conflictId = (args.conflictId || "").trim();
+        if (!conflictId) {
+            return { success: false, reason: "conflict_id_empty" };
+        }
+        const queue = loadConflictQueue();
+        const index = queue.findIndex(item => item.conflict_id === conflictId);
+        if (index < 0) {
+            return { success: false, reason: "conflict_not_found" };
+        }
+        const current = queue[index];
+        if (current.status !== "pending") {
+            return { success: false, reason: `conflict_already_${current.status}` };
+        }
+        const now = new Date().toISOString();
+        if (args.action === "reject") {
+            current.status = "rejected";
+            current.updated_at = now;
+            current.resolution = {
+                action: "reject",
+                note: args.note,
+                resolved_at: now,
+            };
+            queue[index] = current;
+            saveConflictQueue(queue);
+            options.logger.info(`graph_conflict_rejected id=${conflictId}`);
+            triggerWikiMaintenance({
+                type: "conflict_rejected",
+                message: "Conflict rejected; canonical graph unchanged",
+                sourceEventId: current.source_event_id,
+                conflictId,
+                entities: current.candidate.entities,
+                relationTypes: (current.candidate.relations || []).map(item => item.type),
+            });
+            return { success: true };
+        }
+        const supersedeEntries = current.existing_relation_keys.map(key => ({
+            relation_key: key,
+            superseded_at: now,
+            conflict_id: conflictId,
+            note: args.note || "conflict_accept_replace",
+        }));
+        appendSupersededRelationEntries(supersedeEntries);
+        appendSupersedeMutationLogs(supersedeEntries, conflictId, current.source_event_id);
+        const record = {
+            id: generateGraphId(),
+            summary: (current.candidate.summary || "").trim() || buildFallbackSummary(current.candidate.entities, current.candidate.relations),
+            source_text_nav: current.candidate.source_text_nav || {
+                layer: current.source_layer,
+                session_id: current.session_id,
+                source_file: current.source_file || "unknown",
+                source_memory_id: current.source_event_id,
+                source_event_id: current.source_event_id,
+            },
+            source_event_id: current.source_event_id,
+            source_layer: current.source_layer,
+            archive_event_id: current.source_layer === "archive_event" ? current.source_event_id : undefined,
+            session_id: current.session_id,
+            source_file: current.source_file,
+            timestamp: now,
+            entities: current.candidate.entities,
+            entity_types: current.candidate.entity_types,
+            relations: current.candidate.relations,
+            gate_source: current.candidate.gate_source,
+            event_type: current.candidate.event_type,
+            schema_version: "1.0.0",
+            confidence: current.candidate.confidence,
+        };
+        if (shouldRejectStaleSummary(record)) {
+            return { success: false, reason: "stale_summary_after_update" };
+        }
+        try {
+            appendGraphRecord({
+                record,
+                conflictId,
+                note: args.note,
+            });
+        }
+        catch (error) {
+            return { success: false, reason: String(error) };
+        }
+        current.status = "accepted";
+        current.updated_at = now;
+        current.resolution = {
+            action: "accept",
+            note: args.note,
+            resolved_at: now,
+            applied_record_id: record.id,
+        };
+        queue[index] = current;
+        saveConflictQueue(queue);
+        options.logger.info(`graph_conflict_accepted id=${conflictId} record_id=${record.id}`);
+        triggerWikiMaintenance({
+            type: "conflict_accepted",
+            message: "Conflict accepted; canonical graph updated",
+            sourceEventId: current.source_event_id,
+            conflictId,
+            entities: current.candidate.entities,
+            relationTypes: (current.candidate.relations || []).map(item => item.type),
+        });
+        return { success: true, appliedRecordId: record.id };
+    }
     return {
         append,
         loadAll,
         loadByArchiveEventId,
         loadByEntity,
         getStats,
+        exportGraphView,
+        listConflicts,
+        resolveConflict,
+        getConflictStats,
     };
 }
 //# sourceMappingURL=graph_memory_store.js.map