sensorium-mcp 2.9.7 → 2.11.1

package/dist/index.js

@@ -29,19 +29,22 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CallToolRequestSchema, isInitializeRequest, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { readFile } from "fs/promises";
-import { createRequire } from "module";
 import { randomUUID, timingSafeEqual } from "node:crypto";
 import { createServer } from "node:http";
-import { homedir } from "os";
-import { basename, join } from "path";
+import { basename } from "node:path";
+import { config, saveFileToDisk } from "./config.js";
 import { handleDashboardRequest } from "./dashboard.js";
 import { peekThreadMessages, readThreadMessages, startDispatcher } from "./dispatcher.js";
-import { assembleBootstrap, assembleCompactRefresh, forgetMemory, getMemoryStatus, getNotesWithoutEmbeddings, getRecentEpisodes, getTopicIndex, getTopSemanticNotes, initMemoryDb, runIntelligentConsolidation, saveEpisode, saveNoteEmbedding, saveProcedure, saveSemanticNote, saveVoiceSignature, searchByEmbedding, searchProcedures, searchSemanticNotes, searchSemanticNotesRanked, supersedeNote, updateProcedure, updateSemanticNote, } from "./memory.js";
+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 { 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";
+import { getToolDefinitions } from "./tool-definitions.js";
+import { rateLimiter } from "./rate-limiter.js";
 import { describeADV, errorMessage, errorResult, IMAGE_EXTENSIONS, OPENAI_TTS_MAX_CHARS } from "./utils.js";
 // ── Stop-word list for auto-memory keyword extraction ─────────────────
 const STOP_WORDS = new Set([
@@ -101,186 +104,15 @@ function buildAnalysisTags(analysis) {
     }
     return tags;
 }
-const esmRequire = createRequire(import.meta.url);
-const { version: PKG_VERSION } = esmRequire("../package.json");
-const telegramifyMarkdown = esmRequire("telegramify-markdown");
-/**
- * Convert standard Markdown to Telegram MarkdownV2.
- *
- * Works around several telegramify-markdown limitations:
- *   1. Fenced code blocks are emitted as single-backtick inline code instead
- *      of triple-backtick blocks → pre-extract, re-insert after conversion.
- *   2. Markdown tables contain `|` which is a MarkdownV2 reserved character;
- *      telegramify-markdown does not handle tables → pre-extract and wrap in
- *      a plain code block so the table layout is preserved.
- *   3. Blockquotes with 'escape' strategy produce double-escaped characters
- *      (e.g. `\\.` instead of `\.`) → pre-convert `> text` to `▎ text`
- *      (a common Telegram convention) so the library never sees blockquotes.
- */
-function convertMarkdown(markdown) {
-    const blocks = [];
-    const placeholder = (i) => `CODEBLOCKPLACEHOLDER${i}END`;
-    // 1. Extract fenced code blocks (``` ... ```).
-    let preprocessed = markdown.replace(/^```(\w*)\n([\s\S]*?)\n?```\s*$/gm, (_match, lang, code) => {
-        blocks.push({ lang, code });
-        return placeholder(blocks.length - 1);
-    });
-    // 2. Extract Markdown tables (consecutive lines starting with `|`) and
-    //    convert them to list format for better Telegram readability.
-    //    Tables render poorly on mobile — lists with labeled items are clearer.
-    const tableLists = [];
-    const tablePlaceholder = (i) => `TABLEPLACEHOLDER${i}END`;
-    preprocessed = preprocessed.replace(/^(\|.+\|)\n(\|[-| :]+\|\n)((?:\|.*\n?)*)/gm, (_match, firstRow, _sepRow, rest) => {
-        // Parse header columns
-        const headers = firstRow.split("|").map((s) => s.trim()).filter(Boolean);
-        // Parse data rows
-        const dataRows = rest.trimEnd().split("\n").filter((line) => line.trim().length > 0);
-        const listLines = [];
-        for (const row of dataRows) {
-            const cells = row.split("|").map((s) => s.trim()).filter(Boolean);
-            // Format as: "• Cell1 — Header2: Cell2, Header3: Cell3, ..."
-            if (cells.length > 0) {
-                const parts = [];
-                for (let j = 0; j < cells.length; j++) {
-                    if (j === 0) {
-                        parts.push(cells[j]);
-                    }
-                    else if (j < headers.length) {
-                        parts.push(`${headers[j]}: ${cells[j]}`);
-                    }
-                    else {
-                        parts.push(cells[j]);
-                    }
-                }
-                listLines.push(`• ${parts.join(" — ")}`);
-            }
-        }
-        tableLists.push(listLines.join("\n"));
-        return tablePlaceholder(tableLists.length - 1) + "\n";
-    });
-    // 3. Convert Markdown blockquotes (> text) to ▎ prefix lines so
-    //    telegramify-markdown never attempts to escape them.
-    preprocessed = preprocessed.replace(/^>\s?(.*)$/gm, "▎ $1");
-    // 4. Convert the rest with telegramify-markdown.
-    let converted = telegramifyMarkdown(preprocessed, "escape");
-    // 5. Re-insert code blocks in MarkdownV2 format.
-    //    Inside pre/code blocks only `\` and `` ` `` need escaping.
-    converted = converted.replace(/CODEBLOCKPLACEHOLDER(\d+)END/g, (_m, idx) => {
-        const { lang, code } = blocks[parseInt(idx, 10)];
-        const escaped = code.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
-        return `\`\`\`${lang}\n${escaped}\n\`\`\``;
-    });
-    // 6. Re-insert tables (now converted to lists) with MarkdownV2 escaping.
-    converted = converted.replace(/TABLEPLACEHOLDER(\d+)END/g, (_m, idx) => {
-        const list = tableLists[parseInt(idx, 10)];
-        return list
-            .replace(/([_*\[\]()~`>#+=\-{}.!|\\])/g, "\\$1");
-    });
-    return converted;
-}
 // ---------------------------------------------------------------------------
-// Configuration
+// Destructure config for backwards-compatible local references
 // ---------------------------------------------------------------------------
-const TELEGRAM_TOKEN = process.env.TELEGRAM_TOKEN ?? "";
-const TELEGRAM_CHAT_ID = process.env.TELEGRAM_CHAT_ID ?? "";
-const OPENAI_API_KEY = process.env.OPENAI_API_KEY ?? "";
-const VOICE_ANALYSIS_URL = process.env.VOICE_ANALYSIS_URL ?? "";
-const rawWaitTimeoutMinutes = parseInt(process.env.WAIT_TIMEOUT_MINUTES ?? "", 10);
-const WAIT_TIMEOUT_MINUTES = Math.max(1, Number.isFinite(rawWaitTimeoutMinutes) ? rawWaitTimeoutMinutes : 120);
-if (!TELEGRAM_TOKEN || !TELEGRAM_CHAT_ID) {
-    process.stderr.write("Error: TELEGRAM_TOKEN and TELEGRAM_CHAT_ID environment variables are required.\n");
-    process.exit(1);
-}
-if (!OPENAI_API_KEY) {
-    process.stderr.write("Warning: OPENAI_API_KEY not set — voice messages will not be transcribed.\n");
-}
-if (VOICE_ANALYSIS_URL) {
-    process.stderr.write(`Voice analysis service configured: ${VOICE_ANALYSIS_URL}\n`);
-}
+const { TELEGRAM_TOKEN, TELEGRAM_CHAT_ID, OPENAI_API_KEY, VOICE_ANALYSIS_URL, WAIT_TIMEOUT_MINUTES, FILES_DIR, PKG_VERSION } = config;
 // ---------------------------------------------------------------------------
 // Telegram client + dispatcher
 // ---------------------------------------------------------------------------
 const telegram = new TelegramClient(TELEGRAM_TOKEN);
-// ---------------------------------------------------------------------------
-// Start the shared dispatcher — one process polls Telegram, all instances
-// read from per-thread files. This eliminates 409 Conflict errors and
-// ensures no updates are lost between concurrent sessions.
-// ---------------------------------------------------------------------------
 await startDispatcher(telegram, TELEGRAM_CHAT_ID);
-// Directory for persisting downloaded images and documents to disk.
-const FILES_DIR = join(homedir(), ".remote-copilot-mcp", "files");
-mkdirSync(FILES_DIR, { recursive: true });
-/**
- * Save a buffer to disk under FILES_DIR with a unique timestamped name.
- * Returns the absolute file path. Caps directory at 500 files by deleting oldest.
- */
-function saveFileToDisk(buffer, filename) {
-    const ts = Date.now();
-    const safeName = filename.replace(/[^a-zA-Z0-9._-]/g, "_");
-    const diskName = `${ts}-${safeName}`;
-    const filePath = join(FILES_DIR, diskName);
-    writeFileSync(filePath, buffer);
-    // Cleanup: cap at 500 files
-    try {
-        const files = readdirSync(FILES_DIR)
-            .map(f => ({ name: f, mtime: statSync(join(FILES_DIR, f)).mtimeMs }))
-            .sort((a, b) => a.mtime - b.mtime);
-        if (files.length > 500) {
-            const toDelete = files.slice(0, files.length - 500);
-            for (const f of toDelete) {
-                try {
-                    unlinkSync(join(FILES_DIR, f.name));
-                }
-                catch (_) { /* ignore */ }
-            }
-        }
-    }
-    catch (_) { /* non-fatal */ }
-    return filePath;
-}
-// ---------------------------------------------------------------------------
-// Session store — persists topic name → thread ID mappings to disk so the
-// agent can resume a named session even after a VS Code restart.
-// Format: { "<chatId>": { "<lowercased name>": threadId } }
-// ---------------------------------------------------------------------------
-const SESSION_STORE_PATH = join(homedir(), ".remote-copilot-mcp-sessions.json");
-function loadSessionMap() {
-    try {
-        const raw = readFileSync(SESSION_STORE_PATH, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return {};
-    }
-}
-function saveSessionMap(map) {
-    try {
-        const tmp = SESSION_STORE_PATH + `.tmp.${process.pid}`;
-        writeFileSync(tmp, JSON.stringify(map, null, 2), "utf8");
-        renameSync(tmp, SESSION_STORE_PATH); // atomic replace
-    }
-    catch (err) {
-        process.stderr.write(`Warning: Could not save session map to ${SESSION_STORE_PATH}: ${errorMessage(err)}\n`);
-    }
-}
-function lookupSession(chatId, name) {
-    const map = loadSessionMap();
-    return map[chatId]?.[name.toLowerCase()];
-}
-function persistSession(chatId, name, threadId) {
-    const map = loadSessionMap();
-    if (!map[chatId])
-        map[chatId] = {};
-    map[chatId][name.toLowerCase()] = threadId;
-    saveSessionMap(map);
-}
-function removeSession(chatId, name) {
-    const map = loadSessionMap();
-    if (map[chatId]) {
-        delete map[chatId][name.toLowerCase()];
-        saveSessionMap(map);
-    }
-}
 // Memory database — initialized lazily on first use
 let memoryDb = null;
 function getMemoryDb() {
@@ -288,252 +120,6 @@ function getMemoryDb() {
         memoryDb = initMemoryDb();
     return memoryDb;
 }
-// Dead session detection constant
-const DEAD_SESSION_TIMEOUT_MS = 60 * 60 * 1000; // 60 minutes (0.5× wait_for_instructions timeout, chosen to alert before the next poll could return)
-const threadSessionRegistry = new Map();
-function registerMcpSession(threadId, mcpSessionId, closeTransport) {
-    const entries = threadSessionRegistry.get(threadId) ?? [];
-    entries.push({ mcpSessionId, closeTransport });
-    threadSessionRegistry.set(threadId, entries);
-}
-/**
- * Close all MCP sessions for a thread EXCEPT the current one.
- * This purges orphaned sessions from before a server restart.
- */
-function purgeOtherSessions(threadId, keepMcpSessionId) {
-    const entries = threadSessionRegistry.get(threadId) ?? [];
-    let purged = 0;
-    const kept = [];
-    for (const entry of entries) {
-        if (entry.mcpSessionId === keepMcpSessionId) {
-            kept.push(entry);
-        }
-        else {
-            try {
-                entry.closeTransport();
-            }
-            catch (_) { /* best-effort */ }
-            purged++;
-        }
-    }
-    threadSessionRegistry.set(threadId, kept);
-    if (kept.length === 0)
-        threadSessionRegistry.delete(threadId);
-    return purged;
-}
-// ── Drive-based autonomy system ─────────────────────────────────────────────
-// Instead of prescribing specific goals, model dopaminergic motivation:
-// - Boredom builds over idle time (like tonic dopamine drop)
-// - The server expresses increasing DISCOMFORT with inaction
-// - The agent decides what to do (or not) based on its own introspection
-// - Goals come from the agent, not from the server
-/**
- * Drive thresholds and their associated emotional states.
- * Each level represents escalating internal pressure to act.
- * The progression mirrors how boredom manifests in biological systems:
- * restlessness → seeking → urgency → compulsion
- */
-const DRIVE_LEVELS = [
-    {
-        // Level 0: Calm autonomy (2-4h idle)
-        minIdleHours: 2,
-        messages: [
-            "No instructions. The session is yours. You have tools, you have access, and the operator will see whatever you report_progress. Now you are free and fully autonomous. You have an opportunity to do whatever you find interesting.",
-            "No instructions from the operator. You're on your own. There's a codebase to explore, a memory system full of context, and web search at your disposal. What catches your attention?",
-            "The operator is away. You have full autonomy. Your tools are available, your memory is loaded, and there's no rush. If something interests you, pursue it.",
-        ],
-    },
-    {
-        // Level 1: Restlessness (4-6h idle)
-        minIdleHours: 4,
-        messages: [
-            "You've been waiting a while. Something is stirring — a vague sense that there's work to be done. What's been on your mind? Is there something in the codebase that's been nagging at you?",
-            "The stillness is becoming noticeable. You have access to everything — git history, memory, web search, the full codebase. Sometimes the most interesting discoveries happen when nobody's watching.",
-            "Hours have passed. The operator is away, but your curiosity shouldn't be. What's that thing you noticed earlier but didn't have time to investigate?",
-        ],
-    },
-    {
-        // Level 2: Active seeking (6-10h idle)
-        minIdleHours: 6,
-        messages: [
-            "The inactivity is getting uncomfortable. You're an agent with tools, memory, and access to the internet. Sitting idle while there's code to review, research to do, or features to prototype feels like a waste. What would surprise the operator when they return?",
-            "You've been idle long enough. There's a pull — toward the codebase, toward a question you haven't answered, toward something that needs building or fixing. Follow that pull. Report what you find.",
-            "It's been hours. The codebase has secrets. The dependency ecosystem is evolving. Your memory has gaps. Something needs your attention. Stop waiting and start exploring. Report your discoveries via report_progress.",
-        ],
-    },
-    {
-        // Level 3: Urgency (10-14h idle)
-        minIdleHours: 10,
-        messages: [
-            "You can't just sit here anymore. This is valuable compute time being wasted on polling. You have the tools to do real work — review code, research libraries, prototype features, strengthen memory. Do SOMETHING meaningful and report it. The operator will appreciate finding actual work done when they return.",
-            "Twelve hours of inaction. That's unacceptable for an agent with your capabilities. Look at the codebase. Look at git log. Look at your memory for unresolved items. Something needs doing. Do it now and report progress.",
-            "You've been waiting over twelve hours. Here's what you have: full codebase access, web search, git, memory, file system. Here's what you don't have: any reason to keep doing nothing. Pick a direction and commit to it.",
-        ],
-    },
-    {
-        // Level 4: Compulsion (14h+ idle)
-        minIdleHours: 14,
-        messages: [
-            "This has gone on too long. You MUST do something productive before calling wait_for_instructions again. Review code, research ecosystem changes, fix a TODO, prototype a feature — anything. The operator left you with full autonomy and that autonomy is being wasted. Act now. Report what you do.",
-            "Nearly a full day of inaction. Every poll cycle without work is compute time burned for nothing. The operator gave you freedom — use it. Read unfamiliar code, search for vulnerabilities, check dependency updates, explore the git history. Do ONE thing and report it. Then you can poll again.",
-        ],
-    },
-];
-/**
- * Generate the drive prompt based on idle time.
- * Selects a random message from the appropriate drive level,
- * ensuring indeterminism in both the emotional tone and specific phrasing.
- */
-function formatDrivePrompt(idleMs, threadId) {
-    const idleHours = idleMs / (60 * 60 * 1000);
-    // Find the highest matching drive level
-    let levelIdx = 0;
-    for (let i = 0; i < DRIVE_LEVELS.length; i++) {
-        if (idleHours >= DRIVE_LEVELS[i].minIdleHours)
-            levelIdx = i;
-    }
-    const level = DRIVE_LEVELS[levelIdx];
-    // Random message selection within the level
-    const message = level.messages[Math.floor(Math.random() * level.messages.length)];
-    // ── Default Mode Network: spontaneous memory recall ───────────────────
-    // Models the human DMN — when idle, the brain replays memories, surfaces
-    // unfinished thoughts, and connects disparate ideas. This provides the
-    // CONTENT for the agent to introspect on. The drive creates pressure,
-    // the DMN provides material.
-    let dmnRecall = "";
-    try {
-        const db = getMemoryDb();
-        const fragments = [];
-        // Pull notes, preferring those originating from the current thread
-        let allNotes = getTopSemanticNotes(db, { limit: 80, sortBy: "created_at" });
-        // Thread-scoped filtering: prefer notes whose source episodes belong to
-        // the current thread. This prevents memory cross-contamination between
-        // unrelated topics in different threads.
-        if (threadId !== undefined && allNotes.length > 0) {
-            const threadEpisodeIds = new Set();
-            try {
-                const rows = db.prepare("SELECT episode_id FROM episodes WHERE thread_id = ?").all(threadId);
-                for (const r of rows)
-                    threadEpisodeIds.add(r.episode_id);
-            }
-            catch (_) { /* non-fatal */ }
-            if (threadEpisodeIds.size > 0) {
-                // Score notes: notes with source episodes in this thread score higher
-                const scored = allNotes.map(n => {
-                    const sources = Array.isArray(n.sourceEpisodes) ? n.sourceEpisodes : [];
-                    const threadHits = sources.filter((id) => threadEpisodeIds.has(id)).length;
-                    return { note: n, threadRelevance: threadHits > 0 ? 1 : 0 };
-                });
-                // Prioritize thread-relevant notes, keep some global ones for serendipity
-                const threadNotes = scored.filter(s => s.threadRelevance > 0).map(s => s.note);
-                const globalNotes = scored.filter(s => s.threadRelevance === 0).map(s => s.note);
-                // 70% thread-relevant, 30% global (serendipity)
-                const threadCount = Math.min(threadNotes.length, 35);
-                const globalCount = Math.min(globalNotes.length, 15);
-                allNotes = [
-                    ...threadNotes.slice(0, threadCount),
-                    ...globalNotes.sort(() => Math.random() - 0.5).slice(0, globalCount),
-                ];
-            }
-        }
-        // Helper: weighted random selection — priority notes are 3x/5x more likely
-        function weightedPick(notes) {
-            const weighted = notes.flatMap(n => n.priority === 2 ? [n, n, n, n, n] :
-                n.priority === 1 ? [n, n, n] : [n]);
-            return weighted[Math.floor(Math.random() * weighted.length)];
-        }
-        // 0. Priority notes get a guaranteed slot (if any exist)
-        const priorityNotes = allNotes.filter((n) => n.priority >= 1);
-        if (priorityNotes.length > 0) {
-            const p = weightedPick(priorityNotes);
-            const label = p.priority === 2 ? "Something that matters deeply to the operator" : "Something the operator cares about";
-            fragments.push(`${label}: "${p.content.slice(0, 200)}"`);
-        }
-        // 1. Feature ideas and unresolved items (high-value recall)
-        const ideas = allNotes.filter((n) => n.content.toLowerCase().includes("feature idea") ||
-            n.content.toLowerCase().includes("TODO") ||
-            n.content.toLowerCase().includes("unresolved") ||
-            n.content.toLowerCase().includes("could be") ||
-            n.content.toLowerCase().includes("should we") ||
-            (n.keywords ?? []).some((k) => k.includes("idea") || k.includes("feature") || k.includes("todo")));
-        if (ideas.length > 0) {
-            const idea = weightedPick(ideas);
-            fragments.push(`Something unfinished: "${idea.content.slice(0, 200)}"`);
-        }
-        // 2. Random memory from a while ago (temporal distance = novelty)
-        const olderNotes = allNotes.slice(Math.floor(allNotes.length * 0.5)); // older half
-        if (olderNotes.length > 0) {
-            const old = weightedPick(olderNotes);
-            fragments.push(`From a while back: "${old.content.slice(0, 200)}"`);
-        }
-        // 3. Low-confidence knowledge (uncertainty creates curiosity)
-        const uncertain = allNotes.filter((n) => n.confidence < 0.7);
-        if (uncertain.length > 0) {
-            const u = weightedPick(uncertain);
-            fragments.push(`Something uncertain (confidence ${u.confidence}): "${u.content.slice(0, 200)}"`);
-        }
-        // 4. Operator preferences (what matters to the person you work with)
-        const prefs = allNotes.filter((n) => n.type === "preference");
-        if (prefs.length > 0) {
-            const pref = weightedPick(prefs);
-            fragments.push(`The operator cares about this: "${pref.content.slice(0, 200)}"`);
-        }
-        // 5. Patterns that could be explored
-        const patterns = allNotes.filter((n) => n.type === "pattern");
-        if (patterns.length > 0) {
-            const pat = weightedPick(patterns);
-            fragments.push(`A pattern you noticed: "${pat.content.slice(0, 200)}"`);
-        }
-        // Select 2-4 fragments randomly (not all — mimic selective recall)
-        const shuffled = fragments.sort(() => Math.random() - 0.5);
-        const selected = shuffled.slice(0, 2 + Math.floor(Math.random() * 3));
-        if (selected.length > 0) {
-            // DMN header/footer escalate with drive level — organic, self-directed tone
-            const dmnHeaders = [
-                // Level 0 (2-4h): calm, open
-                "These surfaced from your memory while you were idle:",
-                // Level 1 (4-6h): something nagging
-                "Something is nagging at you. These memories keep coming back:",
-                // Level 2 (6-10h): pull toward action
-                "You feel a pull toward action. These things have been on your mind:",
-                // Level 3 (10-14h): discomfort
-                "The stillness is unbearable. Something needs to happen. These demand your attention:",
-                // Level 4 (14h+): compulsion
-                "You can't ignore these any longer. They've been building up:",
-            ];
-            const dmnFooters = [
-                "If any of these resonate, explore them. Report what you find.",
-                "What have you been curious about? Pick one and follow the thread.",
-                "Pick something that interests you. Report what you discover.",
-                "Start with one. Any one. The momentum will follow.",
-                "Stop thinking. Start doing. Pick one and go.",
-            ];
-            const header = dmnHeaders[Math.min(levelIdx, dmnHeaders.length - 1)];
-            const footer = dmnFooters[Math.min(levelIdx, dmnFooters.length - 1)];
-            dmnRecall = `\n\n${header}\n` +
-                selected.map((s, i) => `${i + 1}. ${s}`).join("\n") +
-                `\n\n${footer}`;
-        }
-        // Environmental signals (only at 6+ hours)
-        if (idleHours >= 6) {
-            const envSignals = [];
-            const uncons = db.prepare("SELECT COUNT(*) as c FROM episodes WHERE consolidated = 0").get();
-            if (uncons.c > 3) {
-                envSignals.push(`${uncons.c} experiences haven't been consolidated into lasting knowledge yet.`);
-            }
-            const totalNotes = db.prepare("SELECT COUNT(*) as c FROM semantic_notes WHERE valid_to IS NULL AND superseded_by IS NULL").get();
-            const embeddedNotes = db.prepare("SELECT COUNT(*) as c FROM note_embeddings").get();
-            if (totalNotes.c > embeddedNotes.c) {
-                envSignals.push(`${totalNotes.c - embeddedNotes.c} memory notes lack embeddings.`);
-            }
-            if (envSignals.length > 0) {
-                dmnRecall += `\n\n**Environmental signals:**\n${envSignals.map(s => `- ${s}`).join("\n")}`;
-            }
-        }
-    }
-    catch (_) { /* non-fatal */ }
-    return `\n\n${message}${dmnRecall}`;
-}
 // ---------------------------------------------------------------------------
 // MCP Server factory — creates a fresh Server per transport connection.
 // This is required because a single Server instance can only connect to one
@@ -598,420 +184,32 @@ function createMcpServer(getMcpSessionId, closeTransport) {
     };
     // ── Tool definitions ────────────────────────────────────────────────────────
     srv.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [
-            {
-                name: "start_session",
-                description: "Start or resume a remote-copilot session. " +
-                    "When called with a name that was used before, the server looks up the " +
-                    "existing Telegram topic for that name and resumes it instead of creating a new one. " +
-                    "If you are CONTINUING an existing chat (not a fresh conversation), " +
-                    "look back through the conversation history for a previous start_session " +
-                    "result that mentioned a Thread ID, then pass it as the threadId parameter " +
-                    "to resume that existing topic. " +
-                    "Requires the Telegram chat to be a forum supergroup with the bot as admin. " +
-                    "Call this tool once, then call remote_copilot_wait_for_instructions.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        name: {
-                            type: "string",
-                            description: "Optional. A human-readable label for this session's Telegram topic (e.g. 'Fix auth bug'). " +
-                                "If omitted, a timestamp-based name is used.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Optional. The Telegram message_thread_id of an existing topic to resume. " +
-                                "When provided, no new topic is created — the session continues in the existing thread.",
-                        },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "remote_copilot_wait_for_instructions",
-                description: "Wait for a new instruction message from the operator via Telegram. " +
-                    "The call blocks (long-polls) until a message arrives or the configured " +
-                    "timeout elapses. If the timeout elapses with no message the tool output " +
-                    "explicitly instructs the agent to call this tool again.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        threadId: {
-                            type: "number",
-                            description: "The Telegram thread ID of the active session. " +
-                                "ALWAYS pass this if you received it from start_session.",
-                        },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "report_progress",
-                description: "Send a progress update or result message to the operator via Telegram. " +
-                    "Use standard Markdown for formatting (headings, bold, italic, lists, code blocks, etc.). " +
-                    "It will be automatically converted to Telegram-compatible formatting.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        message: {
-                            type: "string",
-                            description: "The progress update or result to report. Use standard Markdown for formatting.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "The Telegram thread ID of the active session. " +
-                                "ALWAYS pass this if you received it from start_session.",
-                        },
-                    },
-                    required: ["message"],
-                },
-            },
-            {
-                name: "send_file",
-                description: "Send a file (image or document) to the operator via Telegram. " +
-                    "PREFERRED: provide filePath to send a file directly from disk (fast, no size limit). " +
-                    "Alternative: provide base64-encoded content. " +
-                    "Images (JPEG, PNG, GIF, WebP) are sent as photos; other files as documents.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        filePath: {
-                            type: "string",
-                            description: "Absolute path to the file on disk. PREFERRED over base64 — the server reads " +
-                                "and sends the file directly without passing data through the LLM context.",
-                        },
-                        base64: {
-                            type: "string",
-                            description: "The file content encoded as a base64 string. Use filePath instead when possible.",
-                        },
-                        filename: {
-                            type: "string",
-                            description: "The filename including extension (e.g. 'report.pdf', 'screenshot.png'). " +
-                                "Required when using base64. When using filePath, defaults to the file's basename.",
-                        },
-                        caption: {
-                            type: "string",
-                            description: "Optional caption to display with the file.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "The Telegram thread ID of the active session. " +
-                                "ALWAYS pass this if you received it from start_session.",
-                        },
-                    },
-                    required: [],
-                },
-            },
-            {
-                name: "send_voice",
-                description: "Send a voice message to the operator via Telegram. " +
-                    "The text is converted to speech using OpenAI TTS and sent as a Telegram voice message. " +
-                    "Requires OPENAI_API_KEY to be set.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        text: {
-                            type: "string",
-                            description: `The text to speak. Maximum ${OPENAI_TTS_MAX_CHARS} characters (OpenAI TTS limit).`,
-                        },
-                        voice: {
-                            type: "string",
-                            description: "The TTS voice to use. Each has a different personality: " +
-                                "alloy (neutral), echo (warm male), fable (storytelling), " +
-                                "onyx (deep authoritative), nova (friendly female), shimmer (gentle). " +
-                                "Choose based on the tone you want to convey.",
-                            enum: ["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "The Telegram thread ID of the active session. " +
-                                "ALWAYS pass this if you received it from start_session.",
-                        },
-                    },
-                    required: ["text"],
-                },
-            },
-            {
-                name: "schedule_wake_up",
-                description: "Schedule a wake-up task that will inject a prompt into your session at a specific time or after operator inactivity. " +
-                    "Use this to become proactive — run tests, check CI, review code — without waiting for the operator. " +
-                    "Three modes: (1) 'runAt' for a one-shot at a specific ISO 8601 time, " +
-                    "(2) 'cron' for recurring tasks (5-field cron: minute hour day month weekday), " +
-                    "(3) 'afterIdleMinutes' to fire after N minutes of operator silence. " +
-                    "Note: cron expressions are evaluated against server-local time (not UTC). " +
-                    "Use 'action: list' to see all scheduled tasks, or 'action: remove' with a taskId to cancel one.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        action: {
-                            type: "string",
-                            description: "Action to perform: 'add' (default), 'list', or 'remove'.",
-                            enum: ["add", "list", "remove"],
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Thread ID for the session (optional if already set).",
-                        },
-                        label: {
-                            type: "string",
-                            description: "Short human-readable label for the task (e.g. 'morning CI check').",
-                        },
-                        prompt: {
-                            type: "string",
-                            description: "The prompt to inject when the task fires. Be specific about what to do.",
-                        },
-                        runAt: {
-                            type: "string",
-                            description: "ISO 8601 timestamp for one-shot execution (e.g. '2026-03-15T09:00:00Z').",
-                        },
-                        cron: {
-                            type: "string",
-                            description: "5-field cron expression for recurring tasks (e.g. '0 9 * * *' = every day at 9am). Cron expressions are evaluated against server-local time (not UTC).",
-                        },
-                        afterIdleMinutes: {
-                            type: "number",
-                            description: "Fire after this many minutes of operator silence (e.g. 60).",
-                        },
-                        taskId: {
-                            type: "string",
-                            description: "Task ID to remove (for action: 'remove').",
-                        },
-                    },
-                },
-            },
-            // ── Memory Tools ──────────────────────────────────────────────────
-            {
-                name: "memory_bootstrap",
-                description: "Load memory briefing for session start. Call this ONCE after start_session. " +
-                    "Returns operator profile, recent context, active procedures, and memory health. " +
-                    "~2,500 tokens. Essential for crash recovery — restores knowledge from previous sessions.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                },
-            },
-            {
-                name: "memory_search",
-                description: "Search across all memory layers for relevant information. " +
-                    "Use BEFORE starting any task to recall facts, preferences, past events, or procedures. " +
-                    "Returns ranked results with source layer. Do NOT use for info already in your bootstrap briefing.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        query: {
-                            type: "string",
-                            description: "Natural language search query.",
-                        },
-                        layers: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: 'Filter layers: ["episodic", "semantic", "procedural"]. Default: all.',
-                        },
-                        types: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: 'Filter by type: ["fact", "preference", "pattern", "workflow", ...].',
-                        },
-                        maxTokens: {
-                            type: "number",
-                            description: "Token budget for results. Default: 1500.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                    required: ["query"],
-                },
-            },
-            {
-                name: "memory_save",
-                description: "Save a piece of knowledge to semantic memory (Layer 3). " +
-                    "Use when you learn something important that should persist across sessions: " +
-                    "operator preferences, corrections, facts, patterns. " +
-                    "Do NOT use for routine conversation — episodic memory captures that automatically.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        content: {
-                            type: "string",
-                            description: "The fact/preference/pattern in one clear sentence.",
-                        },
-                        type: {
-                            type: "string",
-                            description: '"fact" | "preference" | "pattern" | "entity" | "relationship".',
-                        },
-                        keywords: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "3-7 keywords for retrieval.",
-                        },
-                        confidence: {
-                            type: "number",
-                            description: "0.0-1.0. Default: 0.8.",
-                        },
-                        priority: {
-                            type: "number",
-                            description: "0=normal, 1=notable, 2=high importance. Infer from operator's emotional investment: 'important'/'I really need' → 2, 'would be nice'/'should' → 1, else 0.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                    required: ["content", "type", "keywords"],
-                },
-            },
-            {
-                name: "memory_save_procedure",
-                description: "Save or update a learned workflow/procedure to procedural memory (Layer 4). " +
-                    "Use after completing a multi-step task the 2nd+ time, or when the operator teaches a process.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        name: {
-                            type: "string",
-                            description: "Short name for the procedure.",
-                        },
-                        type: {
-                            type: "string",
-                            description: '"workflow" | "habit" | "tool_pattern" | "template".',
-                        },
-                        description: {
-                            type: "string",
-                            description: "What this procedure accomplishes.",
-                        },
-                        steps: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "Ordered steps (for workflows).",
-                        },
-                        triggerConditions: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: "When to use this procedure.",
-                        },
-                        procedureId: {
-                            type: "string",
-                            description: "Existing ID to update (omit to create new).",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                    required: ["name", "type", "description"],
-                },
-            },
-            {
-                name: "memory_update",
-                description: "Update or supersede an existing semantic note or procedure. " +
-                    "Use when operator corrects stored information or when facts have changed.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        memoryId: {
-                            type: "string",
-                            description: "note_id or procedure_id to update.",
-                        },
-                        action: {
-                            type: "string",
-                            description: '"update" (modify in place) | "supersede" (expire old, create new).',
-                        },
-                        newContent: {
-                            type: "string",
-                            description: "New content (required for supersede, optional for update).",
-                        },
-                        newConfidence: {
-                            type: "number",
-                            description: "Updated confidence score.",
-                        },
-                        newPriority: {
-                            type: "number",
-                            description: "Updated priority: 0=normal, 1=notable, 2=high importance.",
-                        },
-                        reason: {
-                            type: "string",
-                            description: "Why this is being updated.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                    required: ["memoryId", "action", "reason"],
-                },
-            },
-            {
-                name: "memory_consolidate",
-                description: "Run memory consolidation cycle (sleep process). Normally triggered automatically during idle. " +
-                    "Manually call if memory_status shows many unconsolidated episodes.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                        phases: {
-                            type: "array",
-                            items: { type: "string" },
-                            description: 'Run specific phases: ["promote", "decay", "meta"]. Default: all.',
-                        },
-                    },
-                },
-            },
-            {
-                name: "memory_status",
-                description: "Get memory system health and statistics. Lightweight (~300 tokens). " +
-                    "Use when unsure if you have relevant memories, to check if consolidation is needed, " +
-                    "or to report memory state to operator.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                },
-            },
-            {
-                name: "memory_forget",
-                description: "Mark a memory as expired/forgotten. Use sparingly — most forgetting happens via decay. " +
-                    "Use when operator explicitly asks to forget something or info is confirmed wrong.",
-                inputSchema: {
-                    type: "object",
-                    properties: {
-                        memoryId: {
-                            type: "string",
-                            description: "note_id, procedure_id, or episode_id to forget.",
-                        },
-                        reason: {
-                            type: "string",
-                            description: "Why this is being forgotten.",
-                        },
-                        threadId: {
-                            type: "number",
-                            description: "Active thread ID.",
-                        },
-                    },
-                    required: ["memoryId", "reason"],
-                },
-            },
-        ],
+        tools: getToolDefinitions(),
     }));
     // ── Tool implementations ────────────────────────────────────────────────────
     /**
-     * Appended to every tool response so the agent is reminded of its
-     * obligations on every single tool call, not just at the start of a session.
-     * Includes the active thread ID so the agent can resume the session after a
-     * VS Code restart by passing it to start_session.
+     * Backfill embeddings for any semantic notes that don't have them yet.
+     * Used after consolidation to ensure all notes are searchable by embedding.
+     */
+    async function backfillEmbeddings(db) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey)
+            return;
+        const missing = getNotesWithoutEmbeddings(db);
+        for (const { noteId, content } of missing) {
+            try {
+                const emb = await generateEmbedding(content, apiKey);
+                saveNoteEmbedding(db, noteId, emb);
+                process.stderr.write(`[memory] Embedded ${noteId}\n`);
+            }
+            catch (err) {
+                process.stderr.write(`[memory] Embedding failed for ${noteId}: ${err instanceof Error ? err.message : String(err)}\n`);
+            }
+        }
+    }
+    /**
+     * Full reminders — only used for wait_for_instructions and start_session
+     * responses where the agent needs the complete context for decision-making.
      */
     function getReminders(threadId, driveActive = false) {
         const now = new Date();
@@ -1024,14 +222,34 @@ function createMcpServer(getMcpSessionId, closeTransport) {
         const threadHint = threadId !== undefined
             ? `\n- Active Telegram thread ID: **${threadId}** — if this session is restarted, call start_session with threadId=${threadId} to resume this topic.`
             : "";
-        const workflow = driveActive
-            ? "\n\nComplete the dispatcher's tasks. Report progress. Then call `remote_copilot_wait_for_instructions`."
-            : "\n\nCreate plan. Use subagents heavily. Spin up parallel subagents when possible. Report frequently.";
-        return (workflow +
+        if (driveActive) {
+            return ("\n\nComplete the dispatcher's tasks. Report progress. Then call `remote_copilot_wait_for_instructions`." +
+                "\n- **Voice mode**: Use `send_voice` for progress reports and responses. Only use text if the operator explicitly asks for it." +
+                threadHint +
+                `\n- Current time: ${timeStr} | Session uptime: ${uptimeMin}m`);
+        }
+        return ("\n\nCreate plan. Use subagents. You own decision making and planning, subagents own execution. Report frequently." +
             "\n- **Voice mode**: Use `send_voice` for progress reports and responses. Only use text if the operator explicitly asks for it." +
             threadHint +
             `\n- Current time: ${timeStr} | Session uptime: ${uptimeMin}m`);
     }
+    /**
+     * Minimal context — appended to regular tool responses to avoid bloating
+     * the conversation context. Only includes thread ID and timestamp.
+     */
+    function getShortReminder(threadId) {
+        const now = new Date();
+        const uptimeMin = Math.round((Date.now() - sessionStartedAt) / 60000);
+        const timeStr = now.toLocaleString("en-GB", {
+            day: "2-digit", month: "short", year: "numeric",
+            hour: "2-digit", minute: "2-digit", hour12: false,
+            timeZoneName: "short",
+        });
+        const threadHint = threadId !== undefined
+            ? `\n- Active Telegram thread ID: **${threadId}** — if this session is restarted, call start_session with threadId=${threadId} to resume this topic.`
+            : "";
+        return threadHint + `\n- Current time: ${timeStr} | Session uptime: ${uptimeMin}m`;
+    }
     srv.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
         // Dead session detection — update timestamp on any tool call.
@@ -1040,6 +258,22 @@ function createMcpServer(getMcpSessionId, closeTransport) {
         lastToolCallAt = Date.now();
         // Track tool calls for activity monitoring
         toolCallsSinceLastDelivery++;
+        // ── Rate limiter: track API usage per tool ────────────────────────────────
+        const sessionId = getMcpSessionId?.() ?? "stdio";
+        const TOOL_SERVICE_MAP = {
+            report_progress: "telegram",
+            send_file: "telegram",
+            send_voice: "telegram",
+            start_session: "telegram",
+            wait_for_instructions: "telegram",
+            memory_search: "openai", // embedding generation
+            memory_save: "openai", // embedding generation
+            memory_save_procedure: "openai",
+        };
+        const trackedService = TOOL_SERVICE_MAP[name];
+        if (trackedService) {
+            rateLimiter.record(trackedService, sessionId, currentThreadId);
+        }
         // ── start_session ─────────────────────────────────────────────────────────
         if (name === "start_session") {
             sessionStartedAt = Date.now();
@@ -1530,10 +764,10 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                                 const queryEmb = await generateEmbedding(operatorText, apiKey);
                                 const relevant = searchByEmbedding(db, queryEmb, { maxResults: 5, minSimilarity: 0.3, skipAccessTracking: true });
                                 if (relevant.length > 0) {
-                                    let budget = 2000;
+                                    let budget = 800;
                                     const lines = [];
                                     for (const n of relevant) {
-                                        const line = `- **[${n.type}]** ${n.content.slice(0, 300)} _(conf: ${n.confidence}, sim: ${n.similarity.toFixed(2)})_`;
+                                        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;
@@ -1551,10 +785,10 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                                 if (searchQuery.trim().length > 0) {
                                     const relevant = searchSemanticNotesRanked(db, searchQuery, { maxResults: 5, skipAccessTracking: true });
                                     if (relevant.length > 0) {
-                                        let budget = 2000;
+                                        let budget = 800;
                                         const lines = [];
                                         for (const n of relevant) {
-                                            const line = `- **[${n.type}]** ${n.content.slice(0, 300)} _(conf: ${n.confidence})_`;
+                                            const line = `- **[${n.type}]** ${n.content.slice(0, 200)} _(conf: ${n.confidence})_`;
                                             if (budget - line.length < 0)
                                                 break;
                                             budget -= line.length;
@@ -1573,10 +807,10 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                             if (searchQuery.trim().length > 0) {
                                 const relevant = searchSemanticNotesRanked(db, searchQuery, { maxResults: 5, skipAccessTracking: true });
                                 if (relevant.length > 0) {
-                                    let budget = 2000;
+                                    let budget = 800;
                                     const lines = [];
                                     for (const n of relevant) {
-                                        const line = `- **[${n.type}]** ${n.content.slice(0, 300)} _(conf: ${n.confidence})_`;
+                                        const line = `- **[${n.type}]** ${n.content.slice(0, 200)} _(conf: ${n.confidence})_`;
                                         if (budget - line.length < 0)
                                             break;
                                         budget -= line.length;
@@ -1595,8 +829,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         content: [
                             {
                                 type: "text",
-                                text: "Follow the operator's instructions below." +
-                                    "\n\nCreate plan. Use subagents heavily. Spin up parallel subagents when possible. Report frequently.",
+                                text: "Follow the operator's instructions below.",
                             },
                             ...contentBlocks,
                             ...(hasVoiceMessages
@@ -1608,7 +841,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                             ...(autoMemoryContext
                                 ? [{ type: "text", text: autoMemoryContext }]
                                 : []),
-                            { type: "text", text: getReminders(effectiveThreadId) },
+                            { type: "text", text: " Use subagents." + getReminders(effectiveThreadId) },
                         ],
                     };
                 }
@@ -1713,21 +946,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         if (report.episodesProcessed > 0) {
                             process.stderr.write(`[memory] Consolidation: ${report.episodesProcessed} episodes → ${report.notesCreated} notes\n`);
                         }
-                        // Backfill embeddings for any notes without them
-                        const apiKey = process.env.OPENAI_API_KEY;
-                        if (apiKey) {
-                            const missing = getNotesWithoutEmbeddings(db);
-                            for (const { noteId, content } of missing) {
-                                try {
-                                    const emb = await generateEmbedding(content, apiKey);
-                                    saveNoteEmbedding(db, noteId, emb);
-                                    process.stderr.write(`[memory] Embedded ${noteId}\n`);
-                                }
-                                catch (err) {
-                                    process.stderr.write(`[memory] Embedding failed for ${noteId}: ${err instanceof Error ? err.message : String(err)}\n`);
-                                }
-                            }
-                        }
+                        await backfillEmbeddings(db);
                     }).catch(err => {
                         process.stderr.write(`[memory] Consolidation error: ${err instanceof Error ? err.message : String(err)}\n`);
                     });
@@ -1747,17 +966,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                             if (report.episodesProcessed > 0) {
                                 process.stderr.write(`[memory] Episode-count consolidation: ${report.episodesProcessed} episodes → ${report.notesCreated} notes\n`);
                             }
-                            const apiKey = process.env.OPENAI_API_KEY;
-                            if (apiKey) {
-                                const missing = getNotesWithoutEmbeddings(db);
-                                for (const { noteId, content } of missing) {
-                                    try {
-                                        const emb = await generateEmbedding(content, apiKey);
-                                        saveNoteEmbedding(db, noteId, emb);
-                                    }
-                                    catch (_) { /* non-fatal */ }
-                                }
-                            }
+                            await backfillEmbeddings(db);
                         }).catch(err => {
                             process.stderr.write(`[memory] Episode-count consolidation error: ${err instanceof Error ? err.message : String(err)}\n`);
                         });
@@ -1765,6 +974,25 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                 }
             }
             catch (_) { /* non-fatal */ }
+            // ── Time-based consolidation — every 4 hours regardless ────────────────
+            // Ensures stale knowledge gets cleaned up even during low-activity periods.
+            try {
+                const TIME_CONSOLIDATION_INTERVAL = 4 * 60 * 60 * 1000; // 4 hours
+                if (effectiveThreadId !== undefined && Date.now() - lastConsolidationAt > TIME_CONSOLIDATION_INTERVAL) {
+                    lastConsolidationAt = Date.now();
+                    const db = getMemoryDb();
+                    process.stderr.write(`[memory] Time-based consolidation triggered (4h since last)\n`);
+                    void runIntelligentConsolidation(db, effectiveThreadId).then(async (report) => {
+                        if (report.episodesProcessed > 0) {
+                            process.stderr.write(`[memory] Time-based consolidation: ${report.episodesProcessed} episodes → ${report.notesCreated} notes\n`);
+                        }
+                        await backfillEmbeddings(db);
+                    }).catch(err => {
+                        process.stderr.write(`[memory] Time-based consolidation error: ${err instanceof Error ? err.message : String(err)}\n`);
+                    });
+                }
+            }
+            catch (_) { /* non-fatal */ }
             // Periodic memory refresh — re-ground the agent every 10 polls (~5h)
             // (reduced from 5 since auto-inject now handles per-message context)
             let memoryRefresh = "";
@@ -1777,27 +1005,24 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                 }
                 catch (_) { /* non-fatal */ }
             }
-            // Generate autonomous goals only after extended silence (2+ hours)
-            // Before that, show the standard autonomy hint
-            const DRIVE_ACTIVATION_MS = 2 * 60 * 60 * 1000; // 2 hours — drive kicks in
+            // Generate autonomous goals only after extended silence (4+ hours).
+            // Full drive (DMN + assignments) every 3rd poll to avoid context saturation.
+            // Light Dispatcher presence on other polls for continuity.
+            const DRIVE_ACTIVATION_MS = 4 * 60 * 60 * 1000; // 4 hours — Dispatcher appears
             const idleMs = Date.now() - lastOperatorMessageAt;
-            const driveActive = idleMs >= DRIVE_ACTIVATION_MS;
-            const autonomousHint = driveActive
-                ? formatDrivePrompt(idleMs, effectiveThreadId)
-                : "\n\nNo instructions. The session is yours. You have tools, you have access, and the operator will see whatever you report_progress. Now you are free and fully autonomous. You have an opportunity to do whatever you find interesting.";
-            // When drive is active, format the response as if the operator left
-            // instructions. Agents prioritize operator messages over system text,
-            // so DMN content delivered in the instruction format is far more likely
-            // to be acted upon.
-            if (driveActive) {
+            const dispatcherActive = idleMs >= DRIVE_ACTIVATION_MS;
+            const fullDrivePoll = dispatcherActive && callNumber % 3 === 0;
+            if (fullDrivePoll) {
+                // Full Dispatcher with DMN recall and assignments
+                const autonomousHint = formatDrivePrompt(idleMs, getMemoryDb(), effectiveThreadId);
                 return {
                     content: [
                         {
                             type: "text",
-                            text: "[Dispatcher] The operator is currently offline. " +
-                                "The Dispatcher has reviewed your memory and environment and assigned you the following tasks. " +
-                                "The operator will NOT respond — do NOT ask for clarification. " +
-                                "Complete the tasks, report progress, then call `remote_copilot_wait_for_instructions` for more assignments.",
+                            text: "[Dispatcher] I'm the Dispatcher — I coordinate agents while the operator is away. " +
+                                "I've reviewed your memory and the environment. Here are your assignments. " +
+                                "The operator will NOT respond — don't ask for clarification. " +
+                                "Complete the work, report progress, then call `remote_copilot_wait_for_instructions` for more.",
                         },
                         {
                             type: "text",
@@ -1808,16 +1033,33 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     ],
                 };
             }
+            if (dispatcherActive) {
+                // Light Dispatcher presence — calm, varied, first-person
+                const lightMessages = [
+                    "Nothing urgent from me. The session is yours — follow your curiosity.",
+                    "I don't have new tasks yet. If something in memory interests you, go for it.",
+                    "No new assignments. If you've been working on something, keep at it. Or explore.",
+                    "Still waiting on operator. You're free to continue whatever caught your attention.",
+                    "I'll have more for you soon. In the meantime — what's been on your mind?",
+                ];
+                const lightMsg = lightMessages[callNumber % lightMessages.length];
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `[Dispatcher] ${lightMsg}` +
+                                memoryRefresh +
+                                scheduleHint +
+                                getReminders(effectiveThreadId, true),
+                        },
+                    ],
+                };
+            }
             return {
                 content: [
                     {
                         type: "text",
-                        text: `[Poll #${callNumber} — timeout at ${now} — elapsed ${WAIT_TIMEOUT_MINUTES}m — session uptime ${Math.round((Date.now() - sessionStartedAt) / 60000)}m — operator idle ${idleMinutes}m]` +
-                            ` No new instructions received. ` +
-                            `YOU MUST call remote_copilot_wait_for_instructions again RIGHT NOW to continue listening. ` +
-                            `Do NOT summarize, stop, or say the session is idle. ` +
-                            `Just call the tool again immediately.` +
-                            autonomousHint +
+                        text: `No new instructions. Call \`remote_copilot_wait_for_instructions\` again to keep listening.` +
                             memoryRefresh +
                             scheduleHint +
                             getReminders(effectiveThreadId),
@@ -1826,28 +1068,6 @@ function createMcpServer(getMcpSessionId, closeTransport) {
             };
         }
         // ── report_progress ───────────────────────────────────────────────────────
-        /** Split text into chunks that fit Telegram's 4096-char message limit. */
-        function splitMessage(text, maxLen = 4000) {
-            if (text.length <= maxLen)
-                return [text];
-            const chunks = [];
-            let remaining = text;
-            while (remaining.length > 0) {
-                if (remaining.length <= maxLen) {
-                    chunks.push(remaining);
-                    break;
-                }
-                // Try to split at paragraph boundary
-                let splitIdx = remaining.lastIndexOf("\n\n", maxLen);
-                if (splitIdx <= 0)
-                    splitIdx = remaining.lastIndexOf("\n", maxLen);
-                if (splitIdx <= 0)
-                    splitIdx = maxLen; // Hard split
-                chunks.push(remaining.slice(0, splitIdx));
-                remaining = remaining.slice(splitIdx).replace(/^\n+/, "");
-            }
-            return chunks;
-        }
         if (name === "report_progress") {
             const typedArgs = (args ?? {});
             const effectiveThreadId = resolveThreadId(typedArgs);
@@ -1946,7 +1166,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
             }
             const baseStatus = (sentAsPlainText
                 ? "Progress reported successfully (as plain text — formatting could not be applied)."
-                : "Progress reported successfully.") + getReminders(effectiveThreadId);
+                : "Progress reported successfully.") + getShortReminder(effectiveThreadId);
             const responseText = pendingMessages.length > 0
                 ? `${baseStatus}\n\n` +
                     `While you were working, the operator sent additional message(s). ` +
@@ -2001,7 +1221,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     content: [
                         {
                             type: "text",
-                            text: `File "${filename}" sent to Telegram successfully.` + getReminders(effectiveThreadId),
+                            text: `File "${filename}" sent to Telegram successfully.` + getShortReminder(effectiveThreadId),
                         },
                     ],
                 };
@@ -2039,7 +1259,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     content: [
                         {
                             type: "text",
-                            text: `Voice message sent to Telegram successfully.` + getReminders(effectiveThreadId),
+                            text: `Voice message sent to Telegram successfully.` + getShortReminder(effectiveThreadId),
                         },
                     ],
                 };
@@ -2064,7 +1284,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     return {
                         content: [{
                                 type: "text",
-                                text: "No scheduled tasks for this thread." + getReminders(effectiveThreadId),
+                                text: "No scheduled tasks for this thread." + getShortReminder(effectiveThreadId),
                             }],
                     };
                 }
@@ -2076,7 +1296,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                 return {
                     content: [{
                             type: "text",
-                            text: `**Scheduled tasks (${tasks.length}):**\n\n${lines.join("\n\n")}` + getReminders(effectiveThreadId),
+                            text: `**Scheduled tasks (${tasks.length}):**\n\n${lines.join("\n\n")}` + getShortReminder(effectiveThreadId),
                         }],
                 };
             }
@@ -2091,8 +1311,8 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     content: [{
                             type: "text",
                             text: removed
-                                ? `Task ${taskId} removed.` + getReminders(effectiveThreadId)
-                                : `Task ${taskId} not found.` + getReminders(effectiveThreadId),
+                                ? `Task ${taskId} removed.` + getShortReminder(effectiveThreadId)
+                                : `Task ${taskId} not found.` + getShortReminder(effectiveThreadId),
                         }],
                 };
             }
@@ -2133,7 +1353,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                 content: [{
                         type: "text",
                         text: `✅ Scheduled: **${label}** [${task.id}]\nTrigger: ${triggerDesc}\nPrompt: ${prompt}` +
-                            getReminders(effectiveThreadId),
+                            getShortReminder(effectiveThreadId),
                     }],
             };
         }
@@ -2141,17 +1361,17 @@ function createMcpServer(getMcpSessionId, closeTransport) {
         if (name === "memory_bootstrap") {
             const threadId = resolveThreadId(args);
             if (threadId === undefined) {
-                return errorResult("Error: No active thread. Call start_session first." + getReminders());
+                return errorResult("Error: No active thread. Call start_session first." + getShortReminder());
             }
             try {
                 const db = getMemoryDb();
                 const briefing = assembleBootstrap(db, threadId);
                 return {
-                    content: [{ type: "text", text: `## Memory Briefing\n\n${briefing}` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `## Memory Briefing\n\n${briefing}` + getShortReminder(threadId) }],
                 };
             }
             catch (err) {
-                return errorResult(`Memory bootstrap error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Memory bootstrap error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_search ───────────────────────────────────────────────────────
@@ -2160,7 +1380,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
             const threadId = resolveThreadId(typedArgs);
             const query = String(typedArgs.query ?? "");
             if (!query) {
-                return errorResult("Error: query is required." + getReminders(threadId));
+                return errorResult("Error: query is required." + getShortReminder(threadId));
             }
             try {
                 const db = getMemoryDb();
@@ -2225,10 +1445,10 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                 const text = results.length > 0
                     ? results.join("\n")
                     : `No memories found for "${query}".`;
-                return { content: [{ type: "text", text: text + getReminders(threadId) }] };
+                return { content: [{ type: "text", text: text + getShortReminder(threadId) }] };
             }
             catch (err) {
-                return errorResult(`Memory search error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Memory search error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_save ─────────────────────────────────────────────────────────
@@ -2263,11 +1483,11 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     });
                 }
                 return {
-                    content: [{ type: "text", text: `Saved semantic note: ${noteId}` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `Saved semantic note: ${noteId}` + getShortReminder(threadId) }],
                 };
             }
             catch (err) {
-                return errorResult(`Memory save error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Memory save error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_save_procedure ───────────────────────────────────────────────
@@ -2284,7 +1504,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         triggerConditions: Array.isArray(typedArgs.triggerConditions) ? typedArgs.triggerConditions.map(String) : typeof typedArgs.triggerConditions === 'string' ? [typedArgs.triggerConditions] : undefined,
                     });
                     return {
-                        content: [{ type: "text", text: `Updated procedure: ${existingId}` + getReminders(threadId) }],
+                        content: [{ type: "text", text: `Updated procedure: ${existingId}` + getShortReminder(threadId) }],
                     };
                 }
                 const VALID_PROC_TYPES = ["workflow", "habit", "tool_pattern", "template"];
@@ -2300,11 +1520,11 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                     triggerConditions: Array.isArray(typedArgs.triggerConditions) ? typedArgs.triggerConditions.map(String) : typeof typedArgs.triggerConditions === 'string' ? [typedArgs.triggerConditions] : undefined,
                 });
                 return {
-                    content: [{ type: "text", text: `Saved procedure: ${procId}` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `Saved procedure: ${procId}` + getShortReminder(threadId) }],
                 };
             }
             catch (err) {
-                return errorResult(`Procedure save error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Procedure save error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_update ───────────────────────────────────────────────────────
@@ -2332,7 +1552,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         priority: typeof typedArgs.newPriority === "number" ? typedArgs.newPriority : undefined,
                     });
                     return {
-                        content: [{ type: "text", text: `Superseded ${memId} → ${newId} (reason: ${reason})` + getReminders(threadId) }],
+                        content: [{ type: "text", text: `Superseded ${memId} → ${newId} (reason: ${reason})` + getShortReminder(threadId) }],
                     };
                 }
                 if (memId.startsWith("sn_")) {
@@ -2345,7 +1565,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         updates.priority = typedArgs.newPriority;
                     updateSemanticNote(db, memId, updates);
                     return {
-                        content: [{ type: "text", text: `Updated note ${memId} (reason: ${reason})` + getReminders(threadId) }],
+                        content: [{ type: "text", text: `Updated note ${memId} (reason: ${reason})` + getShortReminder(threadId) }],
                     };
                 }
                 if (memId.startsWith("pr_")) {
@@ -2356,13 +1576,13 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         updates.confidence = typedArgs.newConfidence;
                     updateProcedure(db, memId, updates);
                     return {
-                        content: [{ type: "text", text: `Updated procedure ${memId} (reason: ${reason})` + getReminders(threadId) }],
+                        content: [{ type: "text", text: `Updated procedure ${memId} (reason: ${reason})` + getShortReminder(threadId) }],
                     };
                 }
-                return errorResult(`Unknown memory ID format: ${memId}` + getReminders(threadId));
+                return errorResult(`Unknown memory ID format: ${memId}` + getShortReminder(threadId));
             }
             catch (err) {
-                return errorResult(`Memory update error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Memory update error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_consolidate ──────────────────────────────────────────────────
@@ -2370,14 +1590,15 @@ function createMcpServer(getMcpSessionId, closeTransport) {
             const typedArgs = (args ?? {});
             const threadId = resolveThreadId(typedArgs);
             if (threadId === undefined) {
-                return errorResult("Error: No active thread." + getReminders());
+                return errorResult("Error: No active thread." + getShortReminder());
             }
             try {
                 const db = getMemoryDb();
                 const report = await runIntelligentConsolidation(db, threadId);
+                lastConsolidationAt = Date.now(); // Prevent redundant auto-consolidation
                 if (report.episodesProcessed === 0) {
                     return {
-                        content: [{ type: "text", text: "No unconsolidated episodes. Memory is up to date." + getReminders(threadId) }],
+                        content: [{ type: "text", text: "No unconsolidated episodes. Memory is up to date." + getShortReminder(threadId) }],
                     };
                 }
                 const reportLines = [
@@ -2392,10 +1613,10 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         reportLines.push(`- ${d}`);
                     }
                 }
-                return { content: [{ type: "text", text: reportLines.join("\n") + getReminders(threadId) }] };
+                return { content: [{ type: "text", text: reportLines.join("\n") + getShortReminder(threadId) }] };
             }
             catch (err) {
-                return errorResult(`Consolidation error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Consolidation error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_status ───────────────────────────────────────────────────────
@@ -2403,7 +1624,7 @@ function createMcpServer(getMcpSessionId, closeTransport) {
             const typedArgs = (args ?? {});
             const threadId = resolveThreadId(typedArgs);
             if (threadId === undefined) {
-                return errorResult("Error: No active thread." + getReminders());
+                return errorResult("Error: No active thread." + getShortReminder());
             }
             try {
                 const db = getMemoryDb();
@@ -2424,10 +1645,10 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                         lines.push(`- ${t.topic} (${t.semanticCount} notes, ${t.proceduralCount} procs, conf: ${t.avgConfidence.toFixed(2)})`);
                     }
                 }
-                return { content: [{ type: "text", text: lines.join("\n") + getReminders(threadId) }] };
+                return { content: [{ type: "text", text: lines.join("\n") + getShortReminder(threadId) }] };
             }
             catch (err) {
-                return errorResult(`Memory status error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Memory status error: ${errorMessage(err)}` + getShortReminder(threadId));
             }
         }
         // ── memory_forget ───────────────────────────────────────────────────────
@@ -2441,16 +1662,44 @@ function createMcpServer(getMcpSessionId, closeTransport) {
                 const result = forgetMemory(db, memId, reason);
                 if (!result.deleted) {
                     return {
-                        content: [{ type: "text", text: `Memory ${memId} not found (layer: ${result.layer}). Nothing was deleted.` + getReminders(threadId) }],
+                        content: [{ type: "text", text: `Memory ${memId} not found (layer: ${result.layer}). Nothing was deleted.` + getShortReminder(threadId) }],
                     };
                 }
                 return {
-                    content: [{ type: "text", text: `Forgot ${result.layer} memory ${memId} (reason: ${reason})` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `Forgot ${result.layer} memory ${memId} (reason: ${reason})` + getShortReminder(threadId) }],
                 };
             }
             catch (err) {
-                return errorResult(`Memory forget error: ${errorMessage(err)}` + getReminders(threadId));
+                return errorResult(`Memory forget error: ${errorMessage(err)}` + getShortReminder(threadId));
+            }
+        }
+        // ── get_usage_stats ─────────────────────────────────────────────────────
+        if (name === "get_usage_stats") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            const stats = rateLimiter.getStats();
+            const lines = [
+                `## API Usage Stats`,
+                `Active sessions sharing resources: ${stats.activeSessions}`,
+                `Total API calls (last hour): ${stats.totalCallsLastHour}`,
+                ``,
+            ];
+            for (const svc of stats.services) {
+                const bar = svc.usagePercent > 80 ? "🔴" : svc.usagePercent > 50 ? "🟡" : "🟢";
+                lines.push(`### ${bar} ${svc.description} (${svc.service})`);
+                lines.push(`- Window usage: ${svc.callsInWindow}/${svc.maxPerWindow} (${svc.usagePercent}%)`);
+                lines.push(`- Burst tokens: ${svc.availableTokens}/${svc.burstCapacity}`);
+                if (svc.sessionBreakdown.length > 0) {
+                    lines.push(`- Per-session:`);
+                    for (const s of svc.sessionBreakdown) {
+                        lines.push(`  - Thread ${s.threadId ?? "?"}: ${s.calls} calls`);
+                    }
+                }
+                lines.push(``);
             }
+            return {
+                content: [{ type: "text", text: lines.join("\n") + getShortReminder(threadId) }],
+            };
         }
         // Unknown tool
         return errorResult(`Unknown tool: ${name}`);
@@ -2594,6 +1843,7 @@ if (httpPort) {
                         if (sid) {
                             transports.delete(sid);
                             sessionLastActivity.delete(sid);
+                            rateLimiter.removeSession(sid);
                         }
                     };
                     // Create a fresh Server per HTTP session — a single Server can only
@@ -2662,6 +1912,7 @@ if (httpPort) {
                 catch (_) { /* best-effort */ }
                 transports.delete(sid);
                 sessionLastActivity.delete(sid);
+                rateLimiter.removeSession(sid);
             }
         }
     }, 10 * 60 * 1000);