@kinqs/brainrouter-mcp-server 0.3.4 → 0.3.6

package/dist/tools/agent_memory_tools.js

@@ -1,793 +0,0 @@
-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}` }]
-        };
-    }
-}