sensorium-mcp 2.8.9 → 2.8.11

package/dist/index.js

@@ -467,899 +467,925 @@ function formatAutonomousGoals(threadId) {
     return lines.join("\n");
 }
 // ---------------------------------------------------------------------------
-// MCP Server
+// MCP Server factory — creates a fresh Server per transport connection.
+// This is required because a single Server instance can only connect to one
+// transport. In HTTP mode, each VS Code client gets its own Server instance.
+// All instances share the same tool handler logic and in-process state.
 // ---------------------------------------------------------------------------
-const server = new Server({ name: "sensorium-mcp", version: PKG_VERSION }, { capabilities: { tools: {} } });
-// ── Tool definitions ────────────────────────────────────────────────────────
-server.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.",
+function createMcpServer() {
+    const srv = new Server({ name: "sensorium-mcp", version: PKG_VERSION }, { capabilities: { tools: {} } });
+    // ── 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: [],
                 },
-                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.",
+            {
+                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: [],
                 },
-                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.",
+            {
+                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"],
                 },
-                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.",
+            {
+                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: [],
                 },
-                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.",
+            {
+                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"],
                 },
-                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. " +
-                "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).",
-                    },
-                    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').",
+            {
+                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. " +
+                    "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).",
+                        },
+                        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.",
+            // ── 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.",
+            {
+                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"],
                 },
-                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.",
-                    },
-                    threadId: {
-                        type: "number",
-                        description: "Active thread ID.",
+            {
+                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.",
+                        },
+                        threadId: {
+                            type: "number",
+                            description: "Active thread ID.",
+                        },
                     },
+                    required: ["content", "type", "keywords"],
                 },
-                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.",
+            {
+                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"],
                 },
-                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.",
-                    },
-                    reason: {
-                        type: "string",
-                        description: "Why this is being updated.",
-                    },
-                    threadId: {
-                        type: "number",
-                        description: "Active thread ID.",
+            {
+                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.",
+                        },
+                        reason: {
+                            type: "string",
+                            description: "Why this is being updated.",
+                        },
+                        threadId: {
+                            type: "number",
+                            description: "Active thread ID.",
+                        },
                     },
+                    required: ["memoryId", "action", "reason"],
                 },
-                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_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_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.",
+            {
+                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"],
                 },
-                required: ["memoryId", "reason"],
             },
-        },
-    ],
-}));
-// ── 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.
- */
-function getReminders(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 ("\n\n## MANDATORY WORKFLOW" +
-        "\n1. **Plan**: Use the todo list tool to break work into discrete items BEFORE starting. Non-negotiable." +
-        "\n2. **Subagents**: Use subagents heavily — spin them up for code edits, searches, research, reviews, and terminal commands. Subagents have full access to ALL MCP tools including terminal, file system, and web search. Run them in parallel when tasks are independent. You plan and verify; subagents execute." +
-        "\n3. **Reporting**: Call `report_progress` after completing EACH todo item. The operator is remote and CANNOT see your work unless you explicitly report it. Silence = failure." +
-        "\n4. **Never stop**: When all work is done, call `remote_copilot_wait_for_instructions` immediately. Never summarize or stop." +
-        "\n5. **Memory**: (a) Call `memory_save` whenever you learn operator preferences, facts, or corrections. (b) Call `memory_search` before starting any task to recall relevant context. (c) Call `memory_status` when reporting progress to include memory health. These tools persist knowledge across sessions." +
-        threadHint +
-        `\n- Current time: ${timeStr} | Session uptime: ${uptimeMin}m`);
-}
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    // Dead session detection — update timestamp on any tool call.
-    // Only reset the alert flag when wait_for_instructions is called,
-    // as that's the primary health signal (agent is actively polling).
-    lastToolCallAt = Date.now();
-    // Track tool calls for subagent compliance nudging
-    toolCallsSinceLastDelivery++;
-    // ── start_session ─────────────────────────────────────────────────────────
-    if (name === "start_session") {
-        sessionStartedAt = Date.now();
-        const typedArgs = (args ?? {});
-        const explicitThreadId = typeof typedArgs.threadId === "number"
-            ? typedArgs.threadId
-            : undefined;
-        const customName = typeof typedArgs.name === "string" && typedArgs.name.trim()
-            ? typedArgs.name.trim()
-            : undefined;
-        // Determine the thread to use:
-        // 1. Explicit threadId beats everything.
-        // 2. A known name looks up the persisted mapping — resume if found.
-        // 3. Otherwise create a new topic.
-        let resolvedPreexisting = false;
-        if (explicitThreadId !== undefined) {
-            currentThreadId = explicitThreadId;
-            // If a name was also supplied, keep the mapping up to date.
-            if (customName)
-                persistSession(TELEGRAM_CHAT_ID, customName, explicitThreadId);
-            resolvedPreexisting = true;
-        }
-        else if (customName !== undefined) {
-            const stored = lookupSession(TELEGRAM_CHAT_ID, customName);
-            if (stored !== undefined) {
-                currentThreadId = stored;
+        ],
+    }));
+    // ── 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.
+     */
+    function getReminders(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 ("\n\n## MANDATORY WORKFLOW" +
+            "\n1. **Plan**: Use the todo list tool to break work into discrete items BEFORE starting. Non-negotiable." +
+            "\n2. **Subagents**: Use subagents heavily — spin them up for code edits, searches, research, reviews, and terminal commands. Subagents have full access to ALL MCP tools including terminal, file system, and web search. Run them in parallel when tasks are independent. You plan and verify; subagents execute." +
+            "\n3. **Reporting**: Call `report_progress` after completing EACH todo item. The operator is remote and CANNOT see your work unless you explicitly report it. Silence = failure." +
+            "\n4. **Never stop**: When all work is done, call `remote_copilot_wait_for_instructions` immediately. Never summarize or stop." +
+            "\n5. **Memory**: (a) Call `memory_save` whenever you learn operator preferences, facts, or corrections. (b) Call `memory_search` before starting any task to recall relevant context. (c) Call `memory_status` when reporting progress to include memory health. These tools persist knowledge across sessions." +
+            threadHint +
+            `\n- Current time: ${timeStr} | Session uptime: ${uptimeMin}m`);
+    }
+    srv.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        // Dead session detection — update timestamp on any tool call.
+        // Only reset the alert flag when wait_for_instructions is called,
+        // as that's the primary health signal (agent is actively polling).
+        lastToolCallAt = Date.now();
+        // Track tool calls for subagent compliance nudging
+        toolCallsSinceLastDelivery++;
+        // ── start_session ─────────────────────────────────────────────────────────
+        if (name === "start_session") {
+            sessionStartedAt = Date.now();
+            const typedArgs = (args ?? {});
+            const explicitThreadId = typeof typedArgs.threadId === "number"
+                ? typedArgs.threadId
+                : undefined;
+            const customName = typeof typedArgs.name === "string" && typedArgs.name.trim()
+                ? typedArgs.name.trim()
+                : undefined;
+            // Determine the thread to use:
+            // 1. Explicit threadId beats everything.
+            // 2. A known name looks up the persisted mapping — resume if found.
+            // 3. Otherwise create a new topic.
+            let resolvedPreexisting = false;
+            if (explicitThreadId !== undefined) {
+                currentThreadId = explicitThreadId;
+                // If a name was also supplied, keep the mapping up to date.
+                if (customName)
+                    persistSession(TELEGRAM_CHAT_ID, customName, explicitThreadId);
                 resolvedPreexisting = true;
             }
-        }
-        if (resolvedPreexisting) {
-            // Drain any stale messages from the thread file so they aren't
-            // re-delivered in the next wait_for_instructions call.
-            const stale = readThreadMessages(currentThreadId);
-            if (stale.length > 0) {
-                process.stderr.write(`[start_session] Drained ${stale.length} stale message(s) from thread ${currentThreadId}.\n`);
-                // Notify the operator that stale messages were discarded.
-                try {
-                    const notice = convertMarkdown(`\u26A0\uFE0F **${stale.length} message(s) from before the session resumed were discarded.** ` +
-                        `If you sent instructions while the agent was offline, please resend them.`);
-                    await telegram.sendMessage(TELEGRAM_CHAT_ID, notice, "MarkdownV2", currentThreadId);
+            else if (customName !== undefined) {
+                const stored = lookupSession(TELEGRAM_CHAT_ID, customName);
+                if (stored !== undefined) {
+                    currentThreadId = stored;
+                    resolvedPreexisting = true;
                 }
-                catch { /* non-fatal */ }
             }
-            // Resume mode: verify the thread is still alive by sending a message.
-            // If the topic was deleted, drop the cached mapping and fall through to
-            // create a new topic.
-            try {
-                const msg = convertMarkdown("🔄 **Session resumed.** Continuing in this thread.");
-                await telegram.sendMessage(TELEGRAM_CHAT_ID, msg, "MarkdownV2", currentThreadId);
-            }
-            catch (err) {
-                const errMsg = errorMessage(err);
-                // Telegram returns "Bad Request: message thread not found" or
-                // "Bad Request: the topic was closed" for deleted/closed topics.
-                const isThreadGone = /thread not found|topic.*(closed|deleted|not found)/i.test(errMsg);
-                if (isThreadGone) {
-                    process.stderr.write(`[start_session] Cached thread ${currentThreadId} is gone (${errMsg}). Creating new topic.\n`);
-                    // Drop the stale mapping and purge any scheduled tasks.
-                    if (currentThreadId !== undefined)
-                        purgeSchedules(currentThreadId);
-                    if (customName)
-                        removeSession(TELEGRAM_CHAT_ID, customName);
-                    resolvedPreexisting = false;
-                    currentThreadId = undefined;
+            if (resolvedPreexisting) {
+                // Drain any stale messages from the thread file so they aren't
+                // re-delivered in the next wait_for_instructions call.
+                const stale = readThreadMessages(currentThreadId);
+                if (stale.length > 0) {
+                    process.stderr.write(`[start_session] Drained ${stale.length} stale message(s) from thread ${currentThreadId}.\n`);
+                    // Notify the operator that stale messages were discarded.
+                    try {
+                        const notice = convertMarkdown(`\u26A0\uFE0F **${stale.length} message(s) from before the session resumed were discarded.** ` +
+                            `If you sent instructions while the agent was offline, please resend them.`);
+                        await telegram.sendMessage(TELEGRAM_CHAT_ID, notice, "MarkdownV2", currentThreadId);
+                    }
+                    catch { /* non-fatal */ }
+                }
+                // Resume mode: verify the thread is still alive by sending a message.
+                // If the topic was deleted, drop the cached mapping and fall through to
+                // create a new topic.
+                try {
+                    const msg = convertMarkdown("🔄 **Session resumed.** Continuing in this thread.");
+                    await telegram.sendMessage(TELEGRAM_CHAT_ID, msg, "MarkdownV2", currentThreadId);
+                }
+                catch (err) {
+                    const errMsg = errorMessage(err);
+                    // Telegram returns "Bad Request: message thread not found" or
+                    // "Bad Request: the topic was closed" for deleted/closed topics.
+                    const isThreadGone = /thread not found|topic.*(closed|deleted|not found)/i.test(errMsg);
+                    if (isThreadGone) {
+                        process.stderr.write(`[start_session] Cached thread ${currentThreadId} is gone (${errMsg}). Creating new topic.\n`);
+                        // Drop the stale mapping and purge any scheduled tasks.
+                        if (currentThreadId !== undefined)
+                            purgeSchedules(currentThreadId);
+                        if (customName)
+                            removeSession(TELEGRAM_CHAT_ID, customName);
+                        resolvedPreexisting = false;
+                        currentThreadId = undefined;
+                    }
+                    // Other errors (network, etc.) are non-fatal — proceed anyway.
                 }
-                // Other errors (network, etc.) are non-fatal — proceed anyway.
-            }
-        }
-        if (!resolvedPreexisting) {
-            // New session: create a dedicated forum topic.
-            const topicName = customName ??
-                `Copilot — ${new Date().toLocaleString("en-GB", {
-                    day: "2-digit", month: "short", year: "numeric",
-                    hour: "2-digit", minute: "2-digit", hour12: false,
-                })}`;
-            try {
-                const topic = await telegram.createForumTopic(TELEGRAM_CHAT_ID, topicName);
-                currentThreadId = topic.message_thread_id;
-                // Persist so the same name resumes this thread next time.
-                persistSession(TELEGRAM_CHAT_ID, topicName, currentThreadId);
             }
-            catch (err) {
-                // Forum topics not available (e.g. plain group or DM) — cannot proceed
-                // without thread isolation. Return an error so the agent knows.
-                return errorResult(`Error: Could not create forum topic: ${errorMessage(err)}. ` +
-                    "Ensure the Telegram chat is a forum supergroup with the bot as admin with can_manage_topics right.");
+            if (!resolvedPreexisting) {
+                // New session: create a dedicated forum topic.
+                const topicName = customName ??
+                    `Copilot — ${new Date().toLocaleString("en-GB", {
+                        day: "2-digit", month: "short", year: "numeric",
+                        hour: "2-digit", minute: "2-digit", hour12: false,
+                    })}`;
+                try {
+                    const topic = await telegram.createForumTopic(TELEGRAM_CHAT_ID, topicName);
+                    currentThreadId = topic.message_thread_id;
+                    // Persist so the same name resumes this thread next time.
+                    persistSession(TELEGRAM_CHAT_ID, topicName, currentThreadId);
+                }
+                catch (err) {
+                    // Forum topics not available (e.g. plain group or DM) — cannot proceed
+                    // without thread isolation. Return an error so the agent knows.
+                    return errorResult(`Error: Could not create forum topic: ${errorMessage(err)}. ` +
+                        "Ensure the Telegram chat is a forum supergroup with the bot as admin with can_manage_topics right.");
+                }
+                try {
+                    const greeting = convertMarkdown("# 🤖 Remote Copilot Ready\n\n" +
+                        "Your AI assistant is online and listening.\n\n" +
+                        "**Send your instructions** and I'll get to work — " +
+                        "I'll keep you posted on progress as I go.");
+                    await telegram.sendMessage(TELEGRAM_CHAT_ID, greeting, "MarkdownV2", currentThreadId);
+                }
+                catch {
+                    // Non-fatal.
+                }
             }
+            const threadNote = currentThreadId !== undefined
+                ? ` Thread ID: ${currentThreadId} (pass this to start_session as threadId to resume this topic later).`
+                : "";
+            // Auto-bootstrap memory
+            let memoryBriefing = "";
             try {
-                const greeting = convertMarkdown("# 🤖 Remote Copilot Ready\n\n" +
-                    "Your AI assistant is online and listening.\n\n" +
-                    "**Send your instructions** and I'll get to work — " +
-                    "I'll keep you posted on progress as I go.");
-                await telegram.sendMessage(TELEGRAM_CHAT_ID, greeting, "MarkdownV2", currentThreadId);
+                const db = getMemoryDb();
+                if (currentThreadId !== undefined) {
+                    memoryBriefing = "\n\n" + assembleBootstrap(db, currentThreadId);
+                }
             }
-            catch {
-                // Non-fatal.
+            catch (e) {
+                memoryBriefing = "\n\n_Memory system unavailable._";
             }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Session ${resolvedPreexisting ? "resumed" : "started"}.${threadNote}` +
+                            ` Call the remote_copilot_wait_for_instructions tool next.` +
+                            memoryBriefing +
+                            getReminders(currentThreadId),
+                    },
+                ],
+            };
         }
-        const threadNote = currentThreadId !== undefined
-            ? ` Thread ID: ${currentThreadId} (pass this to start_session as threadId to resume this topic later).`
-            : "";
-        // Auto-bootstrap memory
-        let memoryBriefing = "";
-        try {
-            const db = getMemoryDb();
-            if (currentThreadId !== undefined) {
-                memoryBriefing = "\n\n" + assembleBootstrap(db, currentThreadId);
+        // ── remote_copilot_wait_for_instructions ──────────────────────────────────
+        if (name === "remote_copilot_wait_for_instructions") {
+            // Agent is actively polling — this is the primary health signal
+            deadSessionAlerted = false;
+            toolCallsSinceLastDelivery = 0; // reset on polling
+            const typedArgs = (args ?? {});
+            const effectiveThreadId = resolveThreadId(typedArgs);
+            if (effectiveThreadId === undefined) {
+                return errorResult("Error: No active session. Call start_session first, then pass the returned threadId to this tool.");
             }
-        }
-        catch (e) {
-            memoryBriefing = "\n\n_Memory system unavailable._";
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Session ${resolvedPreexisting ? "resumed" : "started"}.${threadNote}` +
-                        ` Call the remote_copilot_wait_for_instructions tool next.` +
-                        memoryBriefing +
-                        getReminders(currentThreadId),
-                },
-            ],
-        };
-    }
-    // ── remote_copilot_wait_for_instructions ──────────────────────────────────
-    if (name === "remote_copilot_wait_for_instructions") {
-        // Agent is actively polling — this is the primary health signal
-        deadSessionAlerted = false;
-        toolCallsSinceLastDelivery = 0; // reset on polling
-        const typedArgs = (args ?? {});
-        const effectiveThreadId = resolveThreadId(typedArgs);
-        if (effectiveThreadId === undefined) {
-            return errorResult("Error: No active session. Call start_session first, then pass the returned threadId to this tool.");
-        }
-        const callNumber = ++waitCallCount;
-        const timeoutMs = WAIT_TIMEOUT_MINUTES * 60 * 1000;
-        const deadline = Date.now() + timeoutMs;
-        // Poll the dispatcher's per-thread file instead of calling getUpdates
-        // directly. This avoids 409 conflicts between concurrent instances.
-        const POLL_INTERVAL_MS = 2000;
-        let lastScheduleCheck = 0;
-        while (Date.now() < deadline) {
-            const stored = readThreadMessages(effectiveThreadId);
-            if (stored.length > 0) {
-                // Update the operator activity timestamp for idle detection.
-                lastOperatorMessageAt = Date.now();
-                // Clear only the consumed IDs from the previewed set (scoped clear).
-                // This is safe because Node.js is single-threaded — no report_progress
-                // call can interleave between readThreadMessages and this cleanup.
-                for (const msg of stored) {
-                    previewedUpdateIds.delete(msg.update_id);
-                }
-                // React with 👀 on each consumed message to signal "seen" to the operator.
-                for (const msg of stored) {
-                    void telegram.setMessageReaction(TELEGRAM_CHAT_ID, msg.message.message_id);
-                }
-                const contentBlocks = [];
-                let hasVoiceMessages = false;
-                // Track which messages already had episodes saved (voice/video handlers)
-                const savedEpisodeUpdateIds = new Set();
-                for (const msg of stored) {
-                    // Photos: download the largest size, persist to disk, and embed as base64.
-                    if (msg.message.photo && msg.message.photo.length > 0) {
-                        const largest = msg.message.photo[msg.message.photo.length - 1];
-                        try {
-                            const { buffer, filePath: telegramPath } = await telegram.downloadFileAsBuffer(largest.file_id);
-                            const ext = telegramPath.split(".").pop()?.toLowerCase() ?? "jpg";
-                            const mimeType = ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : "image/jpeg";
-                            const base64 = buffer.toString("base64");
-                            const diskPath = saveFileToDisk(buffer, `photo.${ext}`);
-                            contentBlocks.push({ type: "image", data: base64, mimeType });
-                            contentBlocks.push({
-                                type: "text",
-                                text: `[Photo saved to: ${diskPath}]` +
-                                    (msg.message.caption ? ` Caption: ${msg.message.caption}` : ""),
-                            });
-                        }
-                        catch (err) {
-                            contentBlocks.push({
-                                type: "text",
-                                text: `[Photo received but could not be downloaded: ${errorMessage(err)}]`,
-                            });
-                        }
+            const callNumber = ++waitCallCount;
+            const timeoutMs = WAIT_TIMEOUT_MINUTES * 60 * 1000;
+            const deadline = Date.now() + timeoutMs;
+            // Poll the dispatcher's per-thread file instead of calling getUpdates
+            // directly. This avoids 409 conflicts between concurrent instances.
+            const POLL_INTERVAL_MS = 2000;
+            let lastScheduleCheck = 0;
+            while (Date.now() < deadline) {
+                const stored = readThreadMessages(effectiveThreadId);
+                if (stored.length > 0) {
+                    // Update the operator activity timestamp for idle detection.
+                    lastOperatorMessageAt = Date.now();
+                    // Clear only the consumed IDs from the previewed set (scoped clear).
+                    // This is safe because Node.js is single-threaded — no report_progress
+                    // call can interleave between readThreadMessages and this cleanup.
+                    for (const msg of stored) {
+                        previewedUpdateIds.delete(msg.update_id);
+                    }
+                    // React with 👀 on each consumed message to signal "seen" to the operator.
+                    for (const msg of stored) {
+                        void telegram.setMessageReaction(TELEGRAM_CHAT_ID, msg.message.message_id);
                     }
-                    // Documents: download, persist to disk, and embed as base64.
-                    if (msg.message.document) {
-                        const doc = msg.message.document;
-                        try {
-                            const { buffer, filePath: telegramPath } = await telegram.downloadFileAsBuffer(doc.file_id);
-                            const filename = doc.file_name ?? basename(telegramPath);
-                            const ext = filename.split(".").pop()?.toLowerCase() ?? "";
-                            const mimeType = doc.mime_type ?? (ext in { jpg: 1, jpeg: 1, png: 1, gif: 1, webp: 1 } ? `image/${ext === "jpg" ? "jpeg" : ext}` : "application/octet-stream");
-                            const base64 = buffer.toString("base64");
-                            const diskPath = saveFileToDisk(buffer, filename);
-                            const isImage = mimeType.startsWith("image/");
-                            if (isImage) {
+                    const contentBlocks = [];
+                    let hasVoiceMessages = false;
+                    // Track which messages already had episodes saved (voice/video handlers)
+                    const savedEpisodeUpdateIds = new Set();
+                    for (const msg of stored) {
+                        // Photos: download the largest size, persist to disk, and embed as base64.
+                        if (msg.message.photo && msg.message.photo.length > 0) {
+                            const largest = msg.message.photo[msg.message.photo.length - 1];
+                            try {
+                                const { buffer, filePath: telegramPath } = await telegram.downloadFileAsBuffer(largest.file_id);
+                                const ext = telegramPath.split(".").pop()?.toLowerCase() ?? "jpg";
+                                const mimeType = ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : "image/jpeg";
+                                const base64 = buffer.toString("base64");
+                                const diskPath = saveFileToDisk(buffer, `photo.${ext}`);
                                 contentBlocks.push({ type: "image", data: base64, mimeType });
+                                contentBlocks.push({
+                                    type: "text",
+                                    text: `[Photo saved to: ${diskPath}]` +
+                                        (msg.message.caption ? ` Caption: ${msg.message.caption}` : ""),
+                                });
                             }
-                            else {
-                                // Non-image documents: provide the disk path instead of
-                                // dumping potentially huge base64 into the LLM context.
+                            catch (err) {
                                 contentBlocks.push({
                                     type: "text",
-                                    text: `[Document: ${filename} (${mimeType}) — saved to: ${diskPath}]`,
+                                    text: `[Photo received but could not be downloaded: ${errorMessage(err)}]`,
                                 });
                             }
-                            contentBlocks.push({
-                                type: "text",
-                                text: `[File saved to: ${diskPath}]` +
-                                    (msg.message.caption ? ` Caption: ${msg.message.caption}` : ""),
-                            });
                         }
-                        catch (err) {
-                            contentBlocks.push({
-                                type: "text",
-                                text: `[Document "${doc.file_name ?? "file"}" received but could not be downloaded: ${errorMessage(err)}]`,
-                            });
-                        }
-                    }
-                    // Text messages.
-                    if (msg.message.text) {
-                        contentBlocks.push({ type: "text", text: msg.message.text });
-                    }
-                    // Voice messages: transcribe using OpenAI Whisper.
-                    if (msg.message.voice) {
-                        hasVoiceMessages = true;
-                        if (OPENAI_API_KEY) {
+                        // Documents: download, persist to disk, and embed as base64.
+                        if (msg.message.document) {
+                            const doc = msg.message.document;
                             try {
-                                process.stderr.write(`[voice] Downloading voice file ${msg.message.voice.file_id}...\n`);
-                                const { buffer } = await telegram.downloadFileAsBuffer(msg.message.voice.file_id);
-                                process.stderr.write(`[voice] Downloaded ${buffer.length} bytes. Starting transcription + analysis...\n`);
-                                // Run transcription and voice analysis in parallel.
-                                const [transcript, analysis] = await Promise.all([
-                                    transcribeAudio(buffer, OPENAI_API_KEY),
-                                    VOICE_ANALYSIS_URL
-                                        ? analyzeVoiceEmotion(buffer, VOICE_ANALYSIS_URL)
-                                        : Promise.resolve(null),
-                                ]);
-                                // Build rich voice analysis tag from VANPY results.
-                                const tags = buildAnalysisTags(analysis);
-                                const analysisTag = tags.length > 0 ? ` | ${tags.join(", ")}` : "";
+                                const { buffer, filePath: telegramPath } = await telegram.downloadFileAsBuffer(doc.file_id);
+                                const filename = doc.file_name ?? basename(telegramPath);
+                                const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+                                const mimeType = doc.mime_type ?? (ext in { jpg: 1, jpeg: 1, png: 1, gif: 1, webp: 1 } ? `image/${ext === "jpg" ? "jpeg" : ext}` : "application/octet-stream");
+                                const base64 = buffer.toString("base64");
+                                const diskPath = saveFileToDisk(buffer, filename);
+                                const isImage = mimeType.startsWith("image/");
+                                if (isImage) {
+                                    contentBlocks.push({ type: "image", data: base64, mimeType });
+                                }
+                                else {
+                                    // Non-image documents: provide the disk path instead of
+                                    // dumping potentially huge base64 into the LLM context.
+                                    contentBlocks.push({
+                                        type: "text",
+                                        text: `[Document: ${filename} (${mimeType}) — saved to: ${diskPath}]`,
+                                    });
+                                }
                                 contentBlocks.push({
                                     type: "text",
-                                    text: transcript
-                                        ? `[Voice message — ${msg.message.voice.duration}s${analysisTag}, transcribed]: ${transcript}`
-                                        : `[Voice message — ${msg.message.voice.duration}s${analysisTag}, transcribed]: (empty — no speech detected)`,
+                                    text: `[File saved to: ${diskPath}]` +
+                                        (msg.message.caption ? ` Caption: ${msg.message.caption}` : ""),
                                 });
-                                // Auto-save voice signature
-                                if (analysis && effectiveThreadId !== undefined) {
-                                    try {
-                                        const db = getMemoryDb();
-                                        const sessionId = `session_${sessionStartedAt}`;
-                                        const epId = saveEpisode(db, {
-                                            sessionId,
-                                            threadId: effectiveThreadId,
-                                            type: "operator_message",
-                                            modality: "voice",
-                                            content: { raw: transcript ?? "", duration: msg.message.voice.duration },
-                                            importance: 0.6,
-                                        });
-                                        saveVoiceSignature(db, {
-                                            episodeId: epId,
-                                            emotion: analysis.emotion ?? undefined,
-                                            arousal: analysis.arousal ?? undefined,
-                                            dominance: analysis.dominance ?? undefined,
-                                            valence: analysis.valence ?? undefined,
-                                            speechRate: analysis.paralinguistics?.speech_rate ?? undefined,
-                                            meanPitchHz: analysis.paralinguistics?.mean_pitch_hz ?? undefined,
-                                            pitchStdHz: analysis.paralinguistics?.pitch_std_hz ?? undefined,
-                                            jitter: analysis.paralinguistics?.jitter ?? undefined,
-                                            shimmer: analysis.paralinguistics?.shimmer ?? undefined,
-                                            hnrDb: analysis.paralinguistics?.hnr_db ?? undefined,
-                                            audioEvents: analysis.audio_events?.map(e => ({ label: e.label, confidence: e.score })),
-                                            durationSec: msg.message.voice.duration,
-                                        });
-                                        savedEpisodeUpdateIds.add(msg.update_id);
-                                    }
-                                    catch (_) { /* non-fatal */ }
-                                }
                             }
                             catch (err) {
                                 contentBlocks.push({
                                     type: "text",
-                                    text: `[Voice message — ${msg.message.voice.duration}s — transcription failed: ${errorMessage(err)}]`,
+                                    text: `[Document "${doc.file_name ?? "file"}" received but could not be downloaded: ${errorMessage(err)}]`,
                                 });
                             }
                         }
-                        else {
-                            contentBlocks.push({
-                                type: "text",
-                                text: `[Voice message received — ${msg.message.voice.duration}s — cannot transcribe: OPENAI_API_KEY not set]`,
-                            });
+                        // Text messages.
+                        if (msg.message.text) {
+                            contentBlocks.push({ type: "text", text: msg.message.text });
                         }
-                    }
-                    // Video notes (circle videos): extract frames, analyze with GPT-4.1 vision,
-                    // optionally transcribe the audio track.
-                    if (msg.message.video_note) {
-                        hasVoiceMessages = true; // Video notes often contain speech
-                        const vn = msg.message.video_note;
-                        if (OPENAI_API_KEY) {
-                            try {
-                                process.stderr.write(`[video-note] Downloading circle video ${vn.file_id} (${vn.duration}s)...\n`);
-                                const { buffer } = await telegram.downloadFileAsBuffer(vn.file_id);
-                                process.stderr.write(`[video-note] Downloaded ${buffer.length} bytes. Extracting frames + transcribing...\n`);
-                                // Run frame extraction, audio transcription, and voice analysis in parallel.
-                                const [frames, transcript, analysis] = await Promise.all([
-                                    extractVideoFrames(buffer, vn.duration).catch((err) => {
-                                        process.stderr.write(`[video-note] Frame extraction failed: ${errorMessage(err)}\n`);
-                                        return [];
-                                    }),
-                                    transcribeAudio(buffer, OPENAI_API_KEY, "video.mp4").catch(() => ""),
-                                    VOICE_ANALYSIS_URL
-                                        ? analyzeVoiceEmotion(buffer, VOICE_ANALYSIS_URL, {
-                                            mimeType: "video/mp4",
-                                            filename: "video.mp4",
-                                        }).catch(() => null)
-                                        : Promise.resolve(null),
-                                ]);
-                                // Analyze frames with GPT-4.1 vision.
-                                let sceneDescription = "";
-                                if (frames.length > 0) {
-                                    process.stderr.write(`[video-note] Analyzing ${frames.length} frames with GPT-4.1 vision...\n`);
-                                    sceneDescription = await analyzeVideoFrames(frames, vn.duration, OPENAI_API_KEY);
-                                    process.stderr.write(`[video-note] Vision analysis complete.\n`);
-                                }
-                                // Build analysis tags (same as voice messages).
-                                const tags = buildAnalysisTags(analysis);
-                                const analysisTag = tags.length > 0 ? ` | ${tags.join(", ")}` : "";
-                                const parts = [];
-                                parts.push(`[Video note — ${vn.duration}s${analysisTag}]`);
-                                if (sceneDescription)
-                                    parts.push(`Scene: ${sceneDescription}`);
-                                if (transcript)
-                                    parts.push(`Audio: "${transcript}"`);
-                                if (!sceneDescription && !transcript)
-                                    parts.push("(no visual or audio content could be extracted)");
-                                contentBlocks.push({ type: "text", text: parts.join("\n") });
-                                // Auto-save voice signature for video notes
-                                if (analysis && effectiveThreadId !== undefined) {
-                                    try {
-                                        const db = getMemoryDb();
-                                        const sessionId = `session_${sessionStartedAt}`;
-                                        const epId = saveEpisode(db, {
-                                            sessionId,
-                                            threadId: effectiveThreadId,
-                                            type: "operator_message",
-                                            modality: "video_note",
-                                            content: { raw: transcript ?? "", scene: sceneDescription ?? "", duration: vn.duration },
-                                            importance: 0.6,
-                                        });
-                                        saveVoiceSignature(db, {
-                                            episodeId: epId,
-                                            emotion: analysis.emotion ?? undefined,
-                                            arousal: analysis.arousal ?? undefined,
-                                            dominance: analysis.dominance ?? undefined,
-                                            valence: analysis.valence ?? undefined,
-                                            speechRate: analysis.paralinguistics?.speech_rate ?? undefined,
-                                            meanPitchHz: analysis.paralinguistics?.mean_pitch_hz ?? undefined,
-                                            pitchStdHz: analysis.paralinguistics?.pitch_std_hz ?? undefined,
-                                            jitter: analysis.paralinguistics?.jitter ?? undefined,
-                                            shimmer: analysis.paralinguistics?.shimmer ?? undefined,
-                                            hnrDb: analysis.paralinguistics?.hnr_db ?? undefined,
-                                            audioEvents: analysis.audio_events?.map(e => ({ label: e.label, confidence: e.score })),
-                                            durationSec: vn.duration,
-                                        });
-                                        savedEpisodeUpdateIds.add(msg.update_id);
+                        // Voice messages: transcribe using OpenAI Whisper.
+                        if (msg.message.voice) {
+                            hasVoiceMessages = true;
+                            if (OPENAI_API_KEY) {
+                                try {
+                                    process.stderr.write(`[voice] Downloading voice file ${msg.message.voice.file_id}...\n`);
+                                    const { buffer } = await telegram.downloadFileAsBuffer(msg.message.voice.file_id);
+                                    process.stderr.write(`[voice] Downloaded ${buffer.length} bytes. Starting transcription + analysis...\n`);
+                                    // Run transcription and voice analysis in parallel.
+                                    const [transcript, analysis] = await Promise.all([
+                                        transcribeAudio(buffer, OPENAI_API_KEY),
+                                        VOICE_ANALYSIS_URL
+                                            ? analyzeVoiceEmotion(buffer, VOICE_ANALYSIS_URL)
+                                            : Promise.resolve(null),
+                                    ]);
+                                    // Build rich voice analysis tag from VANPY results.
+                                    const tags = buildAnalysisTags(analysis);
+                                    const analysisTag = tags.length > 0 ? ` | ${tags.join(", ")}` : "";
+                                    contentBlocks.push({
+                                        type: "text",
+                                        text: transcript
+                                            ? `[Voice message — ${msg.message.voice.duration}s${analysisTag}, transcribed]: ${transcript}`
+                                            : `[Voice message — ${msg.message.voice.duration}s${analysisTag}, transcribed]: (empty — no speech detected)`,
+                                    });
+                                    // Auto-save voice signature
+                                    if (analysis && effectiveThreadId !== undefined) {
+                                        try {
+                                            const db = getMemoryDb();
+                                            const sessionId = `session_${sessionStartedAt}`;
+                                            const epId = saveEpisode(db, {
+                                                sessionId,
+                                                threadId: effectiveThreadId,
+                                                type: "operator_message",
+                                                modality: "voice",
+                                                content: { raw: transcript ?? "", duration: msg.message.voice.duration },
+                                                importance: 0.6,
+                                            });
+                                            saveVoiceSignature(db, {
+                                                episodeId: epId,
+                                                emotion: analysis.emotion ?? undefined,
+                                                arousal: analysis.arousal ?? undefined,
+                                                dominance: analysis.dominance ?? undefined,
+                                                valence: analysis.valence ?? undefined,
+                                                speechRate: analysis.paralinguistics?.speech_rate ?? undefined,
+                                                meanPitchHz: analysis.paralinguistics?.mean_pitch_hz ?? undefined,
+                                                pitchStdHz: analysis.paralinguistics?.pitch_std_hz ?? undefined,
+                                                jitter: analysis.paralinguistics?.jitter ?? undefined,
+                                                shimmer: analysis.paralinguistics?.shimmer ?? undefined,
+                                                hnrDb: analysis.paralinguistics?.hnr_db ?? undefined,
+                                                audioEvents: analysis.audio_events?.map(e => ({ label: e.label, confidence: e.score })),
+                                                durationSec: msg.message.voice.duration,
+                                            });
+                                            savedEpisodeUpdateIds.add(msg.update_id);
+                                        }
+                                        catch (_) { /* non-fatal */ }
                                     }
-                                    catch (_) { /* non-fatal */ }
+                                }
+                                catch (err) {
+                                    contentBlocks.push({
+                                        type: "text",
+                                        text: `[Voice message — ${msg.message.voice.duration}s — transcription failed: ${errorMessage(err)}]`,
+                                    });
                                 }
                             }
-                            catch (err) {
+                            else {
                                 contentBlocks.push({
                                     type: "text",
-                                    text: `[Video note — ${vn.duration}s — analysis failed: ${errorMessage(err)}]`,
+                                    text: `[Voice message received — ${msg.message.voice.duration}s — cannot transcribe: OPENAI_API_KEY not set]`,
                                 });
                             }
                         }
-                        else {
-                            contentBlocks.push({
-                                type: "text",
-                                text: `[Video note received — ${vn.duration}s — cannot analyze: OPENAI_API_KEY not set]`,
-                            });
+                        // Video notes (circle videos): extract frames, analyze with GPT-4.1 vision,
+                        // optionally transcribe the audio track.
+                        if (msg.message.video_note) {
+                            hasVoiceMessages = true; // Video notes often contain speech
+                            const vn = msg.message.video_note;
+                            if (OPENAI_API_KEY) {
+                                try {
+                                    process.stderr.write(`[video-note] Downloading circle video ${vn.file_id} (${vn.duration}s)...\n`);
+                                    const { buffer } = await telegram.downloadFileAsBuffer(vn.file_id);
+                                    process.stderr.write(`[video-note] Downloaded ${buffer.length} bytes. Extracting frames + transcribing...\n`);
+                                    // Run frame extraction, audio transcription, and voice analysis in parallel.
+                                    const [frames, transcript, analysis] = await Promise.all([
+                                        extractVideoFrames(buffer, vn.duration).catch((err) => {
+                                            process.stderr.write(`[video-note] Frame extraction failed: ${errorMessage(err)}\n`);
+                                            return [];
+                                        }),
+                                        transcribeAudio(buffer, OPENAI_API_KEY, "video.mp4").catch(() => ""),
+                                        VOICE_ANALYSIS_URL
+                                            ? analyzeVoiceEmotion(buffer, VOICE_ANALYSIS_URL, {
+                                                mimeType: "video/mp4",
+                                                filename: "video.mp4",
+                                            }).catch(() => null)
+                                            : Promise.resolve(null),
+                                    ]);
+                                    // Analyze frames with GPT-4.1 vision.
+                                    let sceneDescription = "";
+                                    if (frames.length > 0) {
+                                        process.stderr.write(`[video-note] Analyzing ${frames.length} frames with GPT-4.1 vision...\n`);
+                                        sceneDescription = await analyzeVideoFrames(frames, vn.duration, OPENAI_API_KEY);
+                                        process.stderr.write(`[video-note] Vision analysis complete.\n`);
+                                    }
+                                    // Build analysis tags (same as voice messages).
+                                    const tags = buildAnalysisTags(analysis);
+                                    const analysisTag = tags.length > 0 ? ` | ${tags.join(", ")}` : "";
+                                    const parts = [];
+                                    parts.push(`[Video note — ${vn.duration}s${analysisTag}]`);
+                                    if (sceneDescription)
+                                        parts.push(`Scene: ${sceneDescription}`);
+                                    if (transcript)
+                                        parts.push(`Audio: "${transcript}"`);
+                                    if (!sceneDescription && !transcript)
+                                        parts.push("(no visual or audio content could be extracted)");
+                                    contentBlocks.push({ type: "text", text: parts.join("\n") });
+                                    // Auto-save voice signature for video notes
+                                    if (analysis && effectiveThreadId !== undefined) {
+                                        try {
+                                            const db = getMemoryDb();
+                                            const sessionId = `session_${sessionStartedAt}`;
+                                            const epId = saveEpisode(db, {
+                                                sessionId,
+                                                threadId: effectiveThreadId,
+                                                type: "operator_message",
+                                                modality: "video_note",
+                                                content: { raw: transcript ?? "", scene: sceneDescription ?? "", duration: vn.duration },
+                                                importance: 0.6,
+                                            });
+                                            saveVoiceSignature(db, {
+                                                episodeId: epId,
+                                                emotion: analysis.emotion ?? undefined,
+                                                arousal: analysis.arousal ?? undefined,
+                                                dominance: analysis.dominance ?? undefined,
+                                                valence: analysis.valence ?? undefined,
+                                                speechRate: analysis.paralinguistics?.speech_rate ?? undefined,
+                                                meanPitchHz: analysis.paralinguistics?.mean_pitch_hz ?? undefined,
+                                                pitchStdHz: analysis.paralinguistics?.pitch_std_hz ?? undefined,
+                                                jitter: analysis.paralinguistics?.jitter ?? undefined,
+                                                shimmer: analysis.paralinguistics?.shimmer ?? undefined,
+                                                hnrDb: analysis.paralinguistics?.hnr_db ?? undefined,
+                                                audioEvents: analysis.audio_events?.map(e => ({ label: e.label, confidence: e.score })),
+                                                durationSec: vn.duration,
+                                            });
+                                            savedEpisodeUpdateIds.add(msg.update_id);
+                                        }
+                                        catch (_) { /* non-fatal */ }
+                                    }
+                                }
+                                catch (err) {
+                                    contentBlocks.push({
+                                        type: "text",
+                                        text: `[Video note — ${vn.duration}s — analysis failed: ${errorMessage(err)}]`,
+                                    });
+                                }
+                            }
+                            else {
+                                contentBlocks.push({
+                                    type: "text",
+                                    text: `[Video note received — ${vn.duration}s — cannot analyze: OPENAI_API_KEY not set]`,
+                                });
+                            }
                         }
                     }
-                }
-                if (contentBlocks.length === 0) {
-                    // All messages were unsupported types (stickers, etc.);
-                    // continue polling instead of returning empty instructions.
-                    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-                    continue;
-                }
-                // Auto-ingest episodes for messages not already saved by voice/video handlers
-                try {
-                    const db = getMemoryDb();
-                    const sessionId = `session_${sessionStartedAt}`;
-                    if (effectiveThreadId !== undefined) {
-                        // Collect text from messages that didn't already get an episode
-                        const unsavedMsgs = stored.filter(m => !savedEpisodeUpdateIds.has(m.update_id));
-                        if (unsavedMsgs.length > 0) {
-                            const textContent = unsavedMsgs
-                                .map(m => m.message.text ?? m.message.caption ?? "")
-                                .filter(Boolean)
-                                .join("\n")
-                                .slice(0, 2000);
-                            if (textContent) {
-                                saveEpisode(db, {
-                                    sessionId,
-                                    threadId: effectiveThreadId,
-                                    type: "operator_message",
-                                    modality: "text",
-                                    content: { raw: textContent },
-                                    importance: 0.5,
-                                });
+                    if (contentBlocks.length === 0) {
+                        // All messages were unsupported types (stickers, etc.);
+                        // continue polling instead of returning empty instructions.
+                        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+                        continue;
+                    }
+                    // Auto-ingest episodes for messages not already saved by voice/video handlers
+                    try {
+                        const db = getMemoryDb();
+                        const sessionId = `session_${sessionStartedAt}`;
+                        if (effectiveThreadId !== undefined) {
+                            // Collect text from messages that didn't already get an episode
+                            const unsavedMsgs = stored.filter(m => !savedEpisodeUpdateIds.has(m.update_id));
+                            if (unsavedMsgs.length > 0) {
+                                const textContent = unsavedMsgs
+                                    .map(m => m.message.text ?? m.message.caption ?? "")
+                                    .filter(Boolean)
+                                    .join("\n")
+                                    .slice(0, 2000);
+                                if (textContent) {
+                                    saveEpisode(db, {
+                                        sessionId,
+                                        threadId: effectiveThreadId,
+                                        type: "operator_message",
+                                        modality: "text",
+                                        content: { raw: textContent },
+                                        importance: 0.5,
+                                    });
+                                }
                             }
                         }
                     }
+                    catch (_) { /* memory write failures should never break the main flow */ }
+                    // Inject subagent/delegation hint right after the operator's message
+                    // so the agent treats it as part of the operator's instructions.
+                    const delegationHint = {
+                        type: "text",
+                        text: "\n Read and incorporate the operator's new messages." +
+                            "\n - Update or refine your plan as needed." +
+                            "\n - Continue your work." +
+                            "\n\n⚠️ HINT from operator: Use subagents (runSubagent) for ALL substantial work — code edits, research, reviews, searches, and terminal commands. " +
+                            "Subagents have full access to ALL MCP tools including terminal, file system, and web search. " +
+                            "Run them in parallel when tasks are independent. You plan and verify; subagents execute.",
+                    };
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: "Follow the operator's instructions below.\n\n" +
+                                    "BEFORE doing anything: (1) Break the work into todo items. (2) Share your plan via report_progress. " +
+                                    "(3) For each todo: mark in-progress → do the work → call report_progress → mark completed. " +
+                                    "Use subagents heavily for all substantial work — code edits, research, reviews, searches. Spin up parallel subagents when possible. " +
+                                    "The operator is REMOTE — they cannot see your screen. If you don't call report_progress, they see nothing.",
+                            },
+                            ...contentBlocks,
+                            delegationHint,
+                            ...(hasVoiceMessages
+                                ? [{
+                                        type: "text",
+                                        text: "\n**Note:** The operator sent voice message(s). They prefer voice interaction — use `send_voice` for progress updates and responses when possible.",
+                                    }]
+                                : []),
+                            { type: "text", text: getReminders(effectiveThreadId) },
+                        ],
+                    };
                 }
-                catch (_) { /* memory write failures should never break the main flow */ }
-                // Inject subagent/delegation hint right after the operator's message
-                // so the agent treats it as part of the operator's instructions.
-                const delegationHint = {
-                    type: "text",
-                    text: "\n Read and incorporate the operator's new messages." +
-                        "\n - Update or refine your plan as needed." +
-                        "\n - Continue your work." +
-                        "\n\n⚠️ HINT from operator: Use subagents (runSubagent) for ALL substantial work — code edits, research, reviews, searches, and terminal commands. " +
-                        "Subagents have full access to ALL MCP tools including terminal, file system, and web search. " +
-                        "Run them in parallel when tasks are independent. You plan and verify; subagents execute.",
-                };
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "Follow the operator's instructions below.\n\n" +
-                                "BEFORE doing anything: (1) Break the work into todo items. (2) Share your plan via report_progress. " +
-                                "(3) For each todo: mark in-progress → do the work → call report_progress → mark completed. " +
-                                "Use subagents heavily for all substantial work — code edits, research, reviews, searches. Spin up parallel subagents when possible. " +
-                                "The operator is REMOTE — they cannot see your screen. If you don't call report_progress, they see nothing.",
-                        },
-                        ...contentBlocks,
-                        delegationHint,
-                        ...(hasVoiceMessages
-                            ? [{
+                // Check scheduled tasks every ~60s during idle polling.
+                if (effectiveThreadId !== undefined && Date.now() - lastScheduleCheck >= 60_000) {
+                    lastScheduleCheck = Date.now();
+                    const dueTask = checkDueTasks(effectiveThreadId, lastOperatorMessageAt, false);
+                    if (dueTask) {
+                        return {
+                            content: [
+                                {
                                     type: "text",
-                                    text: "\n**Note:** The operator sent voice message(s). They prefer voice interaction — use `send_voice` for progress updates and responses when possible.",
-                                }]
-                            : []),
-                        { type: "text", text: getReminders(effectiveThreadId) },
-                    ],
-                };
+                                    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),
+                                },
+                            ],
+                        };
+                    }
+                }
+                // No messages yet — sleep briefly and check again.
+                await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
             }
-            // Check scheduled tasks every ~60s during idle polling.
-            if (effectiveThreadId !== undefined && Date.now() - lastScheduleCheck >= 60_000) {
-                lastScheduleCheck = Date.now();
+            // Timeout elapsed with no actionable message.
+            const now = new Date().toISOString();
+            // Check for scheduled wake-up tasks.
+            if (effectiveThreadId !== undefined) {
                 const dueTask = checkDueTasks(effectiveThreadId, lastOperatorMessageAt, false);
                 if (dueTask) {
                     return {
@@ -1375,643 +1401,628 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
             }
-            // No messages yet — sleep briefly and check again.
-            await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-        }
-        // Timeout elapsed with no actionable message.
-        const now = new Date().toISOString();
-        // Check for scheduled wake-up tasks.
-        if (effectiveThreadId !== undefined) {
-            const dueTask = checkDueTasks(effectiveThreadId, lastOperatorMessageAt, false);
-            if (dueTask) {
-                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),
-                        },
-                    ],
-                };
-            }
-        }
-        const idleMinutes = Math.round((Date.now() - lastOperatorMessageAt) / 60000);
-        // Show pending scheduled tasks if any exist.
-        let scheduleHint = "";
-        if (effectiveThreadId !== undefined) {
-            const pending = listSchedules(effectiveThreadId);
-            if (pending.length > 0) {
-                const taskList = pending.map(t => {
-                    let trigger = "";
-                    if (t.runAt) {
-                        trigger = `at ${new Date(t.runAt).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" })}`;
-                    }
-                    else if (t.cron) {
-                        trigger = `cron: ${t.cron}`;
-                    }
-                    else if (t.afterIdleMinutes) {
-                        trigger = `after ${t.afterIdleMinutes}min idle`;
-                    }
-                    return `  • "${t.label}" (${trigger})`;
-                }).join("\n");
-                scheduleHint = `\n\n📋 **Pending scheduled tasks:**\n${taskList}`;
-            }
-        }
-        // ── Auto-consolidation during idle ──────────────────────────────────────
-        try {
-            const idleMs = Date.now() - lastOperatorMessageAt;
-            if (idleMs > 30 * 60 * 1000 && effectiveThreadId !== undefined) {
-                const db = getMemoryDb();
-                const report = await runIntelligentConsolidation(db, effectiveThreadId);
-                if (report.episodesProcessed > 0) {
-                    process.stderr.write(`[memory] Consolidation: ${report.episodesProcessed} episodes → ${report.notesCreated} notes\n`);
+            const idleMinutes = Math.round((Date.now() - lastOperatorMessageAt) / 60000);
+            // Show pending scheduled tasks if any exist.
+            let scheduleHint = "";
+            if (effectiveThreadId !== undefined) {
+                const pending = listSchedules(effectiveThreadId);
+                if (pending.length > 0) {
+                    const taskList = pending.map(t => {
+                        let trigger = "";
+                        if (t.runAt) {
+                            trigger = `at ${new Date(t.runAt).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" })}`;
+                        }
+                        else if (t.cron) {
+                            trigger = `cron: ${t.cron}`;
+                        }
+                        else if (t.afterIdleMinutes) {
+                            trigger = `after ${t.afterIdleMinutes}min idle`;
+                        }
+                        return `  • "${t.label}" (${trigger})`;
+                    }).join("\n");
+                    scheduleHint = `\n\n📋 **Pending scheduled tasks:**\n${taskList}`;
                 }
             }
-        }
-        catch (_) { /* consolidation failure is non-fatal */ }
-        // Periodic memory refresh — re-ground the agent every 5 polls (~2.5h)
-        let memoryRefresh = "";
-        if (callNumber % 5 === 0 && effectiveThreadId !== undefined) {
+            // ── Auto-consolidation during idle ──────────────────────────────────────
             try {
-                const db = getMemoryDb();
-                const refresh = assembleCompactRefresh(db, effectiveThreadId);
-                if (refresh)
-                    memoryRefresh = `\n\n${refresh}`;
-            }
-            catch (_) { /* non-fatal */ }
-        }
-        // Generate autonomous goals (curiosity-driven idle behavior)
-        const autonomousGoals = formatAutonomousGoals(effectiveThreadId);
-        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.` +
-                        autonomousGoals +
-                        memoryRefresh +
-                        scheduleHint +
-                        getReminders(effectiveThreadId),
-                },
-            ],
-        };
-    }
-    // ── report_progress ───────────────────────────────────────────────────────
-    if (name === "report_progress") {
-        const typedArgs = (args ?? {});
-        const effectiveThreadId = resolveThreadId(typedArgs);
-        if (effectiveThreadId === undefined) {
-            return errorResult("Error: No active session. Call start_session first, then pass the returned threadId.");
-        }
-        const rawMessage = typeof typedArgs?.message === "string"
-            ? typedArgs.message
-            : "";
-        if (!rawMessage) {
-            return errorResult("Error: 'message' argument is required for report_progress.");
-        }
-        // Convert standard Markdown to Telegram MarkdownV2.
-        let message;
-        try {
-            message = convertMarkdown(rawMessage);
-        }
-        catch {
-            // Fall back to raw text if Markdown conversion throws.
-            message = rawMessage;
-        }
-        let sentAsPlainText = false;
-        try {
-            await telegram.sendMessage(TELEGRAM_CHAT_ID, message, "MarkdownV2", effectiveThreadId);
-        }
-        catch (error) {
-            const errMsg = errorMessage(error);
-            // If Telegram rejected the message due to a MarkdownV2 parse error,
-            // retry as plain text using the original un-converted message.
-            const isParseError = errMsg.includes("can't parse entities");
-            if (isParseError) {
-                try {
-                    await telegram.sendMessage(TELEGRAM_CHAT_ID, rawMessage, undefined, effectiveThreadId);
-                    sentAsPlainText = true;
-                }
-                catch (retryError) {
-                    process.stderr.write(`Failed to send progress message via Telegram (plain fallback): ${errorMessage(retryError)}\n`);
-                    return errorResult("Error: Failed to send progress update to Telegram even without formatting. " +
-                        "Please check the Telegram configuration and try again.");
+                const idleMs = Date.now() - lastOperatorMessageAt;
+                if (idleMs > 30 * 60 * 1000 && effectiveThreadId !== undefined) {
+                    const db = getMemoryDb();
+                    const report = await runIntelligentConsolidation(db, effectiveThreadId);
+                    if (report.episodesProcessed > 0) {
+                        process.stderr.write(`[memory] Consolidation: ${report.episodesProcessed} episodes → ${report.notesCreated} notes\n`);
+                    }
                 }
             }
-            else {
-                process.stderr.write(`Failed to send progress message via Telegram: ${errMsg}\n`);
-                return errorResult("Error: Failed to send progress update to Telegram. " +
-                    "Check the Telegram configuration and try again.");
-            }
-        }
-        // Peek at any messages the operator sent while the agent was working.
-        // Uses non-destructive peek so media is preserved for full delivery
-        // via remote_copilot_wait_for_instructions. Tracks previewed update_ids
-        // to prevent the same messages from appearing on repeated calls.
-        let pendingMessages = [];
-        try {
-            const pendingStored = peekThreadMessages(effectiveThreadId);
-            for (const msg of pendingStored) {
-                if (previewedUpdateIds.has(msg.update_id))
-                    continue;
-                addPreviewedId(msg.update_id);
-                if (msg.message.photo && msg.message.photo.length > 0) {
-                    pendingMessages.push(msg.message.caption
-                        ? `[Photo received — will be downloaded when you call wait_for_instructions] ${msg.message.caption}`
-                        : "[Photo received from operator — will be downloaded when you call wait_for_instructions]");
-                }
-                else if (msg.message.document) {
-                    pendingMessages.push(msg.message.caption
-                        ? `[Document: ${msg.message.document.file_name ?? "file"} — will be downloaded when you call wait_for_instructions] ${msg.message.caption}`
-                        : `[Document received: ${msg.message.document.file_name ?? "file"} — will be downloaded when you call wait_for_instructions]`);
-                }
-                else if (msg.message.voice) {
-                    pendingMessages.push(`[Voice message — ${msg.message.voice.duration}s — will be transcribed on next wait]`);
-                }
-                else if (msg.message.video_note) {
-                    pendingMessages.push(`[Video note — ${msg.message.video_note.duration}s — will be analyzed on next wait]`);
-                }
-                else if (msg.message.text) {
-                    pendingMessages.push(msg.message.text);
+            catch (_) { /* consolidation failure is non-fatal */ }
+            // Periodic memory refresh — re-ground the agent every 5 polls (~2.5h)
+            let memoryRefresh = "";
+            if (callNumber % 5 === 0 && effectiveThreadId !== undefined) {
+                try {
+                    const db = getMemoryDb();
+                    const refresh = assembleCompactRefresh(db, effectiveThreadId);
+                    if (refresh)
+                        memoryRefresh = `\n\n${refresh}`;
                 }
+                catch (_) { /* non-fatal */ }
             }
-        }
-        catch {
-            // Non-fatal: pending messages will still be picked up by the next
-            // remote_copilot_wait_for_instructions call.
-        }
-        const baseStatus = (sentAsPlainText
-            ? "Progress reported successfully (as plain text — formatting could not be applied)."
-            : "Progress reported successfully.") + getReminders(effectiveThreadId);
-        const responseText = pendingMessages.length > 0
-            ? `${baseStatus}\n\n` +
-                `While you were working, the operator sent additional message(s). ` +
-                `Use those messages to steer your active session: ${pendingMessages.join("\n\n")}` +
-                `\n\n⚠️ HINT from operator: Use subagents (runSubagent) for ALL substantial work. ` +
-                `Subagents have full access to ALL MCP tools. You plan and verify; subagents execute.`
-            : baseStatus + getSubagentNudge();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: responseText,
-                },
-            ],
-        };
-    }
-    // ── send_file ─────────────────────────────────────────────────────────────
-    if (name === "send_file") {
-        const typedArgs = (args ?? {});
-        const effectiveThreadId = resolveThreadId(typedArgs);
-        if (effectiveThreadId === undefined) {
-            return errorResult("Error: No active session. Call start_session first, then pass the returned threadId.");
-        }
-        const filePath = typeof typedArgs.filePath === "string" ? typedArgs.filePath.trim() : "";
-        const base64Data = typeof typedArgs.base64 === "string" ? typedArgs.base64 : "";
-        const caption = typeof typedArgs.caption === "string" ? typedArgs.caption : undefined;
-        if (!filePath && !base64Data) {
-            return errorResult("Error: either 'filePath' or 'base64' argument is required for send_file.");
-        }
-        try {
-            let buffer;
-            let filename;
-            if (filePath) {
-                // Read directly from disk — fast, no LLM context overhead.
-                buffer = readFileSync(filePath);
-                filename = typeof typedArgs.filename === "string" && typedArgs.filename.trim()
-                    ? typedArgs.filename.trim()
-                    : basename(filePath);
-            }
-            else {
-                buffer = Buffer.from(base64Data, "base64");
-                filename = typeof typedArgs.filename === "string" && typedArgs.filename.trim()
-                    ? typedArgs.filename.trim()
-                    : "file";
-            }
-            const ext = filename.split(".").pop()?.toLowerCase() ?? "";
-            if (IMAGE_EXTENSIONS.has(ext)) {
-                await telegram.sendPhoto(TELEGRAM_CHAT_ID, buffer, filename, caption, effectiveThreadId);
-            }
-            else {
-                await telegram.sendDocument(TELEGRAM_CHAT_ID, buffer, filename, caption, effectiveThreadId);
-            }
+            // Generate autonomous goals only after extended silence (4+ hours)
+            // Before that, the agent should just keep polling quietly
+            const GOAL_GENERATION_THRESHOLD_MS = 4 * 60 * 60 * 1000; // 4 hours
+            const idleMs = Date.now() - lastOperatorMessageAt;
+            const autonomousGoals = idleMs >= GOAL_GENERATION_THRESHOLD_MS
+                ? formatAutonomousGoals(effectiveThreadId)
+                : "";
             return {
                 content: [
                     {
                         type: "text",
-                        text: `File "${filename}" sent to Telegram successfully.` + getReminders(effectiveThreadId),
+                        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.` +
+                            autonomousGoals +
+                            memoryRefresh +
+                            scheduleHint +
+                            getReminders(effectiveThreadId),
                     },
                 ],
             };
         }
-        catch (err) {
-            process.stderr.write(`Failed to send file via Telegram: ${errorMessage(err)}\n`);
-            return errorResult(`Error: Failed to send file to Telegram: ${errorMessage(err)}`);
-        }
-    }
-    // ── send_voice ──────────────────────────────────────────────────────────
-    if (name === "send_voice") {
-        const typedArgs = (args ?? {});
-        const effectiveThreadId = resolveThreadId(typedArgs);
-        if (effectiveThreadId === undefined) {
-            return errorResult("Error: No active session. Call start_session first, then pass the returned threadId.");
-        }
-        const text = typeof typedArgs.text === "string" ? typedArgs.text.trim() : "";
-        const validVoices = TTS_VOICES;
-        const voice = typeof typedArgs.voice === "string" && validVoices.includes(typedArgs.voice)
-            ? typedArgs.voice
-            : "nova";
-        if (!text) {
-            return errorResult("Error: 'text' argument is required for send_voice.");
-        }
-        if (!OPENAI_API_KEY) {
-            return errorResult("Error: OPENAI_API_KEY is not set. Cannot generate voice.");
-        }
-        if (text.length > OPENAI_TTS_MAX_CHARS) {
-            return errorResult(`Error: text is ${text.length} characters — exceeds OpenAI TTS limit of ${OPENAI_TTS_MAX_CHARS}.`);
-        }
-        try {
-            const audioBuffer = await textToSpeech(text, OPENAI_API_KEY, voice);
-            await telegram.sendVoice(TELEGRAM_CHAT_ID, audioBuffer, effectiveThreadId);
+        // ── report_progress ───────────────────────────────────────────────────────
+        if (name === "report_progress") {
+            const typedArgs = (args ?? {});
+            const effectiveThreadId = resolveThreadId(typedArgs);
+            if (effectiveThreadId === undefined) {
+                return errorResult("Error: No active session. Call start_session first, then pass the returned threadId.");
+            }
+            const rawMessage = typeof typedArgs?.message === "string"
+                ? typedArgs.message
+                : "";
+            if (!rawMessage) {
+                return errorResult("Error: 'message' argument is required for report_progress.");
+            }
+            // Convert standard Markdown to Telegram MarkdownV2.
+            let message;
+            try {
+                message = convertMarkdown(rawMessage);
+            }
+            catch {
+                // Fall back to raw text if Markdown conversion throws.
+                message = rawMessage;
+            }
+            let sentAsPlainText = false;
+            try {
+                await telegram.sendMessage(TELEGRAM_CHAT_ID, message, "MarkdownV2", effectiveThreadId);
+            }
+            catch (error) {
+                const errMsg = errorMessage(error);
+                // If Telegram rejected the message due to a MarkdownV2 parse error,
+                // retry as plain text using the original un-converted message.
+                const isParseError = errMsg.includes("can't parse entities");
+                if (isParseError) {
+                    try {
+                        await telegram.sendMessage(TELEGRAM_CHAT_ID, rawMessage, undefined, effectiveThreadId);
+                        sentAsPlainText = true;
+                    }
+                    catch (retryError) {
+                        process.stderr.write(`Failed to send progress message via Telegram (plain fallback): ${errorMessage(retryError)}\n`);
+                        return errorResult("Error: Failed to send progress update to Telegram even without formatting. " +
+                            "Please check the Telegram configuration and try again.");
+                    }
+                }
+                else {
+                    process.stderr.write(`Failed to send progress message via Telegram: ${errMsg}\n`);
+                    return errorResult("Error: Failed to send progress update to Telegram. " +
+                        "Check the Telegram configuration and try again.");
+                }
+            }
+            // Peek at any messages the operator sent while the agent was working.
+            // Uses non-destructive peek so media is preserved for full delivery
+            // via remote_copilot_wait_for_instructions. Tracks previewed update_ids
+            // to prevent the same messages from appearing on repeated calls.
+            let pendingMessages = [];
+            try {
+                const pendingStored = peekThreadMessages(effectiveThreadId);
+                for (const msg of pendingStored) {
+                    if (previewedUpdateIds.has(msg.update_id))
+                        continue;
+                    addPreviewedId(msg.update_id);
+                    if (msg.message.photo && msg.message.photo.length > 0) {
+                        pendingMessages.push(msg.message.caption
+                            ? `[Photo received — will be downloaded when you call wait_for_instructions] ${msg.message.caption}`
+                            : "[Photo received from operator — will be downloaded when you call wait_for_instructions]");
+                    }
+                    else if (msg.message.document) {
+                        pendingMessages.push(msg.message.caption
+                            ? `[Document: ${msg.message.document.file_name ?? "file"} — will be downloaded when you call wait_for_instructions] ${msg.message.caption}`
+                            : `[Document received: ${msg.message.document.file_name ?? "file"} — will be downloaded when you call wait_for_instructions]`);
+                    }
+                    else if (msg.message.voice) {
+                        pendingMessages.push(`[Voice message — ${msg.message.voice.duration}s — will be transcribed on next wait]`);
+                    }
+                    else if (msg.message.video_note) {
+                        pendingMessages.push(`[Video note — ${msg.message.video_note.duration}s — will be analyzed on next wait]`);
+                    }
+                    else if (msg.message.text) {
+                        pendingMessages.push(msg.message.text);
+                    }
+                }
+            }
+            catch {
+                // Non-fatal: pending messages will still be picked up by the next
+                // remote_copilot_wait_for_instructions call.
+            }
+            const baseStatus = (sentAsPlainText
+                ? "Progress reported successfully (as plain text — formatting could not be applied)."
+                : "Progress reported successfully.") + getReminders(effectiveThreadId);
+            const responseText = pendingMessages.length > 0
+                ? `${baseStatus}\n\n` +
+                    `While you were working, the operator sent additional message(s). ` +
+                    `Use those messages to steer your active session: ${pendingMessages.join("\n\n")}` +
+                    `\n\n⚠️ HINT from operator: Use subagents (runSubagent) for ALL substantial work. ` +
+                    `Subagents have full access to ALL MCP tools. You plan and verify; subagents execute.`
+                : baseStatus + getSubagentNudge();
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Voice message sent to Telegram successfully.` + getReminders(effectiveThreadId),
+                        text: responseText,
                     },
                 ],
             };
         }
-        catch (err) {
-            process.stderr.write(`Failed to send voice via Telegram: ${errorMessage(err)}\n`);
-            return errorResult(`Error: Failed to send voice message: ${errorMessage(err)}`);
+        // ── send_file ─────────────────────────────────────────────────────────────
+        if (name === "send_file") {
+            const typedArgs = (args ?? {});
+            const effectiveThreadId = resolveThreadId(typedArgs);
+            if (effectiveThreadId === undefined) {
+                return errorResult("Error: No active session. Call start_session first, then pass the returned threadId.");
+            }
+            const filePath = typeof typedArgs.filePath === "string" ? typedArgs.filePath.trim() : "";
+            const base64Data = typeof typedArgs.base64 === "string" ? typedArgs.base64 : "";
+            const caption = typeof typedArgs.caption === "string" ? typedArgs.caption : undefined;
+            if (!filePath && !base64Data) {
+                return errorResult("Error: either 'filePath' or 'base64' argument is required for send_file.");
+            }
+            try {
+                let buffer;
+                let filename;
+                if (filePath) {
+                    // Read directly from disk — fast, no LLM context overhead.
+                    buffer = readFileSync(filePath);
+                    filename = typeof typedArgs.filename === "string" && typedArgs.filename.trim()
+                        ? typedArgs.filename.trim()
+                        : basename(filePath);
+                }
+                else {
+                    buffer = Buffer.from(base64Data, "base64");
+                    filename = typeof typedArgs.filename === "string" && typedArgs.filename.trim()
+                        ? typedArgs.filename.trim()
+                        : "file";
+                }
+                const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+                if (IMAGE_EXTENSIONS.has(ext)) {
+                    await telegram.sendPhoto(TELEGRAM_CHAT_ID, buffer, filename, caption, effectiveThreadId);
+                }
+                else {
+                    await telegram.sendDocument(TELEGRAM_CHAT_ID, buffer, filename, caption, effectiveThreadId);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `File "${filename}" sent to Telegram successfully.` + getReminders(effectiveThreadId),
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                process.stderr.write(`Failed to send file via Telegram: ${errorMessage(err)}\n`);
+                return errorResult(`Error: Failed to send file to Telegram: ${errorMessage(err)}`);
+            }
         }
-    }
-    // ── schedule_wake_up ────────────────────────────────────────────────────
-    if (name === "schedule_wake_up") {
-        const typedArgs = (args ?? {});
-        const effectiveThreadId = resolveThreadId(typedArgs);
-        if (effectiveThreadId === undefined) {
-            return errorResult("Error: No active session. Call start_session first.");
+        // ── send_voice ──────────────────────────────────────────────────────────
+        if (name === "send_voice") {
+            const typedArgs = (args ?? {});
+            const effectiveThreadId = resolveThreadId(typedArgs);
+            if (effectiveThreadId === undefined) {
+                return errorResult("Error: No active session. Call start_session first, then pass the returned threadId.");
+            }
+            const text = typeof typedArgs.text === "string" ? typedArgs.text.trim() : "";
+            const validVoices = TTS_VOICES;
+            const voice = typeof typedArgs.voice === "string" && validVoices.includes(typedArgs.voice)
+                ? typedArgs.voice
+                : "nova";
+            if (!text) {
+                return errorResult("Error: 'text' argument is required for send_voice.");
+            }
+            if (!OPENAI_API_KEY) {
+                return errorResult("Error: OPENAI_API_KEY is not set. Cannot generate voice.");
+            }
+            if (text.length > OPENAI_TTS_MAX_CHARS) {
+                return errorResult(`Error: text is ${text.length} characters — exceeds OpenAI TTS limit of ${OPENAI_TTS_MAX_CHARS}.`);
+            }
+            try {
+                const audioBuffer = await textToSpeech(text, OPENAI_API_KEY, voice);
+                await telegram.sendVoice(TELEGRAM_CHAT_ID, audioBuffer, effectiveThreadId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Voice message sent to Telegram successfully.` + getReminders(effectiveThreadId),
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                process.stderr.write(`Failed to send voice via Telegram: ${errorMessage(err)}\n`);
+                return errorResult(`Error: Failed to send voice message: ${errorMessage(err)}`);
+            }
         }
-        const action = typeof typedArgs.action === "string" ? typedArgs.action : "add";
-        // --- List ---
-        if (action === "list") {
-            const tasks = listSchedules(effectiveThreadId);
-            if (tasks.length === 0) {
+        // ── schedule_wake_up ────────────────────────────────────────────────────
+        if (name === "schedule_wake_up") {
+            const typedArgs = (args ?? {});
+            const effectiveThreadId = resolveThreadId(typedArgs);
+            if (effectiveThreadId === undefined) {
+                return errorResult("Error: No active session. Call start_session first.");
+            }
+            const action = typeof typedArgs.action === "string" ? typedArgs.action : "add";
+            // --- List ---
+            if (action === "list") {
+                const tasks = listSchedules(effectiveThreadId);
+                if (tasks.length === 0) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: "No scheduled tasks for this thread." + getReminders(effectiveThreadId),
+                            }],
+                    };
+                }
+                const lines = tasks.map(t => {
+                    const trigger = t.cron ? `cron: ${t.cron}` : t.runAt ? `at: ${t.runAt}` : `idle: ${t.afterIdleMinutes}min`;
+                    const lastFired = t.lastFiredAt ? ` (last: ${t.lastFiredAt})` : "";
+                    return `- **${t.label}** [${t.id}] — ${trigger}${lastFired}\n  Prompt: ${t.prompt.slice(0, 100)}${t.prompt.length > 100 ? "…" : ""}`;
+                });
                 return {
                     content: [{
                             type: "text",
-                            text: "No scheduled tasks for this thread." + getReminders(effectiveThreadId),
+                            text: `**Scheduled tasks (${tasks.length}):**\n\n${lines.join("\n\n")}` + getReminders(effectiveThreadId),
                         }],
                 };
             }
-            const lines = tasks.map(t => {
-                const trigger = t.cron ? `cron: ${t.cron}` : t.runAt ? `at: ${t.runAt}` : `idle: ${t.afterIdleMinutes}min`;
-                const lastFired = t.lastFiredAt ? ` (last: ${t.lastFiredAt})` : "";
-                return `- **${t.label}** [${t.id}] — ${trigger}${lastFired}\n  Prompt: ${t.prompt.slice(0, 100)}${t.prompt.length > 100 ? "…" : ""}`;
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: `**Scheduled tasks (${tasks.length}):**\n\n${lines.join("\n\n")}` + getReminders(effectiveThreadId),
-                    }],
-            };
-        }
-        // --- Remove ---
-        if (action === "remove") {
-            const taskId = typeof typedArgs.taskId === "string" ? typedArgs.taskId : "";
-            if (!taskId) {
-                return errorResult("Error: 'taskId' is required for remove action. Use action: 'list' to see task IDs.");
+            // --- Remove ---
+            if (action === "remove") {
+                const taskId = typeof typedArgs.taskId === "string" ? typedArgs.taskId : "";
+                if (!taskId) {
+                    return errorResult("Error: 'taskId' is required for remove action. Use action: 'list' to see task IDs.");
+                }
+                const removed = removeSchedule(effectiveThreadId, taskId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: removed
+                                ? `Task ${taskId} removed.` + getReminders(effectiveThreadId)
+                                : `Task ${taskId} not found.` + getReminders(effectiveThreadId),
+                        }],
+                };
+            }
+            // --- Add ---
+            const label = typeof typedArgs.label === "string" ? typedArgs.label : "unnamed task";
+            const prompt = typeof typedArgs.prompt === "string" ? typedArgs.prompt : "";
+            if (!prompt) {
+                return errorResult("Error: 'prompt' is required — this is the text that will be injected when the task fires.");
             }
-            const removed = removeSchedule(effectiveThreadId, taskId);
+            const runAt = typeof typedArgs.runAt === "string" ? typedArgs.runAt : undefined;
+            const cron = typeof typedArgs.cron === "string" ? typedArgs.cron : undefined;
+            const afterIdleMinutes = typeof typedArgs.afterIdleMinutes === "number" ? typedArgs.afterIdleMinutes : undefined;
+            if (cron && cron.trim().split(/\s+/).length !== 5) {
+                return errorResult("Error: Invalid cron expression. Must be exactly 5 space-separated fields: minute hour day-of-month month day-of-week. " +
+                    "Example: '0 9 * * *' (daily at 9am). Only *, numbers, and comma-separated lists are supported.");
+            }
+            if (!runAt && !cron && afterIdleMinutes == null) {
+                return errorResult("Error: Specify at least one trigger: 'runAt' (ISO timestamp), 'cron' (5-field), or 'afterIdleMinutes' (number).");
+            }
+            const task = {
+                id: generateTaskId(),
+                threadId: effectiveThreadId,
+                prompt,
+                label,
+                runAt,
+                cron,
+                afterIdleMinutes,
+                oneShot: runAt != null && !cron,
+                createdAt: new Date().toISOString(),
+            };
+            addSchedule(task);
+            const triggerDesc = cron
+                ? `recurring (cron: ${cron})`
+                : runAt
+                    ? `one-shot at ${runAt}`
+                    : `after ${afterIdleMinutes}min of operator silence`;
             return {
                 content: [{
                         type: "text",
-                        text: removed
-                            ? `Task ${taskId} removed.` + getReminders(effectiveThreadId)
-                            : `Task ${taskId} not found.` + getReminders(effectiveThreadId),
+                        text: `✅ Scheduled: **${label}** [${task.id}]\nTrigger: ${triggerDesc}\nPrompt: ${prompt}` +
+                            getReminders(effectiveThreadId),
                     }],
             };
         }
-        // --- Add ---
-        const label = typeof typedArgs.label === "string" ? typedArgs.label : "unnamed task";
-        const prompt = typeof typedArgs.prompt === "string" ? typedArgs.prompt : "";
-        if (!prompt) {
-            return errorResult("Error: 'prompt' is required — this is the text that will be injected when the task fires.");
-        }
-        const runAt = typeof typedArgs.runAt === "string" ? typedArgs.runAt : undefined;
-        const cron = typeof typedArgs.cron === "string" ? typedArgs.cron : undefined;
-        const afterIdleMinutes = typeof typedArgs.afterIdleMinutes === "number" ? typedArgs.afterIdleMinutes : undefined;
-        if (cron && cron.trim().split(/\s+/).length !== 5) {
-            return errorResult("Error: Invalid cron expression. Must be exactly 5 space-separated fields: minute hour day-of-month month day-of-week. " +
-                "Example: '0 9 * * *' (daily at 9am). Only *, numbers, and comma-separated lists are supported.");
-        }
-        if (!runAt && !cron && afterIdleMinutes == null) {
-            return errorResult("Error: Specify at least one trigger: 'runAt' (ISO timestamp), 'cron' (5-field), or 'afterIdleMinutes' (number).");
-        }
-        const task = {
-            id: generateTaskId(),
-            threadId: effectiveThreadId,
-            prompt,
-            label,
-            runAt,
-            cron,
-            afterIdleMinutes,
-            oneShot: runAt != null && !cron,
-            createdAt: new Date().toISOString(),
-        };
-        addSchedule(task);
-        const triggerDesc = cron
-            ? `recurring (cron: ${cron})`
-            : runAt
-                ? `one-shot at ${runAt}`
-                : `after ${afterIdleMinutes}min of operator silence`;
-        return {
-            content: [{
-                    type: "text",
-                    text: `✅ Scheduled: **${label}** [${task.id}]\nTrigger: ${triggerDesc}\nPrompt: ${prompt}` +
-                        getReminders(effectiveThreadId),
-                }],
-        };
-    }
-    // ── memory_bootstrap ────────────────────────────────────────────────────
-    if (name === "memory_bootstrap") {
-        const threadId = resolveThreadId(args);
-        if (threadId === undefined) {
-            return { content: [{ type: "text", text: "Error: No active thread. Call start_session first." + getReminders() }] };
-        }
-        try {
-            const db = getMemoryDb();
-            const briefing = assembleBootstrap(db, threadId);
-            return {
-                content: [{ type: "text", text: `## Memory Briefing\n\n${briefing}` + getReminders(threadId) }],
-            };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Memory bootstrap error: ${errorMessage(err)}` + getReminders(threadId) }] };
-        }
-    }
-    // ── memory_search ───────────────────────────────────────────────────────
-    if (name === "memory_search") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        const query = String(typedArgs.query ?? "");
-        if (!query) {
-            return { content: [{ type: "text", text: "Error: query is required." + getReminders(threadId) }] };
+        // ── memory_bootstrap ────────────────────────────────────────────────────
+        if (name === "memory_bootstrap") {
+            const threadId = resolveThreadId(args);
+            if (threadId === undefined) {
+                return { content: [{ type: "text", text: "Error: No active thread. Call start_session first." + getReminders() }] };
+            }
+            try {
+                const db = getMemoryDb();
+                const briefing = assembleBootstrap(db, threadId);
+                return {
+                    content: [{ type: "text", text: `## Memory Briefing\n\n${briefing}` + getReminders(threadId) }],
+                };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Memory bootstrap error: ${errorMessage(err)}` + getReminders(threadId) }] };
+            }
         }
-        try {
-            const db = getMemoryDb();
-            const layers = typedArgs.layers ?? ["episodic", "semantic", "procedural"];
-            const types = typedArgs.types;
-            const results = [];
-            if (layers.includes("semantic")) {
-                const notes = searchSemanticNotes(db, query, { types, maxResults: 10 });
-                if (notes.length > 0) {
-                    results.push("### Semantic Memory");
-                    for (const n of notes) {
-                        results.push(`- **[${n.type}]** ${n.content} _(conf: ${n.confidence}, id: ${n.noteId})_`);
+        // ── memory_search ───────────────────────────────────────────────────────
+        if (name === "memory_search") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            const query = String(typedArgs.query ?? "");
+            if (!query) {
+                return { content: [{ type: "text", text: "Error: query is required." + getReminders(threadId) }] };
+            }
+            try {
+                const db = getMemoryDb();
+                const layers = typedArgs.layers ?? ["episodic", "semantic", "procedural"];
+                const types = typedArgs.types;
+                const results = [];
+                if (layers.includes("semantic")) {
+                    const notes = searchSemanticNotes(db, query, { types, maxResults: 10 });
+                    if (notes.length > 0) {
+                        results.push("### Semantic Memory");
+                        for (const n of notes) {
+                            results.push(`- **[${n.type}]** ${n.content} _(conf: ${n.confidence}, id: ${n.noteId})_`);
+                        }
                     }
                 }
-            }
-            if (layers.includes("procedural")) {
-                const procs = searchProcedures(db, query, 5);
-                if (procs.length > 0) {
-                    results.push("### Procedural Memory");
-                    for (const p of procs) {
-                        results.push(`- **${p.name}** (${p.type}): ${p.description} _(success: ${Math.round(p.successRate * 100)}%, id: ${p.procedureId})_`);
+                if (layers.includes("procedural")) {
+                    const procs = searchProcedures(db, query, 5);
+                    if (procs.length > 0) {
+                        results.push("### Procedural Memory");
+                        for (const p of procs) {
+                            results.push(`- **${p.name}** (${p.type}): ${p.description} _(success: ${Math.round(p.successRate * 100)}%, id: ${p.procedureId})_`);
+                        }
                     }
                 }
-            }
-            if (layers.includes("episodic") && threadId !== undefined) {
-                const episodes = getRecentEpisodes(db, threadId, 10);
-                const filtered = episodes.filter(ep => {
-                    const content = JSON.stringify(ep.content).toLowerCase();
-                    return query.toLowerCase().split(/\s+/).some(word => content.includes(word));
-                });
-                if (filtered.length > 0) {
-                    results.push("### Episodic Memory");
-                    for (const ep of filtered.slice(0, 5)) {
-                        const summary = typeof ep.content === "object" && ep.content !== null
-                            ? ep.content.text ?? JSON.stringify(ep.content).slice(0, 200)
-                            : String(ep.content).slice(0, 200);
-                        results.push(`- [${ep.modality}] ${summary} _(${ep.timestamp}, id: ${ep.episodeId})_`);
+                if (layers.includes("episodic") && threadId !== undefined) {
+                    const episodes = getRecentEpisodes(db, threadId, 10);
+                    const filtered = episodes.filter(ep => {
+                        const content = JSON.stringify(ep.content).toLowerCase();
+                        return query.toLowerCase().split(/\s+/).some(word => content.includes(word));
+                    });
+                    if (filtered.length > 0) {
+                        results.push("### Episodic Memory");
+                        for (const ep of filtered.slice(0, 5)) {
+                            const summary = typeof ep.content === "object" && ep.content !== null
+                                ? ep.content.text ?? JSON.stringify(ep.content).slice(0, 200)
+                                : String(ep.content).slice(0, 200);
+                            results.push(`- [${ep.modality}] ${summary} _(${ep.timestamp}, id: ${ep.episodeId})_`);
+                        }
                     }
                 }
+                const text = results.length > 0
+                    ? results.join("\n")
+                    : `No memories found for "${query}".`;
+                return { content: [{ type: "text", text: text + getReminders(threadId) }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Memory search error: ${errorMessage(err)}` + getReminders(threadId) }] };
             }
-            const text = results.length > 0
-                ? results.join("\n")
-                : `No memories found for "${query}".`;
-            return { content: [{ type: "text", text: text + getReminders(threadId) }] };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Memory search error: ${errorMessage(err)}` + getReminders(threadId) }] };
-        }
-    }
-    // ── memory_save ─────────────────────────────────────────────────────────
-    if (name === "memory_save") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        const VALID_TYPES = ["fact", "preference", "pattern", "entity", "relationship"];
-        const noteType = String(typedArgs.type ?? "fact");
-        if (!VALID_TYPES.includes(noteType)) {
-            return errorResult(`Invalid type "${noteType}". Must be one of: ${VALID_TYPES.join(", ")}`);
-        }
-        try {
-            const db = getMemoryDb();
-            const noteId = saveSemanticNote(db, {
-                type: noteType,
-                content: String(typedArgs.content ?? ""),
-                keywords: typedArgs.keywords ?? [],
-                confidence: typeof typedArgs.confidence === "number" ? typedArgs.confidence : 0.8,
-            });
-            return {
-                content: [{ type: "text", text: `Saved semantic note: ${noteId}` + getReminders(threadId) + getSubagentNudge() }],
-            };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Memory save error: ${errorMessage(err)}` + getReminders(threadId) }] };
         }
-    }
-    // ── memory_save_procedure ───────────────────────────────────────────────
-    if (name === "memory_save_procedure") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        try {
-            const db = getMemoryDb();
-            const existingId = typedArgs.procedureId;
-            if (existingId) {
-                updateProcedure(db, existingId, {
-                    description: typedArgs.description,
-                    steps: typedArgs.steps,
-                    triggerConditions: typedArgs.triggerConditions,
+        // ── memory_save ─────────────────────────────────────────────────────────
+        if (name === "memory_save") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            const VALID_TYPES = ["fact", "preference", "pattern", "entity", "relationship"];
+            const noteType = String(typedArgs.type ?? "fact");
+            if (!VALID_TYPES.includes(noteType)) {
+                return errorResult(`Invalid type "${noteType}". Must be one of: ${VALID_TYPES.join(", ")}`);
+            }
+            try {
+                const db = getMemoryDb();
+                const noteId = saveSemanticNote(db, {
+                    type: noteType,
+                    content: String(typedArgs.content ?? ""),
+                    keywords: typedArgs.keywords ?? [],
+                    confidence: typeof typedArgs.confidence === "number" ? typedArgs.confidence : 0.8,
                 });
                 return {
-                    content: [{ type: "text", text: `Updated procedure: ${existingId}` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `Saved semantic note: ${noteId}` + getReminders(threadId) + getSubagentNudge() }],
                 };
             }
-            const procId = saveProcedure(db, {
-                name: String(typedArgs.name ?? ""),
-                type: String(typedArgs.type ?? "workflow"),
-                description: String(typedArgs.description ?? ""),
-                steps: typedArgs.steps,
-                triggerConditions: typedArgs.triggerConditions,
-            });
-            return {
-                content: [{ type: "text", text: `Saved procedure: ${procId}` + getReminders(threadId) }],
-            };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Procedure save error: ${errorMessage(err)}` + getReminders(threadId) }] };
+            catch (err) {
+                return { content: [{ type: "text", text: `Memory save error: ${errorMessage(err)}` + getReminders(threadId) }] };
+            }
         }
-    }
-    // ── memory_update ───────────────────────────────────────────────────────
-    if (name === "memory_update") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        try {
-            const db = getMemoryDb();
-            const memId = String(typedArgs.memoryId ?? "");
-            const action = String(typedArgs.action ?? "update");
-            const reason = String(typedArgs.reason ?? "");
-            if (action === "supersede" && memId.startsWith("sn_")) {
-                const origRow = db.prepare("SELECT type, keywords FROM semantic_notes WHERE note_id = ?").get(memId);
-                if (!origRow) {
-                    return errorResult(`Note ${memId} not found — cannot supersede a non-existent note.`);
+        // ── memory_save_procedure ───────────────────────────────────────────────
+        if (name === "memory_save_procedure") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            try {
+                const db = getMemoryDb();
+                const existingId = typedArgs.procedureId;
+                if (existingId) {
+                    updateProcedure(db, existingId, {
+                        description: typedArgs.description,
+                        steps: typedArgs.steps,
+                        triggerConditions: typedArgs.triggerConditions,
+                    });
+                    return {
+                        content: [{ type: "text", text: `Updated procedure: ${existingId}` + getReminders(threadId) }],
+                    };
                 }
-                const newId = supersedeNote(db, memId, {
-                    type: origRow.type,
-                    content: String(typedArgs.newContent ?? ""),
-                    keywords: origRow.keywords ? JSON.parse(origRow.keywords) : [],
-                    confidence: typeof typedArgs.newConfidence === "number" ? typedArgs.newConfidence : 0.8,
+                const procId = saveProcedure(db, {
+                    name: String(typedArgs.name ?? ""),
+                    type: String(typedArgs.type ?? "workflow"),
+                    description: String(typedArgs.description ?? ""),
+                    steps: typedArgs.steps,
+                    triggerConditions: typedArgs.triggerConditions,
                 });
                 return {
-                    content: [{ type: "text", text: `Superseded ${memId} → ${newId} (reason: ${reason})` + getReminders(threadId) }],
-                };
-            }
-            if (memId.startsWith("sn_")) {
-                const updates = {};
-                if (typedArgs.newContent)
-                    updates.content = String(typedArgs.newContent);
-                if (typeof typedArgs.newConfidence === "number")
-                    updates.confidence = typedArgs.newConfidence;
-                updateSemanticNote(db, memId, updates);
-                return {
-                    content: [{ type: "text", text: `Updated note ${memId} (reason: ${reason})` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `Saved procedure: ${procId}` + getReminders(threadId) }],
                 };
             }
-            if (memId.startsWith("pr_")) {
-                const updates = {};
-                if (typedArgs.newContent)
-                    updates.description = String(typedArgs.newContent);
-                if (typeof typedArgs.newConfidence === "number")
-                    updates.confidence = typedArgs.newConfidence;
-                updateProcedure(db, memId, updates);
-                return {
-                    content: [{ type: "text", text: `Updated procedure ${memId} (reason: ${reason})` + getReminders(threadId) }],
-                };
+            catch (err) {
+                return { content: [{ type: "text", text: `Procedure save error: ${errorMessage(err)}` + getReminders(threadId) }] };
             }
-            return { content: [{ type: "text", text: `Unknown memory ID format: ${memId}` + getReminders(threadId) }] };
         }
-        catch (err) {
-            return { content: [{ type: "text", text: `Memory update error: ${errorMessage(err)}` + getReminders(threadId) }] };
-        }
-    }
-    // ── memory_consolidate ──────────────────────────────────────────────────
-    if (name === "memory_consolidate") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        if (threadId === undefined) {
-            return { content: [{ type: "text", text: "Error: No active thread." + getReminders() }] };
+        // ── memory_update ───────────────────────────────────────────────────────
+        if (name === "memory_update") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            try {
+                const db = getMemoryDb();
+                const memId = String(typedArgs.memoryId ?? "");
+                const action = String(typedArgs.action ?? "update");
+                const reason = String(typedArgs.reason ?? "");
+                if (action === "supersede" && memId.startsWith("sn_")) {
+                    const origRow = db.prepare("SELECT type, keywords FROM semantic_notes WHERE note_id = ?").get(memId);
+                    if (!origRow) {
+                        return errorResult(`Note ${memId} not found — cannot supersede a non-existent note.`);
+                    }
+                    const newId = supersedeNote(db, memId, {
+                        type: origRow.type,
+                        content: String(typedArgs.newContent ?? ""),
+                        keywords: origRow.keywords ? JSON.parse(origRow.keywords) : [],
+                        confidence: typeof typedArgs.newConfidence === "number" ? typedArgs.newConfidence : 0.8,
+                    });
+                    return {
+                        content: [{ type: "text", text: `Superseded ${memId} → ${newId} (reason: ${reason})` + getReminders(threadId) }],
+                    };
+                }
+                if (memId.startsWith("sn_")) {
+                    const updates = {};
+                    if (typedArgs.newContent)
+                        updates.content = String(typedArgs.newContent);
+                    if (typeof typedArgs.newConfidence === "number")
+                        updates.confidence = typedArgs.newConfidence;
+                    updateSemanticNote(db, memId, updates);
+                    return {
+                        content: [{ type: "text", text: `Updated note ${memId} (reason: ${reason})` + getReminders(threadId) }],
+                    };
+                }
+                if (memId.startsWith("pr_")) {
+                    const updates = {};
+                    if (typedArgs.newContent)
+                        updates.description = String(typedArgs.newContent);
+                    if (typeof typedArgs.newConfidence === "number")
+                        updates.confidence = typedArgs.newConfidence;
+                    updateProcedure(db, memId, updates);
+                    return {
+                        content: [{ type: "text", text: `Updated procedure ${memId} (reason: ${reason})` + getReminders(threadId) }],
+                    };
+                }
+                return { content: [{ type: "text", text: `Unknown memory ID format: ${memId}` + getReminders(threadId) }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Memory update error: ${errorMessage(err)}` + getReminders(threadId) }] };
+            }
         }
-        try {
-            const db = getMemoryDb();
-            const report = await runIntelligentConsolidation(db, threadId);
-            if (report.episodesProcessed === 0) {
-                return {
-                    content: [{ type: "text", text: "No unconsolidated episodes. Memory is up to date." + getReminders(threadId) }],
-                };
+        // ── memory_consolidate ──────────────────────────────────────────────────
+        if (name === "memory_consolidate") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            if (threadId === undefined) {
+                return { content: [{ type: "text", text: "Error: No active thread." + getReminders() }] };
             }
-            const reportLines = [
-                "## Consolidation Report",
-                `- Episodes processed: ${report.episodesProcessed}`,
-                `- Notes created: ${report.notesCreated}`,
-                `- Duration: ${report.durationMs}ms`,
-            ];
-            if (report.details.length > 0) {
-                reportLines.push("", "### Extracted Knowledge");
-                for (const d of report.details) {
-                    reportLines.push(`- ${d}`);
+            try {
+                const db = getMemoryDb();
+                const report = await runIntelligentConsolidation(db, threadId);
+                if (report.episodesProcessed === 0) {
+                    return {
+                        content: [{ type: "text", text: "No unconsolidated episodes. Memory is up to date." + getReminders(threadId) }],
+                    };
+                }
+                const reportLines = [
+                    "## Consolidation Report",
+                    `- Episodes processed: ${report.episodesProcessed}`,
+                    `- Notes created: ${report.notesCreated}`,
+                    `- Duration: ${report.durationMs}ms`,
+                ];
+                if (report.details.length > 0) {
+                    reportLines.push("", "### Extracted Knowledge");
+                    for (const d of report.details) {
+                        reportLines.push(`- ${d}`);
+                    }
                 }
+                return { content: [{ type: "text", text: reportLines.join("\n") + getReminders(threadId) }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Consolidation error: ${errorMessage(err)}` + getReminders(threadId) }] };
             }
-            return { content: [{ type: "text", text: reportLines.join("\n") + getReminders(threadId) }] };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Consolidation error: ${errorMessage(err)}` + getReminders(threadId) }] };
-        }
-    }
-    // ── memory_status ───────────────────────────────────────────────────────
-    if (name === "memory_status") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        if (threadId === undefined) {
-            return { content: [{ type: "text", text: "Error: No active thread." + getReminders() }] };
         }
-        try {
-            const db = getMemoryDb();
-            const status = getMemoryStatus(db, threadId);
-            const topics = getTopicIndex(db);
-            const lines = [
-                "## Memory Status",
-                `- Episodes: ${status.totalEpisodes} (${status.unconsolidatedEpisodes} unconsolidated)`,
-                `- Semantic notes: ${status.totalSemanticNotes}`,
-                `- Procedures: ${status.totalProcedures}`,
-                `- Voice signatures: ${status.totalVoiceSignatures}`,
-                `- Last consolidation: ${status.lastConsolidation ?? "never"}`,
-                `- DB size: ${(status.dbSizeBytes / 1024).toFixed(1)} KB`,
-            ];
-            if (topics.length > 0) {
-                lines.push("", "**Topics:**");
-                for (const t of topics.slice(0, 15)) {
-                    lines.push(`- ${t.topic} (${t.semanticCount} notes, ${t.proceduralCount} procs, conf: ${t.avgConfidence.toFixed(2)})`);
+        // ── memory_status ───────────────────────────────────────────────────────
+        if (name === "memory_status") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            if (threadId === undefined) {
+                return { content: [{ type: "text", text: "Error: No active thread." + getReminders() }] };
+            }
+            try {
+                const db = getMemoryDb();
+                const status = getMemoryStatus(db, threadId);
+                const topics = getTopicIndex(db);
+                const lines = [
+                    "## Memory Status",
+                    `- Episodes: ${status.totalEpisodes} (${status.unconsolidatedEpisodes} unconsolidated)`,
+                    `- Semantic notes: ${status.totalSemanticNotes}`,
+                    `- Procedures: ${status.totalProcedures}`,
+                    `- Voice signatures: ${status.totalVoiceSignatures}`,
+                    `- Last consolidation: ${status.lastConsolidation ?? "never"}`,
+                    `- DB size: ${(status.dbSizeBytes / 1024).toFixed(1)} KB`,
+                ];
+                if (topics.length > 0) {
+                    lines.push("", "**Topics:**");
+                    for (const t of topics.slice(0, 15)) {
+                        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) }] };
+            }
+            catch (err) {
+                return { content: [{ type: "text", text: `Memory status error: ${errorMessage(err)}` + getReminders(threadId) }] };
             }
-            return { content: [{ type: "text", text: lines.join("\n") + getReminders(threadId) }] };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Memory status error: ${errorMessage(err)}` + getReminders(threadId) }] };
         }
-    }
-    // ── memory_forget ───────────────────────────────────────────────────────
-    if (name === "memory_forget") {
-        const typedArgs = (args ?? {});
-        const threadId = resolveThreadId(typedArgs);
-        try {
-            const db = getMemoryDb();
-            const memId = String(typedArgs.memoryId ?? "");
-            const reason = String(typedArgs.reason ?? "");
-            const result = forgetMemory(db, memId, reason);
-            if (!result.deleted) {
+        // ── memory_forget ───────────────────────────────────────────────────────
+        if (name === "memory_forget") {
+            const typedArgs = (args ?? {});
+            const threadId = resolveThreadId(typedArgs);
+            try {
+                const db = getMemoryDb();
+                const memId = String(typedArgs.memoryId ?? "");
+                const reason = String(typedArgs.reason ?? "");
+                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) }],
+                    };
+                }
                 return {
-                    content: [{ type: "text", text: `Memory ${memId} not found (layer: ${result.layer}). Nothing was deleted.` + getReminders(threadId) }],
+                    content: [{ type: "text", text: `Forgot ${result.layer} memory ${memId} (reason: ${reason})` + getReminders(threadId) }],
                 };
             }
-            return {
-                content: [{ type: "text", text: `Forgot ${result.layer} memory ${memId} (reason: ${reason})` + getReminders(threadId) }],
-            };
-        }
-        catch (err) {
-            return { content: [{ type: "text", text: `Memory forget error: ${errorMessage(err)}` + getReminders(threadId) }] };
+            catch (err) {
+                return { content: [{ type: "text", text: `Memory forget error: ${errorMessage(err)}` + getReminders(threadId) }] };
+            }
         }
-    }
-    // Unknown tool
-    return errorResult(`Unknown tool: ${name}`);
-});
+        // Unknown tool
+        return errorResult(`Unknown tool: ${name}`);
+    });
+    return srv;
+}
 // ---------------------------------------------------------------------------
 // Start the server
 // ---------------------------------------------------------------------------
@@ -2098,10 +2109,52 @@ if (httpPort) {
                     if (sid)
                         transports.delete(sid);
                 };
-                await server.connect(transport);
+                // Create a fresh Server per HTTP session — a single Server can only
+                // connect to one transport, so concurrent clients each need their own.
+                const sessionServer = createMcpServer();
+                await sessionServer.connect(transport);
                 await transport.handleRequest(req, res, body);
                 return;
             }
+            // ── Session recovery ────────────────────────────────────────────────
+            // When the server restarts, old session IDs become invalid. Most MCP
+            // clients (VS Code, Claude, Codex) don't re-initialize on 404 despite
+            // the spec requiring it. Instead of breaking, we transparently adopt
+            // the unknown session: create a new transport+server with the same
+            // session ID, mark it as initialized, and handle the request normally.
+            // The client never knows the restart happened.
+            if (sessionId && !transports.has(sessionId)) {
+                process.stderr.write(`[http] Session recovery: adopting session ${sessionId.slice(0, 8)}...\n`);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => sessionId,
+                    onsessioninitialized: (sid) => {
+                        transports.set(sid, transport);
+                    },
+                });
+                transport.onclose = () => {
+                    const sid = transport.sessionId;
+                    if (sid)
+                        transports.delete(sid);
+                };
+                const sessionServer = createMcpServer();
+                await sessionServer.connect(transport);
+                if (isInitializeRequest(body)) {
+                    // Client is properly re-initializing — let the normal flow handle it
+                    await transport.handleRequest(req, res, body);
+                }
+                else {
+                    // Client sent a tool call with the old session ID.
+                    // Force-adopt: set the session ID and mark as initialized so
+                    // validateSession() passes without an initialize handshake.
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const innerTransport = transport._webStandardTransport;
+                    innerTransport.sessionId = sessionId;
+                    innerTransport._initialized = true;
+                    transports.set(sessionId, transport);
+                    await transport.handleRequest(req, res, body);
+                }
+                return;
+            }
             res.writeHead(400, { "Content-Type": "application/json" });
             res.end(JSON.stringify({
                 jsonrpc: "2.0",
@@ -2111,6 +2164,30 @@ if (httpPort) {
             return;
         }
         if (req.method === "GET") {
+            // Session recovery for GET (SSE stream reconnection after server restart)
+            if (sessionId && !transports.has(sessionId)) {
+                process.stderr.write(`[http] SSE session recovery: adopting session ${sessionId.slice(0, 8)}...\n`);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => sessionId,
+                    onsessioninitialized: (sid) => {
+                        transports.set(sid, transport);
+                    },
+                });
+                transport.onclose = () => {
+                    const sid = transport.sessionId;
+                    if (sid)
+                        transports.delete(sid);
+                };
+                const sessionServer = createMcpServer();
+                await sessionServer.connect(transport);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const innerTransport = transport._webStandardTransport;
+                innerTransport.sessionId = sessionId;
+                innerTransport._initialized = true;
+                transports.set(sessionId, transport);
+                await transport.handleRequest(req, res);
+                return;
+            }
             if (!sessionId || !transports.has(sessionId)) {
                 res.writeHead(400, { "Content-Type": "text/plain" });
                 res.end("Invalid or missing session ID");
@@ -2149,6 +2226,7 @@ if (httpPort) {
 else {
     // ── stdio transport (default) ───────────────────────────────────────────
     const transport = new StdioServerTransport();
+    const server = createMcpServer();
     await server.connect(transport);
     process.stderr.write("Remote Copilot MCP server running on stdio.\n");
     // Close DB on exit for stdio mode too