sensorium-mcp 2.11.1 → 2.13.0

package/dist/index.js

@@ -39,7 +39,7 @@ import { peekThreadMessages, readThreadMessages, startDispatcher } from "./dispa
 import { formatDrivePrompt } from "./drive.js";
 import { convertMarkdown, splitMessage } from "./markdown.js";
 import { assembleBootstrap, assembleCompactRefresh, forgetMemory, getMemoryStatus, getNotesWithoutEmbeddings, getRecentEpisodes, getTopicIndex, initMemoryDb, runIntelligentConsolidation, saveEpisode, saveNoteEmbedding, saveProcedure, saveSemanticNote, saveVoiceSignature, searchByEmbedding, searchProcedures, searchSemanticNotes, searchSemanticNotesRanked, supersedeNote, updateProcedure, updateSemanticNote, } from "./memory.js";
-import { analyzeVideoFrames, analyzeVoiceEmotion, extractVideoFrames, generateEmbedding, textToSpeech, transcribeAudio, TTS_VOICES } from "./openai.js";
+import { analyzeVideoFrames, analyzeVoiceEmotion, chatCompletion, extractVideoFrames, generateEmbedding, textToSpeech, transcribeAudio, TTS_VOICES } from "./openai.js";
 import { addSchedule, checkDueTasks, generateTaskId, listSchedules, purgeSchedules, removeSchedule } from "./scheduler.js";
 import { DEAD_SESSION_TIMEOUT_MS, lookupSession, persistSession, purgeOtherSessions, registerMcpSession, removeSession, threadSessionRegistry, } from "./sessions.js";
 import { TelegramClient } from "./telegram.js";
@@ -151,6 +151,25 @@ function createMcpServer(getMcpSessionId, closeTransport) {
         }
         previewedUpdateIds.add(id);
     }
+    /**
+     * Generate a first-person DMN (Default Mode Network) reflection prompt.
+     * Called when the __DMN__ sentinel fires as a scheduled task.
+     */
+    function generateDmnReflection(threadId) {
+        try {
+            const db = getMemoryDb();
+            const idleMs = Date.now() - lastOperatorMessageAt;
+            const driveContent = formatDrivePrompt(idleMs, db, threadId);
+            // Reframe in first person
+            return (`I've been thinking while the operator is away.\n\n` +
+                `${driveContent}\n\n` +
+                `If something here resonates, I should explore it — use subagents, search the codebase, review memory. ` +
+                `Report what I find, then go back to sleep or continue waiting.`);
+        }
+        catch {
+            return "I should review memory and the codebase for anything interesting while the operator is away.";
+        }
+    }
     function resolveThreadId(args) {
         const raw = args?.threadId;
         const explicit = typeof raw === "number" ? raw
@@ -400,6 +419,25 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     registerMcpSession(currentThreadId, sid, closeTransport);
                 }
             }
+            // Auto-schedule DMN reflection task if not already present.
+            // This fires after 4 hours of operator silence, delivering a
+            // first-person introspection prompt sourced from memory.
+            if (currentThreadId !== undefined) {
+                const existingTasks = listSchedules(currentThreadId);
+                const hasDmn = existingTasks.some(t => t.label === "dmn-reflection");
+                if (!hasDmn) {
+                    addSchedule({
+                        id: generateTaskId(),
+                        threadId: currentThreadId,
+                        prompt: "__DMN__", // Sentinel — handler generates dynamic content
+                        label: "dmn-reflection",
+                        afterIdleMinutes: 240, // 4 hours
+                        oneShot: false,
+                        createdAt: new Date().toISOString(),
+                    });
+                    process.stderr.write(`[start_session] Auto-scheduled DMN reflection task for thread ${currentThreadId}.\n`);
+                }
+            }
             return {
                 content: [
                     {
@@ -744,81 +782,89 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                             contentBlocks.push({ type: "text", text: subagentInstruction });
                         }
                     }
-                    // ── Auto-inject relevant memory context ───────────────────────────
-                    // Architecture-enforced: the agent should NOT need to manually call
-                    // memory_search. The server automatically searches memory for notes
-                    // relevant to the operator's message and injects them.
+                    // ── Smart context injection (GPT-4o-mini preprocessor) ──────────
+                    // Retrieves candidate notes via embedding search, then uses GPT-4o-mini
+                    // to select ONLY the notes truly relevant to the operator's message.
+                    // This prevents context contamination from near-miss semantic matches.
                     let autoMemoryContext = "";
                     try {
                         const db = getMemoryDb();
                         const apiKey = process.env.OPENAI_API_KEY;
-                        // Extract the operator's text to use as a memory search query
                         const operatorText = stored
                             .map(m => m.message.text ?? m.message.caption ?? "")
                             .filter(Boolean)
                             .join(" ")
                             .slice(0, 500);
                         if (operatorText.length > 10 && apiKey) {
-                            // Try embedding-based search first, fall back to keyword search
+                            // Phase 1: Broad retrieval — get 10 candidates via embedding search
+                            let candidates = [];
                             try {
                                 const queryEmb = await generateEmbedding(operatorText, apiKey);
-                                const relevant = searchByEmbedding(db, queryEmb, { maxResults: 5, minSimilarity: 0.3, skipAccessTracking: true });
-                                if (relevant.length > 0) {
-                                    let budget = 800;
-                                    const lines = [];
-                                    for (const n of relevant) {
-                                        const line = `- **[${n.type}]** ${n.content.slice(0, 200)} _(conf: ${n.confidence}, sim: ${n.similarity.toFixed(2)})_`;
-                                        if (budget - line.length < 0)
-                                            break;
-                                        budget -= line.length;
-                                        lines.push(line);
-                                    }
-                                    if (lines.length > 0) {
-                                        autoMemoryContext = `\n\n## Relevant Memory (auto-injected)\n${lines.join("\n")}`;
-                                    }
-                                }
+                                const embResults = searchByEmbedding(db, queryEmb, { maxResults: 10, minSimilarity: 0.25, skipAccessTracking: true, threadId: effectiveThreadId });
+                                candidates = embResults.map(n => ({ type: n.type, content: n.content.slice(0, 200), confidence: n.confidence, similarity: n.similarity }));
                             }
-                            catch (embErr) {
-                                // Fallback to keyword search if embedding fails
-                                process.stderr.write(`[memory] Embedding search failed, falling back to keyword: ${embErr instanceof Error ? embErr.message : String(embErr)}\n`);
+                            catch {
+                                // Fallback to keyword search
                                 const searchQuery = extractSearchKeywords(operatorText);
                                 if (searchQuery.trim().length > 0) {
-                                    const relevant = searchSemanticNotesRanked(db, searchQuery, { maxResults: 5, skipAccessTracking: true });
-                                    if (relevant.length > 0) {
-                                        let budget = 800;
-                                        const lines = [];
-                                        for (const n of relevant) {
-                                            const line = `- **[${n.type}]** ${n.content.slice(0, 200)} _(conf: ${n.confidence})_`;
-                                            if (budget - line.length < 0)
-                                                break;
-                                            budget -= line.length;
-                                            lines.push(line);
-                                        }
-                                        if (lines.length > 0) {
-                                            autoMemoryContext = `\n\n## Relevant Memory (auto-injected)\n${lines.join("\n")}`;
+                                    const kwResults = searchSemanticNotesRanked(db, searchQuery, { maxResults: 10, skipAccessTracking: true, threadId: effectiveThreadId });
+                                    candidates = kwResults.map(n => ({ type: n.type, content: n.content.slice(0, 200), confidence: n.confidence }));
+                                }
+                            }
+                            if (candidates.length > 0) {
+                                // Phase 2: GPT-4o-mini filters and compresses
+                                try {
+                                    const noteList = candidates.map((c, i) => `[${i}] [${c.type}] ${c.content}`).join("\n");
+                                    const filterResponse = await chatCompletion([
+                                        {
+                                            role: "system",
+                                            content: "You are a context filter for an AI assistant. Given an operator's message and candidate memory notes, " +
+                                                "select ONLY the notes that are directly relevant to the operator's current instruction or question. " +
+                                                "Discard notes that are tangentially related, duplicates, or noise. " +
+                                                "Return a JSON array of objects: [{\"i\": <index>, \"s\": \"<compressed one-liner>\"}] " +
+                                                "where 'i' is the note index and 's' is a compressed summary (max 80 chars). " +
+                                                "Return [] if no notes are relevant. Return at most 3 notes. Be aggressive about filtering.",
+                                        },
+                                        {
+                                            role: "user",
+                                            content: `Operator message: "${operatorText.slice(0, 300)}"\n\nCandidate notes:\n${noteList}`,
+                                        },
+                                    ], apiKey, { maxTokens: 200, temperature: 0 });
+                                    // Parse the response — expect JSON array
+                                    const jsonMatch = filterResponse.match(/\[.*\]/s);
+                                    if (jsonMatch) {
+                                        const filtered = JSON.parse(jsonMatch[0]);
+                                        if (filtered.length > 0) {
+                                            const lines = filtered
+                                                .filter(f => f.i >= 0 && f.i < candidates.length)
+                                                .slice(0, 3)
+                                                .map(f => {
+                                                const c = candidates[f.i];
+                                                return `- **[${c.type}]** ${f.s} _(conf: ${c.confidence})_`;
+                                            });
+                                            if (lines.length > 0) {
+                                                autoMemoryContext = `\n\n## Relevant Memory (auto-injected)\n${lines.join("\n")}`;
+                                            }
                                         }
                                     }
+                                    process.stderr.write(`[memory] Smart filter: ${candidates.length} candidates → ${(jsonMatch ? JSON.parse(jsonMatch[0]) : []).length} selected\n`);
+                                }
+                                catch (filterErr) {
+                                    // GPT-4o-mini filter failed — fall back to top-3 raw notes
+                                    process.stderr.write(`[memory] Smart filter failed, using raw top-3: ${filterErr instanceof Error ? filterErr.message : String(filterErr)}\n`);
+                                    const lines = candidates.slice(0, 3).map(c => `- **[${c.type}]** ${c.content} _(conf: ${c.confidence})_`);
+                                    autoMemoryContext = `\n\n## Relevant Memory (auto-injected)\n${lines.join("\n")}`;
                                 }
                             }
                         }
-                        else {
-                            // No API key or text too short — use keyword search
+                        else if (operatorText.length > 10) {
+                            // No API key — keyword search, raw top-3
                             const searchQuery = extractSearchKeywords(operatorText);
                             if (searchQuery.trim().length > 0) {
-                                const relevant = searchSemanticNotesRanked(db, searchQuery, { maxResults: 5, skipAccessTracking: true });
-                                if (relevant.length > 0) {
-                                    let budget = 800;
-                                    const lines = [];
-                                    for (const n of relevant) {
-                                        const line = `- **[${n.type}]** ${n.content.slice(0, 200)} _(conf: ${n.confidence})_`;
-                                        if (budget - line.length < 0)
-                                            break;
-                                        budget -= line.length;
-                                        lines.push(line);
-                                    }
-                                    if (lines.length > 0) {
-                                        autoMemoryContext = `\n\n## Relevant Memory (auto-injected)\n${lines.join("\n")}`;
-                                    }
+                                const kwResults = searchSemanticNotesRanked(db, searchQuery, { maxResults: 3, skipAccessTracking: true, threadId: effectiveThreadId });
+                                if (kwResults.length > 0) {
+                                    const lines = kwResults.map(n => `- **[${n.type}]** ${n.content.slice(0, 200)} _(conf: ${n.confidence})_`);
+                                    autoMemoryContext = `\n\n## Relevant Memory (auto-injected)\n${lines.join("\n")}`;
                                 }
                             }
                         }
@@ -850,14 +896,17 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     lastScheduleCheck = Date.now();
                     const dueTask = checkDueTasks(effectiveThreadId, lastOperatorMessageAt, false);
                     if (dueTask) {
+                        // DMN sentinel: generate dynamic first-person reflection
+                        const taskPrompt = dueTask.prompt === "__DMN__"
+                            ? generateDmnReflection(effectiveThreadId)
+                            : `⏰ **Scheduled task fired: "${dueTask.task.label}"**\n\n` +
+                                `This task was scheduled by you. Execute it now using subagents, then report progress and continue waiting.\n\n` +
+                                `Task prompt: ${dueTask.prompt}`;
                         return {
                             content: [
                                 {
                                     type: "text",
-                                    text: `⏰ **Scheduled task fired: "${dueTask.task.label}"**\n\n` +
-                                        `This task was scheduled by you. Execute it now using subagents, then report progress and continue waiting.\n\n` +
-                                        `Task prompt: ${dueTask.prompt}` +
-                                        getReminders(effectiveThreadId),
+                                    text: taskPrompt + getReminders(effectiveThreadId),
                                 },
                             ],
                         };
@@ -899,14 +948,17 @@ function createMcpServer(getMcpSessionId, closeTransport) {
             if (effectiveThreadId !== undefined) {
                 const dueTask = checkDueTasks(effectiveThreadId, lastOperatorMessageAt, false);
                 if (dueTask) {
+                    // DMN sentinel: generate dynamic first-person reflection
+                    const taskPrompt = dueTask.prompt === "__DMN__"
+                        ? generateDmnReflection(effectiveThreadId)
+                        : `⏰ **Scheduled task fired: "${dueTask.task.label}"**\n\n` +
+                            `This task was scheduled by you. Execute it now using subagents, then report progress and continue waiting.\n\n` +
+                            `Task prompt: ${dueTask.prompt}`;
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: `⏰ **Scheduled task fired: "${dueTask.task.label}"**\n\n` +
-                                    `This task was scheduled by you. Execute it now using subagents, then report progress and continue waiting.\n\n` +
-                                    `Task prompt: ${dueTask.prompt}` +
-                                    getReminders(effectiveThreadId),
+                                text: taskPrompt + getReminders(effectiveThreadId),
                             },
                         ],
                     };
@@ -1357,6 +1409,108 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     }],
             };
         }
+        // ── sleep ────────────────────────────────────────────────────────────────
+        if (name === "sleep") {
+            const typedArgs = (args ?? {});
+            const effectiveThreadId = resolveThreadId(typedArgs);
+            if (effectiveThreadId === undefined) {
+                return errorResult("Error: No active session. Call start_session first.");
+            }
+            const wakeAt = typeof typedArgs.wakeAt === "string" ? new Date(typedArgs.wakeAt).getTime() : undefined;
+            if (wakeAt !== undefined && isNaN(wakeAt)) {
+                return errorResult("Error: Invalid wakeAt timestamp. Use ISO 8601 format.");
+            }
+            // Max sleep: 8 hours
+            const MAX_SLEEP_MS = 8 * 60 * 60 * 1000;
+            const SLEEP_POLL_INTERVAL_MS = 30_000; // 30s
+            const SSE_KEEPALIVE_INTERVAL_MS = 30_000;
+            const deadline = Date.now() + MAX_SLEEP_MS;
+            let lastKeepalive = Date.now();
+            process.stderr.write(`[sleep] Entering sleep mode. threadId=${effectiveThreadId}, wakeAt=${wakeAt ? new Date(wakeAt).toISOString() : "indefinite"}\n`);
+            while (Date.now() < deadline) {
+                // Check for operator messages (non-destructive peek)
+                const peeked = peekThreadMessages(effectiveThreadId);
+                if (peeked.length > 0) {
+                    process.stderr.write(`[sleep] Waking up — ${peeked.length} operator message(s) received.\n`);
+                    // Don't consume messages — let the next wait_for_instructions call handle them
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Woke up: operator sent a message. Call wait_for_instructions now to read it.` +
+                                    getShortReminder(effectiveThreadId),
+                            }],
+                    };
+                }
+                // Check for scheduled tasks
+                const dueTask = checkDueTasks(effectiveThreadId, lastOperatorMessageAt, false);
+                if (dueTask) {
+                    process.stderr.write(`[sleep] Waking up — scheduled task fired: ${dueTask.task.label}\n`);
+                    // DMN sentinel: generate dynamic first-person reflection
+                    const taskPrompt = dueTask.prompt === "__DMN__"
+                        ? generateDmnReflection(effectiveThreadId)
+                        : `⏰ Woke up: scheduled task **"${dueTask.task.label}"**\n\n${dueTask.prompt}`;
+                    return {
+                        content: [{
+                                type: "text",
+                                text: taskPrompt + getShortReminder(effectiveThreadId),
+                            }],
+                    };
+                }
+                // Check alarm
+                if (wakeAt && Date.now() >= wakeAt) {
+                    process.stderr.write(`[sleep] Waking up — alarm reached.\n`);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Woke up: alarm time reached (${new Date(wakeAt).toISOString()}).` +
+                                    getShortReminder(effectiveThreadId),
+                            }],
+                    };
+                }
+                // SSE keepalive
+                const sinceKeepalive = Date.now() - lastKeepalive;
+                if (sinceKeepalive >= SSE_KEEPALIVE_INTERVAL_MS && extra?.sendNotification) {
+                    try {
+                        await extra.sendNotification({
+                            method: "notifications/message",
+                            params: { level: "debug", data: "sleeping", logger: "sensorium" },
+                        });
+                        lastKeepalive = Date.now();
+                    }
+                    catch {
+                        process.stderr.write(`[sleep] SSE keepalive failed — connection lost.\n`);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: "Sleep interrupted: connection lost. Call sleep again to resume." +
+                                        getShortReminder(effectiveThreadId),
+                                }],
+                        };
+                    }
+                }
+                // Check abort signal
+                if (extra.signal.aborted) {
+                    process.stderr.write(`[sleep] SSE connection aborted during sleep.\n`);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "Sleep interrupted: connection closed." +
+                                    getShortReminder(effectiveThreadId),
+                            }],
+                    };
+                }
+                await new Promise((resolve) => setTimeout(resolve, SLEEP_POLL_INTERVAL_MS));
+            }
+            // Max sleep duration reached
+            process.stderr.write(`[sleep] Max sleep duration reached (8h).\n`);
+            return {
+                content: [{
+                        type: "text",
+                        text: "Woke up: maximum sleep duration reached (8 hours)." +
+                            getShortReminder(effectiveThreadId),
+                    }],
+            };
+        }
         // ── memory_bootstrap ────────────────────────────────────────────────────
         if (name === "memory_bootstrap") {
             const threadId = resolveThreadId(args);
@@ -1472,6 +1626,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     keywords: Array.isArray(typedArgs.keywords) ? typedArgs.keywords.map(String) : typeof typedArgs.keywords === 'string' ? [typedArgs.keywords] : [],
                     confidence: typeof typedArgs.confidence === "number" ? typedArgs.confidence : 0.8,
                     priority: typeof typedArgs.priority === "number" ? typedArgs.priority : 0,
+                    threadId: threadId ?? null,
                 });
                 // Fire-and-forget embedding generation
                 const apiKey = process.env.OPENAI_API_KEY;