openclaw-cortex-memory 0.1.0-Alpha.8 → 0.1.0

package/dist/src/engine/ts_engine.js

@@ -37,6 +37,15 @@ exports.createTsEngine = createTsEngine;
 const fs = __importStar(require("fs"));
 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.7.9",
+    session_end_write: "session-end-write.v1.2.0",
+    read_fusion: "read-fusion.v1.2.0",
+};
 function createTsEngine(deps) {
     const graphSchema = (0, ontology_1.loadGraphSchema)(deps.projectRoot);
     const sessionMessageBuffer = new Map();
@@ -64,6 +73,27 @@ function createTsEngine(deps) {
             }
         }
     }
+    function getRecentSessionMessages(sessionId, limit) {
+        const messages = sessionMessageBuffer.get(sessionId) || [];
+        return messages.slice(Math.max(0, messages.length - Math.max(1, limit)));
+    }
+    function isHistoricalMemoryQuery(text) {
+        return /(上次|之前|以前|你记得|记得|历史|上个月|去年|上个星期|昨天|前天|查一下|回忆|记忆|偏好|项目上下文|既有决策|决策|决定|修复|方案|last time|previous|previously|before|remember|history|prior|preference|decision|fix|what did we)/i.test(text);
+    }
+    function buildAutoSearchQuery(sessionId, latestUserText, historical) {
+        if (!historical) {
+            return latestUserText.trim();
+        }
+        const recent = getRecentSessionMessages(sessionId, 8)
+            .map(message => {
+            const role = typeof message.role === "string" && message.role.trim() ? message.role.trim() : "message";
+            const content = typeof message.content === "string" ? message.content.trim().replace(/\s+/g, " ") : "";
+            return content ? `${role}: ${content}` : "";
+        })
+            .filter(Boolean)
+            .join("\n");
+        return (recent || latestUserText).slice(-240).trim();
+    }
     function asRecord(value) {
         if (typeof value === "object" && value !== null) {
             return value;
@@ -98,6 +128,286 @@ function createTsEngine(deps) {
             archivePath: path.join(deps.memoryRoot, "sessions", "archive", "sessions.jsonl"),
         };
     }
+    function parseJsonFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return null;
+            }
+            const raw = fs.readFileSync(filePath, "utf-8").trim();
+            if (!raw) {
+                return null;
+            }
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    function embeddingStats(records) {
+        let ok = 0;
+        let failed = 0;
+        let pending = 0;
+        for (const record of records) {
+            const explicit = typeof record.embedding_status === "string" ? record.embedding_status.trim() : "";
+            const hasEmbedding = Array.isArray(record.embedding) && record.embedding.length > 0;
+            if (explicit === "ok" || hasEmbedding) {
+                ok += 1;
+            }
+            else if (explicit === "failed") {
+                failed += 1;
+            }
+            else {
+                pending += 1;
+            }
+        }
+        const total = records.length;
+        const coverage = total > 0 ? Number((ok / total).toFixed(4)) : 0;
+        return { total, ok, failed, pending, coverage };
+    }
+    function normalizeBaseUrl(value) {
+        if (!value)
+            return "";
+        return value.endsWith("/") ? value.slice(0, -1) : value;
+    }
+    function estimateTokenCount(text) {
+        const parts = text
+            .split(/[\s,.;:!?，。；：！？、()（）[\]{}"'`~]+/)
+            .map(part => part.trim())
+            .filter(Boolean);
+        return parts.length;
+    }
+    function buildVectorSourceText(record, layer) {
+        if (layer === "active") {
+            const sourceText = typeof record.source_text === "string" && record.source_text.trim()
+                ? record.source_text.trim()
+                : "";
+            if (sourceText) {
+                return sourceText;
+            }
+            const summary = typeof record.summary === "string" ? record.summary.trim() : "";
+            if (summary) {
+                return summary;
+            }
+            const text = typeof record.text === "string" ? record.text.trim() : "";
+            return text;
+        }
+        const sourceText = typeof record.source_text === "string" ? record.source_text.trim() : "";
+        if (sourceText) {
+            return sourceText;
+        }
+        const summary = typeof record.summary === "string" ? record.summary.trim() : "";
+        return summary;
+    }
+    function splitTextChunks(text, chunkSize, chunkOverlap) {
+        const normalizedSize = Number.isFinite(chunkSize) && chunkSize >= 200 ? Math.floor(chunkSize) : 600;
+        const normalizedOverlap = Number.isFinite(chunkOverlap) && chunkOverlap >= 0
+            ? Math.floor(chunkOverlap)
+            : 100;
+        const overlap = Math.min(normalizedOverlap, Math.max(0, normalizedSize - 50));
+        const output = [];
+        let cursor = 0;
+        let index = 0;
+        const punctuationSet = new Set(["。", "！", "？", ".", "!", "?", "\n", "；", ";"]);
+        while (cursor < text.length) {
+            const rawEnd = Math.min(text.length, cursor + normalizedSize);
+            let end = rawEnd;
+            if (rawEnd < text.length) {
+                const backwardStart = Math.max(cursor + Math.floor(normalizedSize * 0.45), cursor + 1);
+                let found = -1;
+                for (let i = rawEnd - 1; i >= backwardStart; i -= 1) {
+                    if (punctuationSet.has(text[i])) {
+                        found = i + 1;
+                        break;
+                    }
+                }
+                if (found < 0) {
+                    const forwardEnd = Math.min(text.length, rawEnd + Math.floor(normalizedSize * 0.2));
+                    for (let i = rawEnd; i < forwardEnd; i += 1) {
+                        if (punctuationSet.has(text[i])) {
+                            found = i + 1;
+                            break;
+                        }
+                    }
+                }
+                if (found > cursor) {
+                    end = found;
+                }
+            }
+            if (end <= cursor) {
+                end = Math.min(text.length, cursor + normalizedSize);
+            }
+            const chunkText = text.slice(cursor, end).trim();
+            if (chunkText) {
+                output.push({ index, start: cursor, end, text: chunkText });
+                index += 1;
+            }
+            if (end >= text.length) {
+                break;
+            }
+            const nextCursor = Math.max(cursor + 1, end - overlap);
+            cursor = nextCursor <= cursor ? end : nextCursor;
+        }
+        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 };
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, JSON.stringify(next, null, 2), "utf-8");
+    }
+    async function probeModelConnection(args) {
+        const defaultTimeoutMs = args.kind === "llm" ? 30000 : 15000;
+        const timeoutMs = typeof args.timeoutMs === "number" && Number.isFinite(args.timeoutMs) && args.timeoutMs >= 1000
+            ? Math.floor(args.timeoutMs)
+            : defaultTimeoutMs;
+        if (!args.model || !args.apiKey || !args.baseUrl) {
+            return {
+                configured: false,
+                connected: false,
+                model: args.model || "",
+                base_url: args.baseUrl || "",
+                error: "not_configured",
+            };
+        }
+        let endpoint = args.baseUrl;
+        let payload = {};
+        if (args.kind === "embedding") {
+            endpoint = args.baseUrl.endsWith("/embeddings") ? args.baseUrl : `${args.baseUrl}/embeddings`;
+            payload = {
+                model: args.model,
+                input: "diagnostics connectivity probe",
+            };
+        }
+        else if (args.kind === "llm") {
+            endpoint = args.baseUrl.endsWith("/chat/completions") ? args.baseUrl : `${args.baseUrl}/chat/completions`;
+            payload = {
+                model: args.model,
+                messages: [{ role: "user", content: "ping" }],
+                max_tokens: 4,
+                temperature: 0,
+                stream: false,
+            };
+        }
+        else {
+            endpoint = args.baseUrl.endsWith("/rerank") ? args.baseUrl : `${args.baseUrl}/rerank`;
+            payload = {
+                model: args.model,
+                query: "diagnostics",
+                documents: ["diagnostics connectivity probe"],
+                top_n: 1,
+            };
+        }
+        let lastError = "unknown_error";
+        const maxAttempts = args.kind === "llm" ? 3 : 1;
+        for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+            const response = await (0, http_post_1.postJsonWithTimeout)({
+                endpoint,
+                apiKey: args.apiKey,
+                body: payload,
+                timeoutMs,
+                headers: { accept: "application/json" },
+            });
+            if (response.ok) {
+                return {
+                    configured: true,
+                    connected: true,
+                    model: args.model,
+                    base_url: args.baseUrl,
+                    error: "",
+                };
+            }
+            if (response.aborted) {
+                lastError = `timeout_${timeoutMs}ms`;
+            }
+            else if (response.status > 0) {
+                const details = (response.text || "").trim().slice(0, 180);
+                lastError = details ? `http_${response.status}:${details}` : `http_${response.status}`;
+            }
+            else {
+                lastError = response.error || "network_error";
+            }
+        }
+        return {
+            configured: true,
+            connected: false,
+            model: args.model,
+            base_url: args.baseUrl,
+            error: lastError,
+        };
+    }
+    async function requestEmbedding(args) {
+        const endpoint = args.baseUrl.endsWith("/embeddings") ? args.baseUrl : `${args.baseUrl}/embeddings`;
+        const body = {
+            input: args.text,
+            model: args.model,
+        };
+        if (typeof args.dimensions === "number" && Number.isFinite(args.dimensions) && args.dimensions > 0) {
+            body.dimensions = args.dimensions;
+        }
+        const timeoutMs = typeof args.timeoutMs === "number" && Number.isFinite(args.timeoutMs) && args.timeoutMs >= 1000
+            ? Math.floor(args.timeoutMs)
+            : 20000;
+        const maxRetries = typeof args.maxRetries === "number" && Number.isFinite(args.maxRetries) && args.maxRetries >= 1
+            ? Math.min(8, Math.floor(args.maxRetries))
+            : 4;
+        let lastError = null;
+        for (let attempt = 0; attempt < maxRetries; attempt += 1) {
+            const response = await (0, http_post_1.postJsonWithTimeout)({
+                endpoint,
+                apiKey: args.apiKey,
+                body,
+                timeoutMs,
+            });
+            if (!response.ok) {
+                lastError = new Error(response.status > 0 ? `embedding_http_${response.status}` : (response.error || "embedding_network_error"));
+                continue;
+            }
+            try {
+                const json = (response.json || {});
+                const embedding = json?.data?.[0]?.embedding;
+                if (Array.isArray(embedding) && embedding.length > 0) {
+                    return embedding.filter(item => Number.isFinite(item));
+                }
+                lastError = new Error("embedding_empty");
+            }
+            catch (error) {
+                lastError = error;
+            }
+            if (attempt < maxRetries - 1) {
+                await new Promise(resolve => setTimeout(resolve, 300 * Math.pow(2, attempt)));
+            }
+        }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError || "embedding_failed"));
+    }
     async function storeEvent(args, _context) {
         try {
             const rawArgs = args;
@@ -131,6 +441,22 @@ function createTsEngine(deps) {
                     return "";
                 }).filter(Boolean)
                 : [];
+            const entityTypesFromEntities = {};
+            if (Array.isArray(entityInput)) {
+                for (const item of entityInput) {
+                    if (!item || typeof item !== "object") {
+                        continue;
+                    }
+                    const entityObj = item;
+                    const entityName = typeof entityObj.name === "string" && entityObj.name.trim()
+                        ? entityObj.name.trim()
+                        : (typeof entityObj.id === "string" ? entityObj.id.trim() : "");
+                    const entityType = typeof entityObj.type === "string" ? entityObj.type.trim() : "";
+                    if (entityName && entityType) {
+                        entityTypesFromEntities[entityName] = entityType;
+                    }
+                }
+            }
             const relationInput = Array.isArray(rawArgs.relations)
                 ? rawArgs.relations
                 : Array.isArray(rawArgs.input?.relations)
@@ -159,6 +485,8 @@ function createTsEngine(deps) {
                         source: relation.source.trim(),
                         target: relation.target.trim(),
                         type: (0, ontology_1.normalizeRelationType)(relation.type || "related_to", graphSchema),
+                        evidence_span: typeof relation.evidence_span === "string" ? relation.evidence_span.trim() : undefined,
+                        confidence: typeof relation.confidence === "number" ? Math.max(0, Math.min(1, relation.confidence)) : undefined,
                     };
                 })
                     .filter((item) => Boolean(item))
@@ -170,24 +498,98 @@ 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"
+                    ? rawArgs.input.entity_types
+                    : typeof rawArgs.event?.entity_types === "object"
+                        ? rawArgs.event.entity_types
+                        : {};
+            const entityTypes = {};
+            for (const [key, value] of Object.entries(entityTypesInput)) {
+                if (typeof value === "string") {
+                    entityTypes[key.trim()] = value.trim();
+                }
+            }
+            for (const [key, value] of Object.entries(entityTypesFromEntities)) {
+                if (!entityTypes[key] && value) {
+                    entityTypes[key] = value;
+                }
+            }
             const result = await deps.archiveStore.storeEvents([
                 {
                     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,
                     outcome: outcomeValue,
                     session_id: "manual",
                     source_file: "ts_store_event",
                     confidence: 1,
-                    source_event_id: "",
+                    source_event_id: `manual:${Date.now().toString(36)}`,
                     actor: "manual_tool",
                 },
             ]);
             if (result.stored.length === 0) {
                 return { success: false, error: result.skipped[0]?.reason || "store_event_skipped" };
             }
-            return { success: true, data: { event_id: result.stored[0].id } };
+            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,
+                    relations,
+                    gateSource: "manual",
+                    confidence: 1,
+                    sourceText: normalizedSummary,
+                });
+                if (!graphResult.success) {
+                    deps.logger.info(`store_event graph_skip_reason=${graphResult.reason} source_event_id=${storedId}`);
+                }
+            }
+            return { success: true, data: { event_id: storedId } };
         }
         catch (error) {
             return { success: false, error: String(error) };
@@ -206,32 +608,20 @@ function createTsEngine(deps) {
             : "both";
         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 { archivePath } = memoryFiles();
-        const records = readJsonl(archivePath);
+        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, []);
             }
@@ -239,71 +629,173 @@ 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 });
             }
         }
-        for (const record of records) {
-            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 path = [];
+        let graphPath = [];
         if (pathTo) {
             const visited = new Set();
             const queue = [
@@ -314,7 +806,7 @@ function createTsEngine(deps) {
                 if (!current)
                     break;
                 if (current.node === pathTo) {
-                    path = current.pathEdges;
+                    graphPath = current.pathEdges;
                     break;
                 }
                 if (current.depth >= maxDepth) {
@@ -334,6 +826,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: {
@@ -342,13 +862,61 @@ function createTsEngine(deps) {
                 dir: direction,
                 nodes: [...nodes.values()],
                 edges,
+                status_counts: statusCounts,
                 path_to: pathTo || "",
                 max_depth: maxDepth,
-                path,
+                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) {
@@ -388,11 +956,14 @@ function createTsEngine(deps) {
                     continue;
                 }
                 if (typeof args.text === "string") {
-                    if (typeof record.content === "string") {
-                        record.content = args.text;
+                    const nextText = args.text.trim();
+                    const layer = typeof record.layer === "string" ? record.layer.trim() : "";
+                    if (layer === "active") {
+                        record.summary = nextText;
+                        record.source_text = nextText;
                     }
                     else {
-                        record.summary = args.text;
+                        record.summary = nextText;
                     }
                 }
                 if (typeof args.type === "string") {
@@ -435,35 +1006,667 @@ function createTsEngine(deps) {
         }
         return { success: true, data: { deletedCount } };
     }
+    async function backfillEmbeddings(args, _context) {
+        const layer = args.layer === "active" || args.layer === "archive" || args.layer === "all" ? args.layer : "all";
+        const rebuildMode = args.rebuild_mode === "vector_only" || args.rebuild_mode === "full"
+            ? args.rebuild_mode
+            : "incremental";
+        const batchSize = typeof args.batch_size === "number" && Number.isFinite(args.batch_size) && args.batch_size > 0
+            ? Math.min(500, Math.floor(args.batch_size))
+            : 100;
+        const maxRetries = typeof args.max_retries === "number" && Number.isFinite(args.max_retries) && args.max_retries >= 1
+            ? Math.min(10, Math.floor(args.max_retries))
+            : 3;
+        const retryFailedOnly = args.retry_failed_only === true;
+        const forceRebuild = rebuildMode === "vector_only" || rebuildMode === "full";
+        const model = deps.embedding?.model || "";
+        const apiKey = deps.embedding?.apiKey || "";
+        const baseUrl = normalizeBaseUrl(deps.embedding?.baseURL || deps.embedding?.baseUrl);
+        if (!model || !apiKey || !baseUrl) {
+            return { success: false, error: "Embedding config missing for backfill tool." };
+        }
+        const statePath = path.join(deps.memoryRoot, ".vector_backfill_state.json");
+        const syncStatePath = path.join(deps.memoryRoot, ".sync_state.json");
+        const previousState = parseJsonFile(statePath) || {};
+        const failureCountState = (typeof previousState.failureCounts === "object" && previousState.failureCounts !== null)
+            ? previousState.failureCounts
+            : {};
+        let fullSyncResult = null;
+        if (rebuildMode === "full") {
+            try {
+                fullSyncResult = await deps.sessionSync.syncMemory();
+            }
+            catch (error) {
+                deps.logger.warn(`backfill_full_rebuild_sync_failed error=${error}`);
+            }
+        }
+        const { activePath, archivePath } = memoryFiles();
+        const targetFiles = [];
+        if (layer === "all" || layer === "active") {
+            targetFiles.push({ layer: "active", filePath: activePath });
+        }
+        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) {
+            const records = readJsonl(target.filePath);
+            recordsByFile.set(target.filePath, records);
+            for (let i = 0; i < records.length; i += 1) {
+                const record = records[i];
+                const id = typeof record.id === "string" ? record.id : "";
+                if (!id) {
+                    continue;
+                }
+                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;
+                }
+                if (retryFailedOnly) {
+                    if (status !== "failed") {
+                        continue;
+                    }
+                }
+                else if ((status === "ok" || hasEmbedding) && hasVectorRows) {
+                    continue;
+                }
+                const failCountRaw = failureCountState[id];
+                const failCount = typeof failCountRaw === "number" ? failCountRaw : 0;
+                if (failCount >= maxRetries && status === "failed") {
+                    continue;
+                }
+                queue.push({ layer: target.layer, filePath: target.filePath, index: i });
+            }
+        }
+        const totalCandidates = queue.length;
+        let success = 0;
+        let failed = 0;
+        let skipped = 0;
+        let processed = 0;
+        const failureCounts = {};
+        for (const [key, value] of Object.entries(failureCountState)) {
+            if (typeof value === "number" && Number.isFinite(value)) {
+                failureCounts[key] = value;
+            }
+        }
+        for (let start = 0; start < queue.length; start += batchSize) {
+            const batch = queue.slice(start, start + batchSize);
+            for (const item of batch) {
+                processed += 1;
+                const records = recordsByFile.get(item.filePath) || [];
+                const record = records[item.index];
+                if (!record) {
+                    skipped += 1;
+                    continue;
+                }
+                const id = typeof record.id === "string" ? record.id : "";
+                if (!id) {
+                    skipped += 1;
+                    continue;
+                }
+                const text = buildVectorSourceText(record, item.layer);
+                if (!text) {
+                    record.embedding_status = "failed";
+                    failed += 1;
+                    failureCounts[id] = (failureCounts[id] || 0) + 1;
+                    continue;
+                }
+                const chunkSize = deps.vectorChunking?.chunkSize ?? 600;
+                const chunkOverlap = deps.vectorChunking?.chunkOverlap ?? 100;
+                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;
+                    failureCounts[id] = (failureCounts[id] || 0) + 1;
+                    continue;
+                }
+                try {
+                    if (forceRebuild) {
+                        record.embedding_status = "pending";
+                    }
+                    await deps.vectorStore.deleteBySourceMemory({ layer: item.layer, sourceMemoryId: id });
+                    let chunkOk = 0;
+                    for (const chunk of chunks) {
+                        const embedding = await requestEmbedding({
+                            text: chunk.text,
+                            model,
+                            apiKey,
+                            baseUrl,
+                            dimensions: deps.embedding?.dimensions,
+                            timeoutMs: deps.embedding?.timeoutMs,
+                            maxRetries: deps.embedding?.maxRetries,
+                        });
+                        if (!embedding || embedding.length === 0) {
+                            continue;
+                        }
+                        if (!record.embedding) {
+                            record.embedding = embedding;
+                        }
+                        await deps.vectorStore.upsert({
+                            id: `${id}_c${chunk.index}`,
+                            session_id: typeof record.session_id === "string" ? record.session_id : "unknown",
+                            event_type: typeof record.event_type === "string" ? record.event_type : (item.layer === "active" ? "message" : "insight"),
+                            summary: chunk.text,
+                            timestamp: typeof record.timestamp === "string" ? record.timestamp : new Date().toISOString(),
+                            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)
+                                ? record.relations
+                                    .map(v => {
+                                    if (!v || typeof v !== "object")
+                                        return null;
+                                    const relation = v;
+                                    const source = typeof relation.source === "string" ? relation.source : "";
+                                    const target = typeof relation.target === "string" ? relation.target : "";
+                                    const type = typeof relation.type === "string" ? relation.type : "related_to";
+                                    if (!source || !target)
+                                        return null;
+                                    return { source, target, type };
+                                })
+                                    .filter((v) => Boolean(v))
+                                : [],
+                            embedding,
+                            quality_score: typeof record.quality_score === "number" ? record.quality_score : 0.5,
+                            char_count: chunk.text.length,
+                            token_count: estimateTokenCount(chunk.text),
+                            chunk_index: chunk.index,
+                            chunk_total: chunks.length,
+                            chunk_start: chunk.start,
+                            chunk_end: chunk.end,
+                        });
+                        chunkOk += 1;
+                    }
+                    record.vector_chunks_total = chunks.length;
+                    record.vector_chunks_ok = chunkOk;
+                    record.embedding_status = chunkOk === chunks.length ? "ok" : "failed";
+                    if (!record.layer) {
+                        record.layer = item.layer;
+                    }
+                    if (typeof record.char_count !== "number") {
+                        record.char_count = text.length;
+                    }
+                    if (typeof record.token_count !== "number") {
+                        record.token_count = estimateTokenCount(text);
+                    }
+                    if (chunkOk === chunks.length) {
+                        success += 1;
+                        failureCounts[id] = 0;
+                    }
+                    else {
+                        failed += 1;
+                        failureCounts[id] = (failureCounts[id] || 0) + 1;
+                    }
+                }
+                catch (error) {
+                    record.embedding_status = "failed";
+                    failed += 1;
+                    failureCounts[id] = (failureCounts[id] || 0) + 1;
+                    deps.logger.warn(`backfill_embedding_failed id=${id} layer=${item.layer} error=${error}`);
+                }
+            }
+            deps.logger.info(`backfill_progress processed=${processed}/${totalCandidates} success=${success} failed=${failed} skipped=${skipped}`);
+        }
+        for (const target of targetFiles) {
+            const records = recordsByFile.get(target.filePath);
+            if (records) {
+                writeJsonl(target.filePath, records);
+            }
+        }
+        const summary = {
+            runAt: new Date().toISOString(),
+            layer,
+            rebuild_mode: rebuildMode,
+            candidates: totalCandidates,
+            success,
+            failed,
+            skipped,
+            batch_size: batchSize,
+            max_retries: maxRetries,
+            retry_failed_only: retryFailedOnly,
+            full_sync_result: fullSyncResult,
+        };
+        upsertJsonFile(statePath, {
+            version: "1",
+            lastRun: summary,
+            failureCounts,
+        });
+        upsertJsonFile(syncStatePath, {
+            version: "2",
+            lastVectorBackfill: {
+                runAt: summary.runAt,
+                success,
+                failed,
+                skipped,
+            },
+        });
+        return { success: true, data: summary };
+    }
     async function runDiagnostics(_args, _context) {
         const { activePath, archivePath } = memoryFiles();
+        const activeRecords = readJsonl(activePath);
+        const archiveRecords = readJsonl(archivePath);
+        const activeVector = embeddingStats(activeRecords);
+        const archiveVector = embeddingStats(archiveRecords);
+        const vectorJsonlPath = path.join(deps.memoryRoot, "vector", "lancedb_events.jsonl");
+        const vectorJsonlRecords = readJsonl(vectorJsonlPath);
+        const activeVectorRecords = vectorJsonlRecords.filter(record => (record.layer === "active"));
+        const archiveVectorRecords = vectorJsonlRecords.filter(record => (record.layer === "archive"));
+        const lancedbDir = path.join(deps.memoryRoot, "vector", "lancedb");
+        const lancedbExists = fs.existsSync(lancedbDir);
+        let lancedbRecordCount = 0;
+        if (lancedbExists) {
+            try {
+                const lancedbFiles = fs.readdirSync(lancedbDir).filter(f => f.endsWith(".lance") || f.endsWith(".manifest"));
+                lancedbRecordCount = lancedbFiles.length > 0 ? -1 : 0;
+            }
+            catch {
+                lancedbRecordCount = 0;
+            }
+        }
+        const totalVectorRecords = vectorJsonlRecords.length > 0 ? vectorJsonlRecords.length : (lancedbRecordCount === -1 ? -1 : 0);
+        const vectorStorageType = lancedbExists && lancedbRecordCount === -1 ? "lancedb" : (vectorJsonlRecords.length > 0 ? "jsonl" : "none");
+        const syncState = parseJsonFile(path.join(deps.memoryRoot, ".sync_state.json"));
+        const backfillState = parseJsonFile(path.join(deps.memoryRoot, ".vector_backfill_state.json"));
+        const failureCounts = backfillState && typeof backfillState.failureCounts === "object" && backfillState.failureCounts !== null
+            ? backfillState.failureCounts
+            : {};
+        const pendingRetry = Object.values(failureCounts).filter(value => typeof value === "number" && Number.isFinite(value) && value > 0).length;
+        const lastVectorBackfill = syncState && typeof syncState.lastVectorBackfill === "object" && syncState.lastVectorBackfill !== null
+            ? syncState.lastVectorBackfill
+            : null;
+        const embeddingConnectivity = await probeModelConnection({
+            kind: "embedding",
+            model: deps.embedding?.model || "",
+            apiKey: deps.embedding?.apiKey || "",
+            baseUrl: normalizeBaseUrl(deps.embedding?.baseURL || deps.embedding?.baseUrl),
+            timeoutMs: deps.embedding?.timeoutMs,
+        });
+        const llmConnectivity = await probeModelConnection({
+            kind: "llm",
+            model: deps.llm?.model || "",
+            apiKey: deps.llm?.apiKey || "",
+            baseUrl: normalizeBaseUrl(deps.llm?.baseURL || deps.llm?.baseUrl),
+            timeoutMs: 8000,
+        });
+        const rerankerConnectivity = await probeModelConnection({
+            kind: "reranker",
+            model: deps.reranker?.model || "",
+            apiKey: deps.reranker?.apiKey || "",
+            baseUrl: normalizeBaseUrl(deps.reranker?.baseURL || deps.reranker?.baseUrl),
+            timeoutMs: 8000,
+        });
         const checks = [
             { name: "Engine mode", passed: true, message: "TS engine active" },
             { name: "Active sessions store", passed: fs.existsSync(activePath), message: activePath },
             { name: "Archive sessions store", passed: fs.existsSync(archivePath), message: archivePath },
             { name: "Core rules store", passed: fs.existsSync(path.join(deps.memoryRoot, "CORTEX_RULES.md")), message: "CORTEX_RULES.md checked" },
+            { name: "Embedding model connectivity", passed: embeddingConnectivity.connected, message: embeddingConnectivity.error || "ok" },
+            { name: "LLM model connectivity", passed: llmConnectivity.connected, message: llmConnectivity.error || "ok" },
+            { name: "Reranker model connectivity", passed: rerankerConnectivity.connected, message: rerankerConnectivity.error || "ok" },
         ];
+        const qualityCheck = {
+            active: { total: 0, valid: 0, invalid: 0, issues: [] },
+            archive: { total: 0, valid: 0, invalid: 0, issues: [] },
+        };
+        if (fs.existsSync(activePath)) {
+            const content = fs.readFileSync(activePath, "utf-8");
+            const lines = content.split(/\r?\n/).filter(l => l.trim());
+            qualityCheck.active.total = lines.length;
+            for (let i = 0; i < lines.length; i++) {
+                const validation = (0, llm_output_validator_1.validateJsonlLine)(lines[i]);
+                if (validation.valid) {
+                    qualityCheck.active.valid++;
+                }
+                else {
+                    qualityCheck.active.invalid++;
+                    if (qualityCheck.active.issues.length < 5) {
+                        qualityCheck.active.issues.push({ line: i + 1, errors: validation.errors });
+                    }
+                }
+            }
+        }
+        if (fs.existsSync(archivePath)) {
+            const content = fs.readFileSync(archivePath, "utf-8");
+            const lines = content.split(/\r?\n/).filter(l => l.trim());
+            qualityCheck.archive.total = lines.length;
+            for (let i = 0; i < lines.length; i++) {
+                const validation = (0, llm_output_validator_1.validateJsonlLine)(lines[i]);
+                if (validation.valid) {
+                    qualityCheck.archive.valid++;
+                }
+                else {
+                    qualityCheck.archive.invalid++;
+                    if (qualityCheck.archive.issues.length < 5) {
+                        qualityCheck.archive.issues.push({ line: i + 1, errors: validation.errors });
+                    }
+                }
+            }
+        }
+        const totalInvalid = qualityCheck.active.invalid + qualityCheck.archive.invalid;
+        if (totalInvalid > 0) {
+            checks.push({ name: "Data integrity", passed: false, message: `${totalInvalid} invalid records found` });
+        }
+        else {
+            checks.push({ name: "Data integrity", passed: true, message: "All records valid" });
+        }
+        const graphMemoryPath = path.join(deps.memoryRoot, "graph", "memory.jsonl");
+        const graphRecords = readJsonl(graphMemoryPath);
+        function stringField(record, key) {
+            const value = record[key];
+            return typeof value === "string" ? value.trim() : "";
+        }
+        const activeFieldIssues = {
+            missing_id: 0,
+            missing_timestamp: 0,
+            missing_layer: 0,
+            missing_text_payload: 0,
+        };
+        for (const record of activeRecords) {
+            if (!stringField(record, "id"))
+                activeFieldIssues.missing_id += 1;
+            if (!stringField(record, "timestamp"))
+                activeFieldIssues.missing_timestamp += 1;
+            if (stringField(record, "layer") !== "active")
+                activeFieldIssues.missing_layer += 1;
+            const hasPayload = [
+                stringField(record, "summary"),
+                stringField(record, "source_text"),
+                stringField(record, "text"),
+                stringField(record, "message"),
+            ].some(Boolean);
+            if (!hasPayload)
+                activeFieldIssues.missing_text_payload += 1;
+        }
+        const archiveFieldIssues = {
+            missing_id: 0,
+            missing_timestamp: 0,
+            missing_layer: 0,
+            missing_summary: 0,
+            missing_source_memory_id: 0,
+        };
+        for (const record of archiveRecords) {
+            if (!stringField(record, "id"))
+                archiveFieldIssues.missing_id += 1;
+            if (!stringField(record, "timestamp"))
+                archiveFieldIssues.missing_timestamp += 1;
+            if (stringField(record, "layer") !== "archive")
+                archiveFieldIssues.missing_layer += 1;
+            if (!stringField(record, "summary"))
+                archiveFieldIssues.missing_summary += 1;
+            if (!stringField(record, "source_memory_id") && !stringField(record, "canonical_id")) {
+                archiveFieldIssues.missing_source_memory_id += 1;
+            }
+        }
+        const vectorFieldIssues = {
+            missing_id: 0,
+            missing_layer: 0,
+            missing_summary: 0,
+            missing_source_memory_id: 0,
+            missing_embedding: 0,
+        };
+        for (const record of vectorJsonlRecords) {
+            if (!stringField(record, "id"))
+                vectorFieldIssues.missing_id += 1;
+            const layer = stringField(record, "layer");
+            if (layer !== "active" && layer !== "archive")
+                vectorFieldIssues.missing_layer += 1;
+            if (!stringField(record, "summary"))
+                vectorFieldIssues.missing_summary += 1;
+            if (!stringField(record, "source_memory_id"))
+                vectorFieldIssues.missing_source_memory_id += 1;
+            const embedding = record.embedding;
+            const vector = record.vector;
+            const hasEmbedding = Array.isArray(embedding) ? embedding.length > 0 : (Array.isArray(vector) ? vector.length > 0 : false);
+            if (!hasEmbedding)
+                vectorFieldIssues.missing_embedding += 1;
+        }
+        const graphFieldIssues = {
+            missing_id: 0,
+            missing_event_ref: 0,
+            missing_layer: 0,
+            malformed_relations: 0,
+        };
+        for (const record of graphRecords) {
+            if (!stringField(record, "id"))
+                graphFieldIssues.missing_id += 1;
+            if (!stringField(record, "source_event_id") && !stringField(record, "archive_event_id")) {
+                graphFieldIssues.missing_event_ref += 1;
+            }
+            const layer = stringField(record, "source_layer");
+            if (layer !== "archive_event" && layer !== "active_only")
+                graphFieldIssues.missing_layer += 1;
+            if (!Array.isArray(record.relations))
+                graphFieldIssues.malformed_relations += 1;
+        }
+        const archiveIdSet = new Set(archiveRecords
+            .map(record => stringField(record, "id"))
+            .filter(Boolean));
+        const vectorLinkedToArchive = vectorJsonlRecords.filter(record => {
+            const sourceMemoryId = stringField(record, "source_memory_id");
+            return !!sourceMemoryId && archiveIdSet.has(sourceMemoryId);
+        }).length;
+        const graphLinkedToArchive = graphRecords.filter(record => {
+            const sourceLayer = stringField(record, "source_layer");
+            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)
+            + Object.values(graphFieldIssues).reduce((sum, n) => sum + n, 0);
+        checks.push({
+            name: "Field mapping alignment",
+            passed: schemaIssueTotal === 0,
+            message: schemaIssueTotal === 0
+                ? "active/archive/vector/graph field mapping aligned with read path"
+                : `${schemaIssueTotal} field mapping issues detected across four memory stores`,
+        });
         return {
             success: true,
             data: {
                 status: "ok",
+                prompt_versions: PROMPT_VERSIONS,
                 checks,
-                recommendations: [],
+                layers: {
+                    active: {
+                        records: activeRecords.length,
+                        path: activePath,
+                    },
+                    archive: {
+                        records: archiveRecords.length,
+                        path: archivePath,
+                    },
+                    vector: {
+                        storage_type: vectorStorageType,
+                        lancedb_exists: lancedbExists,
+                        active_coverage: activeVector.coverage,
+                        archive_coverage: archiveVector.coverage,
+                        active_unembedded: activeVector.pending + activeVector.failed,
+                        archive_unembedded: archiveVector.pending + archiveVector.failed,
+                        chunking: {
+                            chunk_size: deps.vectorChunking?.chunkSize ?? 600,
+                            chunk_overlap: deps.vectorChunking?.chunkOverlap ?? 100,
+                        },
+                        vector_jsonl_records: vectorJsonlRecords.length,
+                        vector_jsonl_by_layer: {
+                            active: activeVectorRecords.length,
+                            archive: archiveVectorRecords.length,
+                        },
+                        total_vector_records: totalVectorRecords,
+                        last_backfill_summary: lastVectorBackfill,
+                        backfill_state: {
+                            pending_retry_records: pendingRetry,
+                            has_state_file: fs.existsSync(path.join(deps.memoryRoot, ".vector_backfill_state.json")),
+                        },
+                    },
+                    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")),
+                    },
+                },
+                model_connectivity: {
+                    embedding: embeddingConnectivity,
+                    llm: llmConnectivity,
+                    reranker: rerankerConnectivity,
+                },
+                quality_check: qualityCheck,
+                schema_alignment: {
+                    active: {
+                        records: activeRecords.length,
+                        issues: activeFieldIssues,
+                    },
+                    archive: {
+                        records: archiveRecords.length,
+                        issues: archiveFieldIssues,
+                    },
+                    vector: {
+                        records: vectorJsonlRecords.length,
+                        issues: vectorFieldIssues,
+                        linked_to_archive: vectorLinkedToArchive,
+                    },
+                    graph: {
+                        records: graphRecords.length,
+                        issues: graphFieldIssues,
+                        linked_archive_events: graphLinkedToArchive,
+                    },
+                    cross_layer_links: {
+                        archive_records: archiveIdSet.size,
+                        vector_archive_link_coverage: archiveIdSet.size > 0
+                            ? Number((vectorLinkedToArchive / archiveIdSet.size).toFixed(4))
+                            : 0,
+                        graph_archive_link_coverage: archiveIdSet.size > 0
+                            ? Number((graphLinkedToArchive / archiveIdSet.size).toFixed(4))
+                            : 0,
+                    },
+                },
+                recommendations: [
+                    ...(totalInvalid > 0 ? ["Run repair-memory --fix to clean invalid records"] : []),
+                    ...(schemaIssueTotal > 0 ? ["Run diagnostics output schema_alignment and repair missing cross-layer fields"] : []),
+                ],
             },
         };
     }
     async function searchMemory(args, context) {
-        if (!args || !args.query) {
+        const argsRecord = asRecord(args) || {};
+        const argsInput = asRecord(argsRecord.input);
+        const queryCandidate = [
+            typeof args.query === "string" ? args.query : "",
+            typeof argsRecord.query === "string" ? String(argsRecord.query) : "",
+            typeof argsRecord.q === "string" ? String(argsRecord.q) : "",
+            typeof argsRecord.keyword === "string" ? String(argsRecord.keyword) : "",
+            typeof argsInput?.query === "string" ? String(argsInput.query) : "",
+            typeof argsInput?.q === "string" ? String(argsInput.q) : "",
+        ].find(item => item.trim());
+        const query = queryCandidate ? queryCandidate.trim() : "";
+        if (!query) {
             return {
                 success: false,
                 error: "Invalid input provided. Missing 'query' parameter.",
             };
         }
+        const topKRaw = [
+            typeof args.top_k === "number" ? args.top_k : undefined,
+            typeof argsRecord.top_k === "number" ? Number(argsRecord.top_k) : undefined,
+            typeof argsRecord.topK === "number" ? Number(argsRecord.topK) : undefined,
+            typeof argsInput?.top_k === "number" ? Number(argsInput.top_k) : undefined,
+            typeof argsInput?.topK === "number" ? Number(argsInput.topK) : undefined,
+        ].find(value => typeof value === "number" && Number.isFinite(value));
+        const fusionModeRaw = [
+            typeof args.fusion_mode === "string" ? args.fusion_mode : "",
+            typeof argsRecord.fusion_mode === "string" ? String(argsRecord.fusion_mode) : "",
+            typeof argsRecord.fusionMode === "string" ? String(argsRecord.fusionMode) : "",
+            typeof argsInput?.fusion_mode === "string" ? String(argsInput.fusion_mode) : "",
+            typeof argsInput?.fusionMode === "string" ? String(argsInput.fusionMode) : "",
+        ].find(value => value === "auto" || value === "authoritative" || value === "candidates" || value === "off");
+        const trackHitsRaw = [
+            typeof args.track_hits === "boolean" ? args.track_hits : undefined,
+            typeof argsRecord.track_hits === "boolean" ? Boolean(argsRecord.track_hits) : undefined,
+            typeof argsRecord.trackHits === "boolean" ? Boolean(argsRecord.trackHits) : undefined,
+            typeof argsInput?.track_hits === "boolean" ? Boolean(argsInput.track_hits) : undefined,
+            typeof argsInput?.trackHits === "boolean" ? Boolean(argsInput.trackHits) : undefined,
+        ].find(value => typeof value === "boolean");
         const result = await deps.readStore.searchMemory({
-            query: args.query,
-            topK: typeof args.top_k === "number" && args.top_k > 0 ? Math.floor(args.top_k) : 3,
+            query,
+            topK: typeof topKRaw === "number" && topKRaw > 0 ? Math.floor(topKRaw) : 3,
+            fusionMode: fusionModeRaw || "auto",
+            trackHits: trackHitsRaw !== false,
         });
-        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,
+                channel_results: result.channel_results,
+                vector_search_strategy: result.strategy,
+                timing_ms: result.timing_ms,
+                debug: result.debug,
+            },
+        };
     }
     async function getHotContext(args, _context) {
         const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 20;
@@ -471,12 +1674,22 @@ function createTsEngine(deps) {
         return { success: true, data: result.context };
     }
     async function getAutoContext(args, context) {
-        const sessionId = deps.resolveSessionId(context);
+        const argsRecord = asRecord(args) || {};
+        const argsInput = asRecord(argsRecord.input);
+        const includeHotRaw = [
+            typeof args.include_hot === "boolean" ? args.include_hot : undefined,
+            typeof argsRecord.include_hot === "boolean" ? Boolean(argsRecord.include_hot) : undefined,
+            typeof argsRecord.includeHot === "boolean" ? Boolean(argsRecord.includeHot) : undefined,
+            typeof argsInput?.include_hot === "boolean" ? Boolean(argsInput.include_hot) : undefined,
+            typeof argsInput?.includeHot === "boolean" ? Boolean(argsInput.includeHot) : undefined,
+        ].find(value => typeof value === "boolean");
+        const sessionId = deps.resolveSessionId((context || {}));
         const cached = deps.getCachedAutoSearch(sessionId);
         const result = await deps.readStore.getAutoContext({
-            includeHot: args.include_hot !== false,
+            includeHot: includeHotRaw !== false,
             sessionId,
             cachedAutoSearch: cached ?? undefined,
+            recentMessages: getRecentSessionMessages(sessionId, 8),
         });
         if (!result.auto_search && !result.hot_context) {
             return {
@@ -489,6 +1702,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();
@@ -549,9 +1805,17 @@ function createTsEngine(deps) {
         deps.logger.debug(`TS buffered ${role} message for session ${sessionId} source=${source}`);
         if (role === "user" && text.length > 5) {
             try {
-                const searchResult = await deps.readStore.searchMemory({ query: text, topK: 3 });
+                const historical = isHistoricalMemoryQuery(text);
+                const query = buildAutoSearchQuery(sessionId, text, historical);
+                const searchResult = await deps.readStore.searchMemory({
+                    query,
+                    topK: 3,
+                    mode: historical ? "auto" : "lightweight",
+                    fusionMode: "off",
+                    trackHits: false,
+                });
                 if (searchResult.results.length > 0) {
-                    deps.setSessionAutoSearchCache(sessionId, text, searchResult.results);
+                    deps.setSessionAutoSearchCache(sessionId, query, searchResult.results);
                     deps.logger.info(`TS auto-search cached ${searchResult.results.length} results for context`);
                 }
             }
@@ -582,12 +1846,17 @@ function createTsEngine(deps) {
         getAutoContext,
         storeEvent,
         queryGraph,
+        exportGraphView,
+        lintMemoryWiki,
+        listGraphConflicts,
+        resolveGraphConflict,
         reflectMemory,
         syncMemory,
         promoteMemory,
         deleteMemory,
         updateMemory,
         cleanupMemories,
+        backfillEmbeddings,
         runDiagnostics,
         onMessage,
         onSessionEnd,