@kinqs/brainrouter-mcp-server 0.3.4

package/dist/tools/agent_memory_tools.js

@@ -0,0 +1,793 @@
+import { z } from "zod";
+import crypto from "node:crypto";
+import { memoryEngine } from "../memory/engine.js";
+import { L1CommitPayloadSchema, ContradictionDecisionCommitSchema, GraphCommitSchema, L2CommitSchema, L3CommitSchema, normalizeSceneName, normalizeSkillTag, normalizeMemoryContent, normalizeEntityName, validateL0RecordOwnership, validateL1RecordOwnership, } from "../memory/validation.js";
+import { EXTRACT_MEMORIES_SYSTEM_PROMPT, formatExtractionPrompt } from "../memory/prompts/l1-extraction.js";
+import { L1_CONTRADICTION_PROMPT } from "../memory/prompts/l1-contradiction.js";
+import { GRAPH_EXTRACTION_SYSTEM_PROMPT } from "../memory/prompts/graph-extraction.js";
+import { L2_SCENE_SYSTEM_PROMPT } from "../memory/prompts/l2-scene.js";
+import { L3_PERSONA_SYSTEM_PROMPT, formatL3PersonaPrompt } from "../memory/prompts/l3-persona.js";
+import { deduplicateMemories } from "../memory/pipeline/l1-dedup.js";
+import { L2_MAX_SCENES } from "../memory/scheduler.js";
+// ============================
+// Schemas for MCP Tool Registration
+// ============================
+export const memoryGetExtractionWorkSchema = {
+    name: "memory_get_extraction_work",
+    description: "Get pending conversational L0 messages that need to be distilled into L1 memories.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string", description: "The ID of the user." },
+            sessionKey: { type: "string", description: "The session key." },
+            limit: { type: "number", description: "Maximum number of L0 messages to retrieve.", default: 10 },
+            activeSkill: { type: "string", description: "The currently active skill." }
+        },
+        required: ["userId", "sessionKey"]
+    }
+};
+export const memoryCommitExtractedL1Schema = {
+    name: "memory_commit_extracted_l1",
+    description: "Commit newly extracted L1 memories for a session, automatically generating vector embeddings and running deduplication.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            sessionKey: { type: "string" },
+            sessionId: { type: "string", default: "" },
+            sourceL0Ids: { type: "array", items: { type: "string" } },
+            scenes: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        sceneName: { type: "string" },
+                        memories: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    content: { type: "string" },
+                                    type: { type: "string", enum: ["persona", "episodic", "instruction", "skill_context"] },
+                                    priority: { type: "number", minimum: 0, maximum: 100, default: 50 },
+                                    skillTag: { type: "string", default: "" },
+                                    metadata: { type: "object", default: {} }
+                                },
+                                required: ["content", "type"]
+                            }
+                        }
+                    },
+                    required: ["sceneName", "memories"]
+                }
+            }
+        },
+        required: ["userId", "sessionKey", "scenes"]
+    }
+};
+export const memoryGetContradictionWorkSchema = {
+    name: "memory_get_contradiction_work",
+    description: "Get pending L1 memories that need to be evaluated for semantic contradictions or temporal updates against existing memories.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            limit: { type: "number", default: 20 }
+        },
+        required: ["userId"]
+    }
+};
+export const memoryCommitContradictionDecisionsSchema = {
+    name: "memory_commit_contradiction_decisions",
+    description: "Commit decisions on contradiction candidates, invalidating/superseding old records or logging genuine conflicts.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            decisions: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        newRecordId: { type: "string" },
+                        existingRecordId: { type: "string" },
+                        decision: { type: "string", enum: ["no_conflict", "temporal_update", "genuine_conflict"] },
+                        reason: { type: "string" },
+                        confidence: { type: "number", minimum: 0, maximum: 1, default: 1.0 }
+                    },
+                    required: ["newRecordId", "existingRecordId", "decision"]
+                }
+            }
+        },
+        required: ["userId", "decisions"]
+    }
+};
+export const memoryGetGraphWorkSchema = {
+    name: "memory_get_graph_work",
+    description: "Get pending L1 memories that have not yet had GraphRAG entities and relationships extracted from them.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            limit: { type: "number", default: 20 }
+        },
+        required: ["userId"]
+    }
+};
+export const memoryCommitGraphSchema = {
+    name: "memory_commit_graph",
+    description: "Commit entities and relations extracted from an L1 memory, updating the GraphRAG knowledge graph.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            sourceRecordId: { type: "string" },
+            entities: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        entity: { type: "string" },
+                        type: { type: "string", default: "concept" },
+                        confidence: { type: "number", minimum: 0, maximum: 1, default: 1.0 },
+                        skillTag: { type: "string", default: "" },
+                        sourceRecordId: { type: "string" }
+                    },
+                    required: ["entity"]
+                }
+            },
+            relations: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        from: { type: "string" },
+                        to: { type: "string" },
+                        relation: { type: "string", default: "relates_to" },
+                        confidence: { type: "number", minimum: 0, maximum: 1, default: 1.0 },
+                        skillTag: { type: "string", default: "" },
+                        sourceRecordId: { type: "string" }
+                    },
+                    required: ["from", "to"]
+                }
+            }
+        },
+        required: ["userId"]
+    }
+};
+export const memoryGetL2WorkSchema = {
+    name: "memory_get_l2_work",
+    description: "Get L1 memories grouped by scenes to perform scene narrative summary distillation or cold scene merges.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" }
+        },
+        required: ["userId"]
+    }
+};
+export const memoryCommitL2Schema = {
+    name: "memory_commit_l2",
+    description: "Commit scene summaries, scene name renames (clustering), or cold scene merge distillations.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            renames: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        oldName: { type: "string" },
+                        newName: { type: "string" }
+                    },
+                    required: ["oldName", "newName"]
+                }
+            },
+            scenes: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        sceneName: { type: "string" },
+                        summaryMd: { type: "string" },
+                        heatScore: { type: "number", minimum: 0, maximum: 100 }
+                    },
+                    required: ["sceneName", "summaryMd"]
+                }
+            },
+            merges: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        sceneIds: { type: "array", items: { type: "string" } },
+                        mergedSummaryMd: { type: "string" }
+                    },
+                    required: ["sceneIds", "mergedSummaryMd"]
+                }
+            }
+        },
+        required: ["userId"]
+    }
+};
+export const memoryGetL3WorkSchema = {
+    name: "memory_get_l3_work",
+    description: "Get L1 persona and instruction memories across all sessions to compile a synthesized L3 Narrative Profile.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" }
+        },
+        required: ["userId"]
+    }
+};
+export const memoryCommitL3Schema = {
+    name: "memory_commit_l3",
+    description: "Commit a synthesized L3 Narrative Profile summary, invalidating persona caches.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            userId: { type: "string" },
+            personaMd: { type: "string" }
+        },
+        required: ["userId", "personaMd"]
+    }
+};
+// ============================
+// Tool Dispatcher Handlers
+// ============================
+export async function handleMemoryGetExtractionWork(args) {
+    const params = z.object({
+        userId: z.string(),
+        sessionKey: z.string(),
+        limit: z.number().optional().default(10),
+        activeSkill: z.string().optional(),
+    }).parse(args);
+    const store = memoryEngine.store;
+    try {
+        const unextractedCount = store.getUnextractedL0Count(params.userId, params.sessionKey);
+        if (unextractedCount === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ status: "no_work", message: "No unextracted L0 messages in this session." }, null, 2)
+                    }]
+            };
+        }
+        const messages = store.getRecentL0Messages(params.userId, params.sessionKey, params.limit, "", true);
+        const existingSceneNames = store.getTopL2Scenes(params.userId, 20).map((s) => s.sceneName);
+        const skillHints = params.activeSkill ? (store.getSkillHints(params.activeSkill) ?? undefined) : undefined;
+        // Build the instruction templates
+        const qualifiedMessages = messages.filter((m) => {
+            const clean = m.messageText.trim();
+            return clean.length >= 3 && !/^[^a-zA-Z\u4e00-\u9fa5]+$/.test(clean);
+        });
+        const userPrompt = formatExtractionPrompt({
+            newMessages: qualifiedMessages,
+            backgroundMessages: [],
+            previousSceneName: "None",
+            existingSceneNames,
+            activeSkill: params.activeSkill,
+            skillHints
+        });
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "work_available",
+                        userId: params.userId,
+                        sessionKey: params.sessionKey,
+                        messages,
+                        unextractedCount,
+                        remainingUnextractedCount: Math.max(0, unextractedCount - messages.length),
+                        existingSceneNames,
+                        skillHints,
+                        prompts: {
+                            systemPrompt: EXTRACT_MEMORIES_SYSTEM_PROMPT,
+                            userPrompt
+                        }
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to retrieve extraction work: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryCommitExtractedL1(args) {
+    const payload = L1CommitPayloadSchema.parse(args);
+    const store = memoryEngine.store;
+    const embeddingService = memoryEngine.capturePipeline.embeddingService;
+    try {
+        if (payload.sourceL0Ids.length > 0) {
+            validateL0RecordOwnership(store, payload.userId, payload.sourceL0Ids);
+        }
+        const records = [];
+        const now = new Date().toISOString();
+        for (const group of payload.scenes) {
+            const sceneName = normalizeSceneName(group.sceneName);
+            for (const mem of group.memories) {
+                records.push({
+                    id: `l1_${payload.sessionKey}_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`,
+                    userId: payload.userId,
+                    sessionKey: payload.sessionKey,
+                    sessionId: payload.sessionId,
+                    content: normalizeMemoryContent(mem.content),
+                    type: mem.type,
+                    priority: mem.priority,
+                    sceneName,
+                    skillTag: normalizeSkillTag(mem.skillTag),
+                    halfLifeDays: mem.type === "instruction" ? null : (mem.type === "persona" ? 180 : (mem.type === "skill_context" ? 7 : 30)),
+                    supersededBy: null,
+                    timestampStr: "",
+                    timestampStart: "",
+                    timestampEnd: "",
+                    createdTime: now,
+                    updatedTime: now,
+                    metadata: mem.metadata,
+                    citationCount: 0,
+                    lastCitedAt: null,
+                    neverCitedCount: 0,
+                    archived: false,
+                });
+            }
+        }
+        // Deduplication check
+        const { uniqueRecords, droppedCount } = await deduplicateMemories({
+            records,
+            store,
+            userId: payload.userId
+        });
+        const entries = [];
+        for (const record of uniqueRecords) {
+            let embedding;
+            if (embeddingService.isReady()) {
+                try {
+                    embedding = await embeddingService.embed(record.content);
+                }
+                catch (err) {
+                    console.error(`[BrainRouter] Embedding failed during commit for ${record.id}:`, err.message);
+                }
+            }
+            entries.push({ record, embedding });
+        }
+        if (entries.length > 0) {
+            store.upsertL1Batch(entries);
+            store.incrementSchedulerL1Count(payload.userId, entries.length);
+        }
+        if (payload.sourceL0Ids.length > 0) {
+            store.markL0ExtractedByIds(payload.userId, payload.sourceL0Ids);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        committedCount: entries.length,
+                        committedIds: uniqueRecords.map(r => r.id),
+                        droppedDuplicateCount: droppedCount,
+                        validationErrors: []
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to commit L1 memories: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryGetContradictionWork(args) {
+    const params = z.object({
+        userId: z.string(),
+        limit: z.number().optional().default(20),
+    }).parse(args);
+    const store = memoryEngine.store;
+    try {
+        const pendingL1s = store.getPendingContradictionL1s(params.userId, params.limit);
+        if (pendingL1s.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ status: "no_work", message: "No pending contradiction checks." }, null, 2)
+                    }]
+            };
+        }
+        const pairs = [];
+        for (const newRecord of pendingL1s) {
+            const candidates = store.searchL1Fts(params.userId, newRecord.content, 5);
+            for (const cand of candidates) {
+                if (cand.record_id === newRecord.id)
+                    continue;
+                pairs.push({
+                    newRecord: {
+                        id: newRecord.id,
+                        content: newRecord.content,
+                        type: newRecord.type
+                    },
+                    existingRecord: {
+                        id: cand.record_id,
+                        content: cand.content,
+                        type: cand.type
+                    }
+                });
+            }
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: pairs.length > 0 ? "work_available" : "no_work",
+                        userId: params.userId,
+                        pairs,
+                        prompts: {
+                            systemPrompt: L1_CONTRADICTION_PROMPT
+                        }
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to retrieve contradiction work: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryCommitContradictionDecisions(args) {
+    const payload = ContradictionDecisionCommitSchema.parse(args);
+    const store = memoryEngine.store;
+    try {
+        const allIds = payload.decisions.flatMap(d => [d.newRecordId, d.existingRecordId]);
+        validateL1RecordOwnership(store, payload.userId, [...new Set(allIds)]);
+        let processedCount = 0;
+        const processedIds = [];
+        for (const decision of payload.decisions) {
+            const newRec = store.getL1Record(payload.userId, decision.newRecordId);
+            if (!newRec)
+                continue;
+            if (decision.decision === "temporal_update") {
+                store.invalidateL1Record(payload.userId, decision.existingRecordId, decision.newRecordId, newRec.createdTime);
+                processedCount++;
+                processedIds.push(decision.newRecordId);
+            }
+            else if (decision.decision === "genuine_conflict") {
+                store.upsertContradiction({
+                    id: `conflict_${crypto.randomBytes(4).toString("hex")}`,
+                    userId: payload.userId,
+                    recordIdA: decision.existingRecordId,
+                    recordIdB: decision.newRecordId,
+                    reason: decision.reason || "Genuine contradiction",
+                    confidence: decision.confidence
+                });
+                processedCount++;
+                processedIds.push(decision.newRecordId);
+            }
+            else {
+                // no_conflict
+                processedCount++;
+                processedIds.push(decision.newRecordId);
+            }
+        }
+        const uniqueNewIds = [...new Set(payload.decisions.map(d => d.newRecordId))];
+        store.markL1ContradictionChecked(payload.userId, uniqueNewIds);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        committedCount: processedCount,
+                        committedIds: processedIds,
+                        droppedDuplicateCount: 0,
+                        validationErrors: []
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to commit contradiction decisions: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryGetGraphWork(args) {
+    const params = z.object({
+        userId: z.string(),
+        limit: z.number().optional().default(20),
+    }).parse(args);
+    const store = memoryEngine.store;
+    try {
+        const pendingL1s = store.getPendingGraphL1s(params.userId, params.limit);
+        if (pendingL1s.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ status: "no_work", message: "No pending graph extractions." }, null, 2)
+                    }]
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "work_available",
+                        userId: params.userId,
+                        records: pendingL1s.map((r) => ({
+                            id: r.id,
+                            content: r.content,
+                            skillTag: r.skillTag
+                        })),
+                        prompts: {
+                            systemPrompt: GRAPH_EXTRACTION_SYSTEM_PROMPT
+                        }
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to retrieve graph work: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryCommitGraph(args) {
+    const payload = GraphCommitSchema.parse(args);
+    const store = memoryEngine.store;
+    try {
+        if (payload.sourceRecordId) {
+            validateL1RecordOwnership(store, payload.userId, [payload.sourceRecordId]);
+        }
+        const entityMap = new Map();
+        const committedIds = [];
+        // 1. Upsert Nodes
+        for (const ent of payload.entities) {
+            const entityName = normalizeEntityName(ent.entity);
+            const existing = store.getGraphNodeByEntity(payload.userId, entityName);
+            const nodeId = existing?.id ?? `gn_${crypto.randomBytes(6).toString("hex")}`;
+            entityMap.set(entityName.toLowerCase(), nodeId);
+            const node = {
+                id: nodeId,
+                userId: payload.userId,
+                entity: ent.entity,
+                entityType: ent.type || "concept",
+                skillTag: ent.skillTag || "",
+                confidence: ent.confidence || 1.0,
+                sourceRecordId: ent.sourceRecordId || payload.sourceRecordId || "",
+                createdTime: new Date().toISOString()
+            };
+            store.upsertGraphNode(node);
+            committedIds.push(nodeId);
+        }
+        // 2. Upsert Edges
+        for (const rel of payload.relations) {
+            const fromName = normalizeEntityName(rel.from);
+            const toName = normalizeEntityName(rel.to);
+            let fromNodeId = entityMap.get(fromName.toLowerCase());
+            if (!fromNodeId) {
+                fromNodeId = store.getGraphNodeByEntity(payload.userId, fromName)?.id;
+            }
+            let toNodeId = entityMap.get(toName.toLowerCase());
+            if (!toNodeId) {
+                toNodeId = store.getGraphNodeByEntity(payload.userId, toName)?.id;
+            }
+            if (!fromNodeId || !toNodeId)
+                continue;
+            const edgeId = `ge_${crypto.randomBytes(6).toString("hex")}`;
+            const edge = {
+                id: edgeId,
+                userId: payload.userId,
+                fromNodeId,
+                toNodeId,
+                relation: rel.relation || "relates_to",
+                skillTag: rel.skillTag || "",
+                confidence: rel.confidence || 1.0,
+                sourceRecordId: rel.sourceRecordId || payload.sourceRecordId || "",
+                createdTime: new Date().toISOString()
+            };
+            store.upsertGraphEdge(edge);
+            committedIds.push(edgeId);
+        }
+        if (payload.sourceRecordId) {
+            store.markL1GraphExtracted(payload.userId, [payload.sourceRecordId]);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        committedCount: committedIds.length,
+                        committedIds,
+                        droppedDuplicateCount: 0,
+                        validationErrors: []
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to commit graph elements: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryGetL2Work(args) {
+    const params = z.object({
+        userId: z.string(),
+    }).parse(args);
+    const store = memoryEngine.store;
+    try {
+        const countState = store.getSchedulerState(params.userId);
+        const sceneNames = store.getDistinctSceneNames(params.userId);
+        const topL2Scenes = store.getTopL2Scenes(params.userId, 50);
+        const scenes = [];
+        for (const name of sceneNames) {
+            const l1s = store.getL1sByScene(params.userId, name, 30);
+            if (l1s.length > 0) {
+                scenes.push({ sceneName: name, memories: l1s });
+            }
+        }
+        const sceneCount = store.getL2SceneCount(params.userId);
+        const overflow = sceneCount - L2_MAX_SCENES + 1;
+        const coldScenes = overflow > 0 ? store.getColdL2Scenes(params.userId, overflow + 3) : [];
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: scenes.length > 0 ? "work_available" : "no_work",
+                        userId: params.userId,
+                        schedulerState: countState,
+                        scenes,
+                        existingL2Scenes: topL2Scenes,
+                        coldScenesToMerge: coldScenes,
+                        prompts: {
+                            systemPrompt: L2_SCENE_SYSTEM_PROMPT
+                        }
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to retrieve L2 work: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryCommitL2(args) {
+    const payload = L2CommitSchema.parse(args);
+    const store = memoryEngine.store;
+    try {
+        const committedIds = [];
+        const now = new Date().toISOString();
+        // 1. Renames (clustering canonicalization)
+        for (const r of payload.renames) {
+            store.renameSceneInL1Records(payload.userId, r.oldName, r.newName);
+        }
+        // 2. Main distilled scenes
+        for (const scene of payload.scenes) {
+            const existing = store.getL2SceneByName(payload.userId, scene.sceneName);
+            const record = {
+                id: existing?.id ?? `l2_${crypto.randomBytes(6).toString("hex")}`,
+                userId: payload.userId,
+                sceneName: scene.sceneName,
+                summaryMd: scene.summaryMd,
+                heatScore: scene.heatScore !== undefined ? scene.heatScore : (existing ? Math.min(100, existing.heatScore + 30) : 100),
+                lastActiveTime: now,
+                createdTime: existing?.createdTime ?? now,
+                updatedTime: now
+            };
+            store.upsertL2Scene(record);
+            committedIds.push(record.id);
+        }
+        // 3. Merges into [Archived]
+        for (const merge of payload.merges) {
+            const existingArchive = store.getL2SceneByName(payload.userId, "[Archived]");
+            const record = {
+                id: existingArchive?.id ?? `l2_${crypto.randomBytes(6).toString("hex")}`,
+                userId: payload.userId,
+                sceneName: "[Archived]",
+                summaryMd: merge.mergedSummaryMd,
+                heatScore: 10,
+                lastActiveTime: now,
+                createdTime: existingArchive?.createdTime ?? now,
+                updatedTime: now
+            };
+            store.upsertL2Scene(record);
+            store.deleteL2Scenes(payload.userId, merge.sceneIds);
+            committedIds.push(record.id);
+        }
+        store.resetSchedulerL2Count(payload.userId);
+        store.decayL2HeatScores(payload.userId);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        committedCount: committedIds.length,
+                        committedIds,
+                        droppedDuplicateCount: 0,
+                        validationErrors: []
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to commit L2 scenes: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryGetL3Work(args) {
+    const params = z.object({
+        userId: z.string(),
+    }).parse(args);
+    const store = memoryEngine.store;
+    try {
+        const memories = store.getPersonaAndInstructionL1s(params.userId, 100);
+        const existing = store.getL3Persona(params.userId);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        status: memories.length > 0 ? "work_available" : "no_work",
+                        userId: params.userId,
+                        memories,
+                        existingPersona: existing,
+                        prompts: {
+                            systemPrompt: L3_PERSONA_SYSTEM_PROMPT,
+                            userPrompt: formatL3PersonaPrompt(memories)
+                        }
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to retrieve L3 work: ${err.message}` }]
+        };
+    }
+}
+export async function handleMemoryCommitL3(args) {
+    const payload = L3CommitSchema.parse(args);
+    const store = memoryEngine.store;
+    try {
+        const memories = store.getPersonaAndInstructionL1s(payload.userId, 100);
+        const existing = store.getL3Persona(payload.userId);
+        const now = new Date().toISOString();
+        const record = {
+            userId: payload.userId,
+            personaMd: payload.personaMd,
+            l1CountAtGeneration: memories.length,
+            createdTime: existing?.createdTime ?? now,
+            updatedTime: now
+        };
+        store.upsertL3Persona(record);
+        // Invalidate local in-memory cache
+        const cache = memoryEngine.personaCache;
+        if (cache) {
+            cache.set(payload.userId, { personaMd: payload.personaMd, cachedAt: Date.now() });
+        }
+        store.resetSchedulerL3Count(payload.userId);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        committedCount: 1,
+                        committedIds: [payload.userId],
+                        droppedDuplicateCount: 0,
+                        validationErrors: []
+                    }, null, 2)
+                }]
+        };
+    }
+    catch (err) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to commit L3 persona: ${err.message}` }]
+        };
+    }
+}