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

package/dist/src/sync/session_sync.js

@@ -37,6 +37,9 @@ exports.createSessionSync = createSessionSync;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const http_post_1 = require("../net/http_post");
+const llm_output_validator_1 = require("../quality/llm_output_validator");
+const runtime_env_1 = require("../utils/runtime_env");
 function asRecord(value) {
     if (typeof value === "object" && value !== null) {
         return value;
@@ -51,23 +54,64 @@ function firstString(values) {
     }
     return undefined;
 }
+function extractTextFromContent(content) {
+    if (typeof content === "string" && content.trim()) {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return undefined;
+    }
+    const parts = [];
+    for (const item of content) {
+        if (typeof item === "string" && item.trim()) {
+            parts.push(item.trim());
+            continue;
+        }
+        const obj = asRecord(item);
+        if (!obj) {
+            continue;
+        }
+        const text = firstString([obj.text, obj.content, obj.summary, obj.message, obj.body]);
+        if (text) {
+            parts.push(text);
+        }
+    }
+    if (parts.length === 0) {
+        return undefined;
+    }
+    return parts.join("\n");
+}
+function extractTextFromMessageRecord(record) {
+    const contentText = extractTextFromContent(record.content);
+    return firstString([contentText, record.text, record.summary, record.message, record.body]);
+}
+const SYNC_STATE_VERSION = "2";
+function createDefaultState() {
+    return { version: SYNC_STATE_VERSION, files: {}, markdowns: {} };
+}
 function readState(filePath) {
     try {
         if (!fs.existsSync(filePath)) {
-            return { files: {} };
+            return createDefaultState();
         }
         const content = fs.readFileSync(filePath, "utf-8").trim();
         if (!content) {
-            return { files: {} };
+            return createDefaultState();
         }
         const parsed = JSON.parse(content);
         if (!parsed.files || typeof parsed.files !== "object") {
-            return { files: {} };
+            return createDefaultState();
+        }
+        if (!parsed.markdowns || typeof parsed.markdowns !== "object") {
+            parsed.markdowns = {};
         }
+        parsed.version = typeof parsed.version === "string" && parsed.version.trim()
+            ? parsed.version
+            : SYNC_STATE_VERSION;
         return parsed;
     }
     catch {
-        return { files: {} };
+        return createDefaultState();
     }
 }
 function writeState(filePath, state) {
@@ -75,6 +119,7 @@ function writeState(filePath, state) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
+    state.version = SYNC_STATE_VERSION;
     fs.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function gatherSessionFiles(openclawBasePath, memoryRoot) {
@@ -93,12 +138,37 @@ function gatherSessionFiles(openclawBasePath, memoryRoot) {
     }
     return [...results];
 }
+function gatherDailySummaryFiles(openclawBasePath) {
+    const summaryDir = path.join(openclawBasePath, "workspace", "memory");
+    if (!fs.existsSync(summaryDir) || !fs.statSync(summaryDir).isDirectory()) {
+        return [];
+    }
+    const files = [];
+    for (const entry of fs.readdirSync(summaryDir)) {
+        if (!entry.toLowerCase().endsWith(".md")) {
+            continue;
+        }
+        const filePath = path.join(summaryDir, entry);
+        if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+            files.push(filePath);
+        }
+    }
+    return files;
+}
 function inferOpenclawBasePath(projectRoot) {
-    const fromEnv = process.env.OPENCLAW_BASE_PATH;
-    if (fromEnv && fs.existsSync(fromEnv)) {
-        return fromEnv;
+    const configPath = (0, runtime_env_1.getEnvValue)("OPENCLAW_CONFIG_PATH");
+    if (configPath && fs.existsSync(configPath)) {
+        return path.dirname(configPath);
+    }
+    const stateDir = (0, runtime_env_1.getEnvValue)("OPENCLAW_STATE_DIR");
+    if (stateDir && fs.existsSync(stateDir)) {
+        return stateDir;
+    }
+    const basePath = (0, runtime_env_1.getEnvValue)("OPENCLAW_BASE_PATH");
+    if (basePath && fs.existsSync(basePath)) {
+        return basePath;
     }
-    const home = process.env.USERPROFILE || process.env.HOME || "";
+    const home = (0, runtime_env_1.getHomeDir)();
     if (home) {
         const defaultPath = path.join(home, ".openclaw");
         if (fs.existsSync(defaultPath)) {
@@ -118,7 +188,7 @@ function extractMessages(record) {
             const obj = asRecord(item);
             if (!obj)
                 continue;
-            const text = firstString([obj.content, obj.summary, obj.text, obj.message, obj.body]);
+            const text = extractTextFromMessageRecord(obj);
             if (!text)
                 continue;
             const role = firstString([obj.role, obj.senderRole, obj.fromRole]) || "unknown";
@@ -128,31 +198,615 @@ function extractMessages(record) {
             return output;
         }
     }
-    const text = firstString([record.content, record.summary, record.text, record.message]);
+    const nestedMessage = asRecord(record.message);
+    if (nestedMessage) {
+        const text = extractTextFromMessageRecord(nestedMessage);
+        if (text) {
+            return [{ role: firstString([nestedMessage.role, record.role, record.senderRole, record.fromRole]) || "unknown", text }];
+        }
+    }
+    const text = extractTextFromMessageRecord(record);
     if (text) {
         return [{ role: firstString([record.role, record.senderRole, record.fromRole]) || "unknown", text }];
     }
     return [];
 }
 function getSessionId(record, fallbackSeed) {
+    const sessionObj = asRecord(record.session);
+    const type = firstString([record.type])?.toLowerCase();
+    const typeScopedId = type === "session" ? firstString([record.id]) : undefined;
     return (firstString([
         record.sessionId,
         record.session_id,
         record.conversationId,
         record.conversation_id,
-        record.id,
+        sessionObj?.id,
+        sessionObj?.sessionId,
+        typeScopedId,
     ]) || `sync:${fallbackSeed}`);
 }
+function parseDailySummary(content) {
+    const normalized = content
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(line => !line.startsWith("```"));
+    const chunks = [];
+    let current = [];
+    for (const line of normalized) {
+        const isHeader = line.startsWith("#");
+        const isBullet = /^[-*]\s+/.test(line);
+        if (isHeader && current.length > 0) {
+            chunks.push(current.join("\n"));
+            current = [];
+        }
+        current.push(line);
+        if (isBullet && current.length >= 6) {
+            chunks.push(current.join("\n"));
+            current = [];
+        }
+    }
+    if (current.length > 0) {
+        chunks.push(current.join("\n"));
+    }
+    return chunks.map(chunk => chunk.trim()).filter(chunk => chunk.length >= 10);
+}
+function normalizeBaseUrl(value) {
+    if (!value)
+        return "";
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function buildEventSnippet(text) {
+    const lines = text
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(line => line.length >= 8);
+    const actionPattern = /(决定|完成|修复|阻塞|失败|成功|上线|部署|实现|依赖|owner|blocked|resolved|fixed|depends|decide|complete)/i;
+    const picked = lines.filter(line => actionPattern.test(line));
+    const use = picked.length > 0 ? picked : lines.slice(-20);
+    return use.slice(-30).join("\n").slice(-8000);
+}
+const WRITE_GATE_PROMPT_VERSION = "write-gate.v1.3.0";
+const WRITE_GATE_REGRESSION_SAMPLES = [
+    "鏍蜂緥A: 鈥滀粖澶╄璁轰簡涓夌鏂规锛屽皻鏈喅绛栤€?=> active_only",
+    "鏍蜂緥B: 鈥滃喅瀹氶噰鐢˙鏂规骞跺畬鎴愪笂绾匡紝閿欒鐜囦笅闄嶅埌0.2%鈥?=> archive_event",
+    "鏍蜂緥C: 鈥滃ソ鐨勬敹鍒拌阿璋⑩€?=> skip",
+];
+function parseArchiveEventPayload(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const obj = value;
+    const eventType = typeof obj.event_type === "string" ? obj.event_type.trim() : "";
+    const summary = typeof obj.summary === "string" ? obj.summary.trim() : "";
+    if (!eventType || !summary) {
+        return null;
+    }
+    const entities = Array.isArray(obj.entities)
+        ? obj.entities.map(v => (typeof v === "string" ? v.trim() : "")).filter(Boolean)
+        : [];
+    const relations = Array.isArray(obj.relations)
+        ? obj.relations
+            .map(valueItem => {
+            if (!valueItem || typeof valueItem !== "object")
+                return null;
+            const relation = valueItem;
+            const source = typeof relation.source === "string" ? relation.source.trim() : "";
+            const target = typeof relation.target === "string" ? relation.target.trim() : "";
+            const type = typeof relation.type === "string" ? relation.type.trim() : "related_to";
+            const evidenceSpan = typeof relation.evidence_span === "string" ? relation.evidence_span.trim() : "";
+            const confidence = typeof relation.confidence === "number"
+                ? Math.max(0, Math.min(1, relation.confidence))
+                : undefined;
+            if (!source || !target)
+                return null;
+            return { source, target, type, evidence_span: evidenceSpan || undefined, confidence };
+        })
+            .filter(Boolean)
+        : [];
+    const entity_types = typeof obj.entity_types === "object" && obj.entity_types !== null && !Array.isArray(obj.entity_types)
+        ? Object.fromEntries(Object.entries(obj.entity_types)
+            .filter(([key, value]) => typeof key === "string" && key.trim().length > 0 && typeof value === "string" && value.trim().length > 0)
+            .map(([key, value]) => [key.trim(), value.trim()]))
+        : undefined;
+    return {
+        event_type: eventType,
+        summary,
+        entities,
+        entity_types,
+        relations,
+        outcome: typeof obj.outcome === "string" ? obj.outcome.trim() : "",
+        confidence: typeof obj.confidence === "number" ? Math.max(0, Math.min(1, obj.confidence)) : 0.6,
+    };
+}
+function parseGraphPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const obj = value;
+    const entities = Array.isArray(obj.entities)
+        ? obj.entities.map(v => (typeof v === "string" ? v.trim() : "")).filter(Boolean)
+        : [];
+    const entity_types = typeof obj.entity_types === "object" && obj.entity_types !== null && !Array.isArray(obj.entity_types)
+        ? Object.fromEntries(Object.entries(obj.entity_types)
+            .filter(([key, val]) => typeof key === "string" && key.trim() && typeof val === "string" && val.trim())
+            .map(([key, val]) => [key.trim(), val.trim()]))
+        : undefined;
+    const relations = Array.isArray(obj.relations)
+        ? obj.relations
+            .map(item => {
+            if (!item || typeof item !== "object")
+                return null;
+            const rel = item;
+            const source = typeof rel.source === "string" ? rel.source.trim() : "";
+            const target = typeof rel.target === "string" ? rel.target.trim() : "";
+            const type = typeof rel.type === "string" && rel.type.trim() ? rel.type.trim() : "related_to";
+            if (!source || !target)
+                return null;
+            const evidenceSpan = typeof rel.evidence_span === "string" ? rel.evidence_span.trim() : "";
+            const confidence = typeof rel.confidence === "number"
+                ? Math.max(0, Math.min(1, rel.confidence))
+                : undefined;
+            return {
+                source,
+                target,
+                type,
+                ...(evidenceSpan ? { evidence_span: evidenceSpan } : {}),
+                ...(typeof confidence === "number" ? { confidence } : {}),
+            };
+        })
+            .filter((item) => item !== null)
+        : [];
+    if (entities.length === 0 || relations.length === 0) {
+        return null;
+    }
+    return {
+        entities,
+        entity_types,
+        relations,
+        confidence: typeof obj.confidence === "number" ? Math.max(0, Math.min(1, obj.confidence)) : undefined,
+    };
+}
+function parseLlmGateDecisions(raw, logger) {
+    const validation = (0, llm_output_validator_1.validateLlmJsonOutput)(raw);
+    if (!validation.valid) {
+        if (logger) {
+            logger.warn(`quality_gate_decisions_invalid errors=${validation.errors.join("|")}`);
+        }
+        return [];
+    }
+    if (validation.warnings.length > 0 && logger) {
+        logger.debug(`quality_gate_decisions_warnings warnings=${validation.warnings.join("|")}`);
+    }
+    const root = validation.data;
+    const parsed = Array.isArray(root) ? root : root;
+    const output = [];
+    const pushDecision = (obj, target) => {
+        let event = null;
+        if (target === "archive_event") {
+            const eventValidation = (0, llm_output_validator_1.validateArchiveEvent)(obj.event || obj);
+            if (eventValidation.valid && eventValidation.cleaned) {
+                event = {
+                    event_type: eventValidation.cleaned.event_type || "insight",
+                    summary: eventValidation.cleaned.summary,
+                    entities: eventValidation.cleaned.entities,
+                    entity_types: eventValidation.cleaned.entity_types,
+                    relations: eventValidation.cleaned.relations,
+                    outcome: eventValidation.cleaned.outcome || "",
+                    confidence: eventValidation.cleaned.confidence,
+                };
+            }
+            else {
+                if (logger) {
+                    logger.warn(`quality_event_invalid errors=${eventValidation.errors.join("|")}`);
+                }
+                return;
+            }
+        }
+        output.push({
+            candidate_id: typeof obj.candidate_id === "string" ? obj.candidate_id.trim() : "",
+            target_layer: target,
+            active_text: typeof obj.active_text === "string" ? obj.active_text.trim() : "",
+            event: event || undefined,
+            graph: parseGraphPayload(obj.graph) || undefined,
+            reason: typeof obj.reason === "string" ? obj.reason.trim() : "",
+        });
+    };
+    if (Array.isArray(parsed)) {
+        if (logger) {
+            logger.warn("quality_gate_decisions_invalid format=array_not_supported_require_routing_plan");
+        }
+    }
+    else if (parsed && typeof parsed === "object") {
+        const rootObj = parsed;
+        const routingPlan = (typeof rootObj.routing_plan === "object" && rootObj.routing_plan !== null)
+            ? rootObj.routing_plan
+            : null;
+        if (routingPlan) {
+            const buckets = [
+                { key: "archive_event", items: routingPlan.archive_event },
+                { key: "active_only", items: routingPlan.active_only },
+                { key: "skip", items: routingPlan.skip },
+            ];
+            for (const bucket of buckets) {
+                if (!Array.isArray(bucket.items))
+                    continue;
+                for (const item of bucket.items) {
+                    if (!item || typeof item !== "object")
+                        continue;
+                    pushDecision(item, bucket.key);
+                }
+            }
+        }
+        else if (logger) {
+            logger.warn("quality_gate_decisions_invalid missing_routing_plan");
+        }
+    }
+    if (output.length === 0 && logger) {
+        logger.warn("quality_gate_decisions_empty");
+    }
+    const deduped = [];
+    const seen = new Set();
+    for (const item of output) {
+        const key = `${item.target_layer}|${item.event?.summary || item.active_text || item.reason || ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(item);
+    }
+    return deduped;
+}
+async function extractGateDecisionsWithLlm(args) {
+    const endpoint = args.llm.baseUrl.endsWith("/chat/completions")
+        ? args.llm.baseUrl
+        : `${args.llm.baseUrl}/chat/completions`;
+    const body = {
+        model: args.llm.model,
+        temperature: 0.1,
+        response_format: { type: "json_object" },
+        messages: [
+            { role: "system", content: "You are a memory write-gate router. Output JSON only." },
+            {
+                role: "user",
+                content: [
+                    `prompt_version=${WRITE_GATE_PROMPT_VERSION}`,
+                    "Execute in 3 stages:",
+                    "Stage1) Split transcript into candidate_events[]. One candidate should contain one principal event only.",
+                    "Stage2) Route each candidate_event into target_layer: active_only | archive_event | skip.",
+                    "Stage3) Output routing plan only. Do NOT claim data has been written.",
+                    "Classification:",
+                    "A) active_only: process context, ongoing discussion, temporary status, no stable conclusion.",
+                    "B) archive_event: reusable event with clear subject + action/decision + outcome/phase conclusion.",
+                    "C) skip: noise/repetition/chitchat/no clear business value.",
+                    "Constraints:",
+                    "- For archive_event: if confidence < 0.35, prefer skip.",
+                    "- Relations must be grounded in source text. Do not fabricate.",
+                    "- For active_only: active_text is required.",
+                    "- Optional graph for active_only: graph={entities[],entity_types,relations[],confidence}.",
+                    "- For relations: each relation should include source,target,type,evidence_span,confidence.",
+                    "- If evidence_span or confidence is missing, do not output that relation.",
+                    "Output JSON schema:",
+                    "{\"candidate_events\":[{\"candidate_id\":\"c1\",\"span\":\"...\",\"normalized_text\":\"...\"}],\"routing_plan\":{\"archive_event\":[{\"candidate_id\":\"c1\",\"event\":{\"event_type\":\"decision\",\"summary\":\"...\",\"entities\":[\"A\"],\"entity_types\":{\"A\":\"Project\"},\"relations\":[],\"outcome\":\"...\",\"confidence\":0.82}}],\"active_only\":[],\"skip\":[]}}",
+                    "routing_plan.archive_event[] item: {candidate_id,event}",
+                    "routing_plan.active_only[] item: {candidate_id,active_text,graph}",
+                    "routing_plan.skip[] item: {candidate_id,reason}",
+                    ...WRITE_GATE_REGRESSION_SAMPLES,
+                    "Output JSON only.",
+                    "",
+                    buildEventSnippet(args.transcript),
+                ].join("\n"),
+            },
+        ],
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        const response = await (0, http_post_1.postJsonWithTimeout)({
+            endpoint,
+            apiKey: args.llm.apiKey,
+            body,
+            timeoutMs: 25000,
+        });
+        if (!response.ok) {
+            lastError = new Error(response.status > 0 ? `sync_llm_http_${response.status}` : (response.error || "sync_llm_network_error"));
+            continue;
+        }
+        try {
+            const json = (response.json || {});
+            const content = json?.choices?.[0]?.message?.content || "";
+            if (!content.trim()) {
+                lastError = new Error("sync_llm_empty");
+                continue;
+            }
+            return parseLlmGateDecisions(content, args.logger);
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    args.logger.warn(`Sync LLM extraction failed: ${String(lastError || "unknown")}`);
+    return [];
+}
 function createSessionSync(options) {
     const memoryRoot = options.dbPath ? path.resolve(options.dbPath) : path.join(options.projectRoot, "data", "memory");
     const statePath = path.join(memoryRoot, ".sync_state.json");
     const openclawBasePath = inferOpenclawBasePath(options.projectRoot);
+    const llmModel = options.llm?.model || "";
+    const llmApiKey = options.llm?.apiKey || "";
+    const llmBaseUrl = normalizeBaseUrl(options.llm?.baseURL || options.llm?.baseUrl);
+    const requireLlmForWrite = options.requireLlmForWrite !== false;
+    options.logger.info(`sync_gate_prompt_version=${WRITE_GATE_PROMPT_VERSION}`);
+    if (!fs.existsSync(statePath)) {
+        options.logger.warn("sync_state_missing: deleting state file triggers full re-import");
+    }
+    async function storeFromTranscript(args) {
+        const skipReasons = {};
+        const activeTextMaxChars = typeof options.writePolicy?.activeTextMaxChars === "number"
+            ? Math.max(500, Math.min(20000, Math.floor(options.writePolicy.activeTextMaxChars)))
+            : 4000;
+        const archiveSourceTextMaxChars = typeof options.writePolicy?.archiveSourceTextMaxChars === "number"
+            ? Math.max(1000, Math.min(30000, Math.floor(options.writePolicy.archiveSourceTextMaxChars)))
+            : 8000;
+        function bumpReason(reason) {
+            const key = reason || "unknown";
+            skipReasons[key] = (skipReasons[key] || 0) + 1;
+        }
+        if (!args.transcript.trim()) {
+            options.logger.info(`sync_skip reason=no_active_records session=${args.sessionId}`);
+            bumpReason("no_active_records");
+            return { imported: 0, skipped: 1, ok: true, llmDecisions: 0, activeOnly: 0, archiveEvent: 0, skipReasons };
+        }
+        if (!llmModel || !llmApiKey || !llmBaseUrl) {
+            if (requireLlmForWrite) {
+                options.logger.warn(`sync_skip reason=llm_not_configured session=${args.sessionId}`);
+                bumpReason("llm_not_configured");
+                return { imported: 0, skipped: 1, ok: false, llmDecisions: 0, activeOnly: 0, archiveEvent: 0, skipReasons };
+            }
+            options.logger.warn(`Sync gate degraded to active_only for ${args.sessionId}: llm_not_configured`);
+            const fallbackWrite = await options.writeStore.writeMemory({
+                text: args.transcript.slice(-activeTextMaxChars),
+                role: "system",
+                source: `sync_gate_fallback:${args.sourceFile}`,
+                sessionId: args.sessionId,
+            });
+            if (fallbackWrite.status === "ok") {
+                return { imported: 1, skipped: 0, ok: true, llmDecisions: 1, activeOnly: 1, archiveEvent: 0, skipReasons };
+            }
+            bumpReason(fallbackWrite.reason || "active_only_fallback_failed");
+            return { imported: 0, skipped: 1, ok: false, llmDecisions: 1, activeOnly: 0, archiveEvent: 0, skipReasons };
+        }
+        const decisions = await extractGateDecisionsWithLlm({
+            llm: { model: llmModel, apiKey: llmApiKey, baseUrl: llmBaseUrl },
+            transcript: args.transcript,
+            logger: options.logger,
+        });
+        if (decisions.length === 0) {
+            options.logger.info(`sync_skip reason=llm_extract_empty session=${args.sessionId}`);
+            bumpReason("llm_extract_empty");
+            return { imported: 0, skipped: 1, ok: true, llmDecisions: 0, activeOnly: 0, archiveEvent: 0, skipReasons };
+        }
+        let llmDecisions = 0;
+        let imported = 0;
+        let skipped = 0;
+        let activeOnly = 0;
+        let archiveEvent = 0;
+        let activeAttempted = 0;
+        let archiveAttempted = 0;
+        let graphAttempted = 0;
+        let graphStored = 0;
+        let graphSkipped = 0;
+        const archiveInputs = [];
+        for (const decision of decisions) {
+            llmDecisions += 1;
+            if (decision.target_layer === "skip") {
+                skipped += 1;
+                bumpReason(decision.reason || "llm_gate_skip");
+                continue;
+            }
+            if (decision.target_layer === "active_only") {
+                activeAttempted += 1;
+                const activeText = (decision.active_text || args.transcript).trim().slice(-activeTextMaxChars);
+                if (!activeText) {
+                    skipped += 1;
+                    bumpReason("active_only_empty");
+                    continue;
+                }
+                const writeResult = await options.writeStore.writeMemory({
+                    text: activeText,
+                    role: "system",
+                    source: `sync_gate_active:${args.sourceFile}`,
+                    sessionId: args.sessionId,
+                });
+                if (writeResult.status === "ok") {
+                    imported += 1;
+                    activeOnly += 1;
+                    if (options.graphMemoryStore && decision.graph) {
+                        graphAttempted += 1;
+                        const relationFingerprint = (decision.graph.relations || [])
+                            .map(rel => `${rel.source}|${rel.type}|${rel.target}|${rel.evidence_span || ""}`)
+                            .sort()
+                            .join("||");
+                        const activeSourceEventId = `active:${args.sessionId}:${crypto.createHash("sha1").update(relationFingerprint || activeText).digest("hex").slice(0, 16)}`;
+                        const graphResult = await options.graphMemoryStore.append({
+                            sourceEventId: activeSourceEventId,
+                            sourceLayer: "active_only",
+                            sessionId: args.sessionId,
+                            sourceFile: args.sourceFile,
+                            eventType: "insight",
+                            entities: decision.graph.entities,
+                            entity_types: decision.graph.entity_types,
+                            relations: decision.graph.relations,
+                            gateSource: "sync",
+                            confidence: decision.graph.confidence,
+                            sourceText: activeText,
+                        });
+                        if (!graphResult.success) {
+                            graphSkipped += 1;
+                            options.logger.info(`graph_skip_reason=${graphResult.reason} source_event_id=${activeSourceEventId}`);
+                        }
+                        else {
+                            graphStored += 1;
+                        }
+                    }
+                }
+                else {
+                    skipped += 1;
+                    bumpReason(writeResult.reason || "active_only_write_skipped");
+                }
+                continue;
+            }
+            if (decision.target_layer === "archive_event") {
+                archiveAttempted += 1;
+                if (!decision.event) {
+                    skipped += 1;
+                    bumpReason("archive_event_missing_payload");
+                    continue;
+                }
+                archiveInputs.push({
+                    event_type: decision.event.event_type,
+                    summary: decision.event.summary,
+                    entities: decision.event.entities,
+                    relations: decision.event.relations,
+                    entity_types: decision.event.entity_types,
+                    outcome: decision.event.outcome,
+                    confidence: decision.event.confidence,
+                    session_id: args.sessionId,
+                    source_file: args.sourceFile,
+                    source_text: args.transcript.slice(-archiveSourceTextMaxChars),
+                    source_event_id: decision.candidate_id
+                        ? `candidate:${args.sessionId}:${decision.candidate_id}`
+                        : `candidate:${args.sessionId}:${crypto.createHash("sha1").update(decision.event.summary).digest("hex").slice(0, 16)}`,
+                    actor: "sync_llm_gate",
+                });
+            }
+        }
+        if (archiveInputs.length > 0) {
+            let archivedSuccess = 0;
+            let archivedSkipped = 0;
+            for (const inputRecord of archiveInputs) {
+                const archiveResult = await options.archiveStore.storeEvents([inputRecord]);
+                imported += archiveResult.stored.length;
+                skipped += archiveResult.skipped.length;
+                archiveEvent += archiveResult.stored.length;
+                archivedSuccess += archiveResult.stored.length;
+                archivedSkipped += archiveResult.skipped.length;
+                for (const skip of archiveResult.skipped) {
+                    bumpReason(skip.reason || "archive_store_skipped");
+                }
+                const archiveRecord = archiveResult.stored[0];
+                if (!archiveRecord) {
+                    continue;
+                }
+                if (!options.graphMemoryStore) {
+                    continue;
+                }
+                graphAttempted += 1;
+                const graphResult = await options.graphMemoryStore.append({
+                    // Graph trace points to persisted archive record id for stable lookup.
+                    sourceEventId: archiveRecord.id,
+                    sourceLayer: "archive_event",
+                    archiveEventId: archiveRecord.id,
+                    sessionId: args.sessionId,
+                    sourceFile: args.sourceFile,
+                    eventType: inputRecord.event_type,
+                    entities: inputRecord.entities,
+                    entity_types: inputRecord.entity_types,
+                    relations: inputRecord.relations,
+                    gateSource: "sync",
+                    confidence: inputRecord.confidence,
+                    sourceText: args.transcript,
+                });
+                if (!graphResult.success) {
+                    graphSkipped += 1;
+                    options.logger.info(`graph_skip_reason=${graphResult.reason} source_event_id=${archiveRecord.id}`);
+                }
+                else {
+                    graphStored += 1;
+                }
+            }
+            options.logger.info(`sync_archive_result session=${args.sessionId} archived_success=${archivedSuccess} skipped=${archivedSkipped}`);
+        }
+        options.logger.info(`sync_gate_result session=${args.sessionId} llm_decisions=${llmDecisions} active_only=${activeOnly} archive_event=${archiveEvent} skipped=${skipped}`);
+        options.logger.info(`sync_gate_metrics session=${args.sessionId} active_attempted=${activeAttempted} archive_attempted=${archiveAttempted} graph_attempted=${graphAttempted} graph_stored=${graphStored} graph_skipped=${graphSkipped} skip_reason_kinds=${Object.keys(skipReasons).length}`);
+        return {
+            imported,
+            skipped,
+            ok: true,
+            llmDecisions,
+            activeOnly,
+            archiveEvent,
+            skipReasons,
+        };
+    }
+    async function syncDailySummaries() {
+        const files = gatherDailySummaryFiles(openclawBasePath);
+        const state = readState(statePath);
+        if (!state.markdowns || typeof state.markdowns !== "object") {
+            state.markdowns = {};
+        }
+        let imported = 0;
+        let skipped = 0;
+        let filesProcessed = 0;
+        let llmDecisions = 0;
+        let activeOnly = 0;
+        let archiveEvent = 0;
+        const skipReasons = {};
+        for (const filePath of files) {
+            if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+                continue;
+            }
+            const content = fs.readFileSync(filePath, "utf-8");
+            const digest = crypto.createHash("sha1").update(content).digest("hex");
+            const prev = state.markdowns[filePath];
+            if (prev && prev.digest === digest) {
+                skipped += 1;
+                continue;
+            }
+            const chunks = parseDailySummary(content);
+            if (chunks.length === 0) {
+                state.markdowns[filePath] = { digest, importedAt: new Date().toISOString() };
+                skipped += 1;
+                continue;
+            }
+            const summarySessionId = `daily_summary:${path.basename(filePath)}`;
+            const transcript = chunks.join("\n");
+            const result = await storeFromTranscript({
+                sessionId: summarySessionId,
+                sourceFile: `daily_summary_sync:${path.basename(filePath)}`,
+                transcript,
+            });
+            imported += result.imported;
+            skipped += result.skipped;
+            llmDecisions += result.llmDecisions;
+            activeOnly += result.activeOnly;
+            archiveEvent += result.archiveEvent;
+            for (const [key, count] of Object.entries(result.skipReasons)) {
+                skipReasons[key] = (skipReasons[key] || 0) + count;
+            }
+            if (!result.ok) {
+                continue;
+            }
+            state.markdowns[filePath] = { digest, importedAt: new Date().toISOString() };
+            filesProcessed += 1;
+        }
+        writeState(statePath, state);
+        options.logger.info(`TS daily summary sync completed: imported=${imported}, skipped=${skipped}, files=${filesProcessed}`);
+        return { imported, skipped, filesProcessed, llmDecisions, activeOnly, archiveEvent, skipReasons };
+    }
     async function syncMemory() {
         const files = gatherSessionFiles(openclawBasePath, memoryRoot);
+        if (files.length === 0) {
+            options.logger.info("sync_skip reason=no_active_records");
+        }
         const state = readState(statePath);
         let imported = 0;
         let skipped = 0;
         let filesProcessed = 0;
+        let llmDecisions = 0;
+        let activeOnly = 0;
+        let archiveEvent = 0;
+        const skipReasons = {};
         for (const filePath of files) {
             if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
                 continue;
@@ -169,32 +823,34 @@ function createSessionSync(options) {
                 state.files[filePath] = { size: stat.size, lineCount: lines.length };
                 continue;
             }
+            const bySession = new Map();
+            let fileHasFailure = false;
+            const fileSessionSeed = path.basename(filePath, path.extname(filePath));
+            let fileSessionId;
             for (let i = startIndex; i < lines.length; i++) {
                 const line = lines[i].trim();
                 if (!line)
                     continue;
-                const hash = crypto.createHash("sha1").update(line).digest("hex").slice(0, 12);
                 try {
                     const record = JSON.parse(line);
+                    if (!fileSessionId) {
+                        const inferred = getSessionId(record, fileSessionSeed);
+                        if (inferred && inferred !== `sync:${fileSessionSeed}`) {
+                            fileSessionId = inferred;
+                        }
+                    }
                     const messages = extractMessages(record);
                     if (messages.length === 0) {
                         skipped += 1;
                         continue;
                     }
-                    const sessionId = getSessionId(record, `${path.basename(filePath)}:${hash}`);
+                    const fallbackSession = fileSessionId || fileSessionSeed;
+                    const sessionId = getSessionId(record, fallbackSession);
                     for (const msg of messages) {
-                        const result = await options.writeStore.writeMemory({
-                            text: msg.text,
-                            role: msg.role,
-                            source: "sync",
-                            sessionId,
-                        });
-                        if (result.status === "ok") {
-                            imported += 1;
-                        }
-                        else {
-                            skipped += 1;
+                        if (!bySession.has(sessionId)) {
+                            bySession.set(sessionId, []);
                         }
+                        bySession.get(sessionId)?.push(`[${msg.role}] ${msg.text}`);
                     }
                 }
                 catch (error) {
@@ -202,13 +858,54 @@ function createSessionSync(options) {
                     skipped += 1;
                 }
             }
+            for (const [sessionId, messages] of bySession.entries()) {
+                const transcript = messages.join("\n");
+                const result = await storeFromTranscript({
+                    sessionId,
+                    sourceFile: `sync:${path.basename(filePath)}`,
+                    transcript,
+                });
+                imported += result.imported;
+                skipped += result.skipped;
+                llmDecisions += result.llmDecisions;
+                activeOnly += result.activeOnly;
+                archiveEvent += result.archiveEvent;
+                for (const [key, count] of Object.entries(result.skipReasons)) {
+                    skipReasons[key] = (skipReasons[key] || 0) + count;
+                }
+                if (!result.ok) {
+                    fileHasFailure = true;
+                }
+            }
             filesProcessed += 1;
-            state.files[filePath] = { size: stat.size, lineCount: lines.length };
+            if (!fileHasFailure) {
+                state.files[filePath] = { size: stat.size, lineCount: lines.length };
+            }
         }
         writeState(statePath, state);
-        options.logger.info(`TS sync completed: imported=${imported}, skipped=${skipped}, files=${filesProcessed}`);
-        return { imported, skipped, filesProcessed };
+        const summary = await syncDailySummaries();
+        llmDecisions += summary.llmDecisions;
+        activeOnly += summary.activeOnly;
+        archiveEvent += summary.archiveEvent;
+        for (const [key, count] of Object.entries(summary.skipReasons)) {
+            skipReasons[key] = (skipReasons[key] || 0) + count;
+        }
+        options.logger.info(`TS sync completed: imported=${imported}, skipped=${skipped}, files=${filesProcessed}, summaryImported=${summary.imported}, summarySkipped=${summary.skipped}, llmDecisions=${llmDecisions}, activeOnly=${activeOnly}, archiveEvent=${archiveEvent}`);
+        return {
+            imported,
+            skipped,
+            filesProcessed,
+            summaryImported: summary.imported,
+            summarySkipped: summary.skipped,
+            llmDecisions,
+            activeOnly,
+            archiveEvent,
+            skipReasons,
+        };
+    }
+    async function routeTranscript(args) {
+        return storeFromTranscript(args);
     }
-    return { syncMemory };
+    return { syncMemory, syncDailySummaries, routeTranscript };
 }
 //# sourceMappingURL=session_sync.js.map