dis-gravity 1.1.0 → 1.2.5

package/mcp/server.js

@@ -0,0 +1,2174 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Dis-Gravity Model Context Protocol (MCP) Server
+ * Stdio JSON-RPC 2.0 server for Claude Desktop, Claude Code, and MCP-compliant AI desktop clients.
+ * Packaged as .mcpb (MCP Bundle) and .dxt (Desktop Extension).
+ *
+ * Features:
+ * - Zero external dependencies: Native Node 18+/24 Discord Gateway v10 WebSocket + REST + Multipart client
+ * - Concurrent Discord Gateway WebSocket execution in Node event loop
+ * - Full Discord slash commands (/sh, /diff, /cat, /tree, /info, /status, /help)
+ * - 2x Retina PNG Table Card rendering via OS headless browser with zero native dependencies
+ * - Bi-directional AI agent bridge: MCP Tools + MCP Resources
+ * - Fail-closed whitelist security (isUserAllowed)
+ * - Path traversal protection on workspace file inspection
+ */
+
+const readline = require('readline');
+const fs = require('fs');
+const https = require('https');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const {
+  loadConfig,
+  saveConfig,
+  looksLikeBotToken,
+  inspectApplication,
+  ensureMessageContentIntent,
+  listUserGuilds,
+  waitForGuildJoin,
+  findOrCreateChannel,
+  sendWelcomeMessage,
+  openBrowser,
+  buildInviteUrl,
+  discordRequest,
+  discordMultipartRequest
+} = require('../lib/onboarding');
+const {
+  isUserAllowed,
+  executeShellCommand,
+  findHeadlessBrowser,
+  escapeHtml,
+  buildTableHtml,
+  renderTableToPng,
+  parseMarkdownTable,
+  safeResolveWorkspacePath,
+  readWorkspaceFile,
+  listWorkspaceTree,
+  getGitStatusAndDiff,
+  getSystemHealth,
+  parseScheduleSpec,
+  parseScheduleCommandInput,
+  TaskScheduler,
+  ThreadWorkspaceManager,
+  isAudioAttachment,
+  transcribeAudioFile,
+  buildDiffHtml,
+  renderDiffToPng,
+  detectDestructiveKeywords,
+  captureWorkspaceCheckpoint,
+  restoreWorkspaceCheckpoint
+} = require('../lib/core');
+
+const SERVER_VERSION = '1.2.3';
+const SUPPORTED_PROTOCOL_VERSIONS = [
+  '2025-11-25',
+  '2025-06-18',
+  '2025-03-26',
+  '2024-11-05',
+  '2024-10-07'
+];
+
+// All diagnostic logging MUST go to stderr to keep stdout clean for JSON-RPC messages
+const log = (...args) => console.error('[Dis-Gravity MCP]', ...args);
+
+/**
+ * Sanitizes environment variable strings and strips unresolved ${user_config.*} placeholders
+ */
+function cleanEnvValue(val) {
+  if (!val || typeof val !== 'string') return '';
+  const trimmed = val.trim().replace(/^['"]|['"]$/g, '').trim();
+  if (!trimmed || trimmed === 'undefined' || trimmed === 'null') return '';
+  if (/^\$\{[^}]*\}$/.test(trimmed)) return '';
+  return trimmed;
+}
+
+function cleanBotToken(val) {
+  return cleanEnvValue(val).replace(/^Bot\s+/i, '').trim();
+}
+
+function cleanChannelId(val) {
+  return cleanEnvValue(val).replace(/^[<#]+|[>]+$/g, '').trim();
+}
+
+function parseAllowedUsersList(rawEnv, savedList) {
+  const cleanedEnv = cleanEnvValue(rawEnv);
+  if (cleanedEnv) {
+    return cleanedEnv
+      .split(/[\s,]+/)
+      .map(s => s.replace(/^[<@!]+|[>]+$/g, '').trim())
+      .filter(s => Boolean(s) && !/^\$\{[^}]*\}$/.test(s));
+  }
+  if (Array.isArray(savedList)) {
+    return savedList
+      .map(s => String(s).replace(/^[<@!]+|[>]+$/g, '').trim())
+      .filter(s => Boolean(s) && !/^\$\{[^}]*\}$/.test(s));
+  }
+  return [];
+}
+
+function resolveWorkspaceDir(rawWorkspace) {
+  const cleaned = cleanEnvValue(rawWorkspace);
+  if (cleaned) {
+    return path.resolve(cleaned);
+  }
+  const cwd = process.cwd();
+  // When launched by Claude Desktop on Windows/macOS without a workspace, cwd may be the app binary dir
+  if (/WindowsApps|System32|\/Applications\/Claude\.app/i.test(cwd)) {
+    return os.homedir();
+  }
+  return path.resolve(cwd);
+}
+
+// Load configuration with precedence: sanitized environment variables > ~/.dis-gravity/config.json
+const saved = loadConfig();
+const config = {
+  token: cleanBotToken(process.env.DISCORD_BOT_TOKEN) || cleanBotToken(saved.token),
+  channelId: cleanChannelId(process.env.DISCORD_CHANNEL_ID) || cleanChannelId(saved.channelId),
+  guildId: cleanChannelId(process.env.DISCORD_GUILD_ID) || cleanChannelId(saved.guildId),
+  workspace: resolveWorkspaceDir(process.env.DISCORD_WORKSPACE || saved.workspace),
+  allowedUsers: parseAllowedUsersList(process.env.DISCORD_ALLOWED_USERS, saved.allowedUsers)
+};
+
+let discordClient = null;
+let clientReady = false;
+let discordInitStarted = false;
+
+// Pending button interaction waiters for ask_discord_approval
+const pendingComponentWaiters = new Map();
+
+// Queue of recent incoming messages from Discord for inbound Claude prompt bridging
+const incomingMessages = [];
+const MAX_INCOMING_MESSAGES = 50;
+
+// Thread-per-Workspace Manager & Cron/Interval Scheduler
+const threadWorkspaces = new ThreadWorkspaceManager({
+  defaultWorkspace: config.workspace,
+  storageFile: path.join(os.homedir(), '.dis-gravity', 'threads.json')
+});
+
+function resolveMcpThreadWorkspace(channelId) {
+  return threadWorkspaces.getThreadWorkspace(channelId, config.workspace);
+}
+
+const scheduler = new TaskScheduler({
+  onTrigger: async (job) => {
+    const targetChannelId = job.threadId || job.channelId || config.channelId;
+    const jobWorkspace = job.workspacePath || resolveMcpThreadWorkspace(targetChannelId);
+    const trimmed = (job.prompt || '').trim();
+
+    if (trimmed.startsWith('!sh ') || trimmed.startsWith('/sh ')) {
+      const cmdStr = trimmed.substring(4).trim();
+      const res = await executeShellCommand(cmdStr, jobWorkspace);
+      const badge = res.code === 0 ? `✅ **Exit 0 (${res.duration}s)**` : `❌ **Exit ${res.code} (${res.duration}s)**`;
+      const out = (res.stdout || res.stderr || '(No output)').trim();
+      if (config.token && targetChannelId) {
+        await discordRequest(config.token, 'POST', `/channels/${targetChannelId}/messages`, {
+          content: `⏰ **Scheduled Command (\`#${job.id}\` — ${job.description}):** \`${cmdStr}\`\n${badge}\n\`\`\`text\n${out.substring(0, 1750)}\n\`\`\``
+        }).catch(() => { });
+      }
+    } else {
+      recordIncomingMessage({
+        id: `sched_${job.id}_${Date.now()}`,
+        author: { username: 'scheduler', discriminator: '0', id: job.userId || 'scheduler' },
+        content: trimmed,
+        channel_id: targetChannelId,
+        workspace: jobWorkspace
+      });
+      if (config.token && targetChannelId) {
+        await discordRequest(config.token, 'POST', `/channels/${targetChannelId}/messages`, {
+          content: `⏰ **Scheduled Prompt Queued (\`#${job.id}\` — ${job.description}):**\n> ${trimmed.substring(0, 1800)}`
+        }).catch(() => { });
+      }
+    }
+  }
+});
+
+function downloadDiscordAttachmentToTemp(url, filename) {
+  return new Promise((resolve) => {
+    try {
+      const parsed = new URL(url);
+      if (parsed.protocol !== 'https:' || !['cdn.discordapp.com', 'media.discordapp.net'].includes(parsed.hostname)) {
+        return resolve(null);
+      }
+    } catch {
+      return resolve(null);
+    }
+
+    const safeName = path.basename(filename || 'voice.ogg').replace(/[^a-zA-Z0-9._-]/g, '_');
+    const tempFile = path.join(os.tmpdir(), `dg_mcp_voice_${Date.now()}_${safeName}`);
+    const fileStream = fs.createWriteStream(tempFile);
+    let totalBytes = 0;
+    const MAX_BYTES = 25 * 1024 * 1024;
+
+    const req = https.get(url, (res) => {
+      if (res.statusCode !== 200) {
+        fileStream.close();
+        try { fs.unlinkSync(tempFile); } catch { }
+        return resolve(null);
+      }
+      res.on('data', (chunk) => {
+        totalBytes += chunk.length;
+        if (totalBytes > MAX_BYTES) {
+          req.destroy();
+          fileStream.close();
+          try { fs.unlinkSync(tempFile); } catch { }
+          resolve(null);
+        }
+      });
+      res.pipe(fileStream);
+      fileStream.on('finish', () => {
+        fileStream.close(() => resolve(tempFile));
+      });
+    });
+
+    req.on('error', () => {
+      fileStream.close();
+      try { fs.unlinkSync(tempFile); } catch { }
+      resolve(null);
+    });
+  });
+}
+
+function recordIncomingMessage(msg) {
+  const authorTag = msg.author
+    ? (msg.author.tag || (msg.author.discriminator && msg.author.discriminator !== '0'
+      ? `${msg.author.username}#${msg.author.discriminator}`
+      : msg.author.username))
+    : 'unknown';
+
+  incomingMessages.push({
+    id: msg.id,
+    author: authorTag,
+    authorId: msg.author ? msg.author.id : '',
+    content: msg.content,
+    channelId: msg.channel_id || config.channelId || '',
+    workspace: msg.workspace || resolveMcpThreadWorkspace(msg.channel_id),
+    timestamp: new Date().toISOString()
+  });
+  if (incomingMessages.length > MAX_INCOMING_MESSAGES) {
+    incomingMessages.shift();
+  }
+}
+
+// Build status payload with interactive action buttons (Discord API v10 raw format, zero dependencies)
+function getBridgeStatusPayload(customHeader = null) {
+  const health = getSystemHealth(config.workspace);
+
+  let msg = '';
+  if (customHeader) {
+    msg += `${customHeader}\n\n`;
+  }
+  msg += `📊 **Dis-Gravity Claude MCP Bridge Status**\n\n`;
+  msg += `• **Client:** 🤖 Claude Desktop / Claude Code MCP Engine\n`;
+  msg += `• **Project:** 📁 \`${path.basename(config.workspace)}\`\n`;
+  msg += `• **Workspace:** \`${config.workspace}\`\n`;
+  msg += `• **Connection:** ${clientReady ? '🟢 **Active Gateway WebSocket**' : '🟡 **REST Mode (Gateway Connecting...)**'}\n`;
+  msg += `• **Host:** 💻 ${health.platform} (${health.release}, ${health.arch})\n`;
+  msg += `• **Memory:** 📈 ${health.memory}\n`;
+  msg += `• **Node Runtime:** ${health.nodeVersion} (PID: ${health.pid})\n`;
+
+  if (!config.allowedUsers || config.allowedUsers.length === 0) {
+    msg += `\n> 🛡️ *Security active: No \`allowedUsers\` configured. Remote execution is BLOCKED until your Discord User ID is added.*`;
+  }
+
+  const actionRow = {
+    type: 1, // ACTION_ROW
+    components: [
+      {
+        type: 2, // BUTTON
+        style: 1, // Primary
+        custom_id: 'mcp:status',
+        label: '🔄 Refresh'
+      },
+      {
+        type: 2, // BUTTON
+        style: 2, // Secondary
+        custom_id: 'mcp:diff',
+        label: '🌿 Git Diff'
+      },
+      {
+        type: 2, // BUTTON
+        style: 2, // Secondary
+        custom_id: 'mcp:info',
+        label: '🖥️ System Info'
+      }
+    ]
+  };
+
+  return { content: msg.substring(0, 1950), components: [actionRow] };
+}
+
+// Automatic frictionless onboarding bootstrap when token is present without channelId
+async function autoBootstrapBridge(token) {
+  if (!looksLikeBotToken(token)) return false;
+  try {
+    log('Discord Bot Token detected without Channel ID. Initiating automatic frictionless onboarding...');
+    // 1. Ensure Message Content Intent
+    const intentRes = await ensureMessageContentIntent(token).catch(() => null);
+    if (intentRes?.autoEnabled) {
+      log('Automatically enabled Message Content Intent for bot application.');
+    }
+
+    // 2. Inspect application
+    const app = await inspectApplication(token);
+    log(`Identified Bot @${app.botTag} (App: ${app.appName})`);
+
+    // 3. Check existing guilds
+    const guilds = await listUserGuilds(token);
+    let targetGuild = null;
+
+    if (config.guildId) {
+      targetGuild = guilds.find(g => g.id === config.guildId) || { id: config.guildId };
+    } else if (guilds.length > 0) {
+      targetGuild = guilds[0];
+    }
+
+    if (!targetGuild) {
+      const inviteUrl = buildInviteUrl(app.appId);
+      log('Bot is not currently authorized in any Discord server.');
+      log(`Opening OAuth2 invite link in browser: ${inviteUrl}`);
+      if (!process.env.NODE_TEST_CONTEXT && !process.env.CI) {
+        try { openBrowser(inviteUrl); } catch { }
+      }
+      targetGuild = await waitForGuildJoin(token, { timeoutMs: 90000 }).catch(() => null);
+      if (!targetGuild) {
+        log(`Timed out waiting for server authorization. Authorize via: ${inviteUrl}`);
+        return false;
+      }
+    }
+
+    // 4. Find or create private channel #dis-gravity
+    const channelRes = await findOrCreateChannel(token, targetGuild.id, {
+      channelName: 'dis-gravity',
+      botId: app.botId,
+      ownerId: app.ownerId
+    });
+
+    config.channelId = channelRes.channel.id;
+    config.guildId = targetGuild.id;
+
+    // 5. Auto-whitelist owner if not configured
+    if ((!config.allowedUsers || config.allowedUsers.length === 0) && app.ownerId) {
+      config.allowedUsers = [app.ownerId];
+      log(`Auto-whitelisted application owner ID: ${app.ownerId}`);
+    }
+
+    // 6. Save configuration to ~/.dis-gravity/config.json
+    saveConfig({
+      token,
+      channelId: config.channelId,
+      guildId: config.guildId,
+      allowedUsers: config.allowedUsers,
+      workspace: config.workspace
+    });
+
+    log(`Channel #${channelRes.channel.name} (${channelRes.channel.id}) configured in guild ${targetGuild.name || targetGuild.id}.`);
+
+    // 7. Send welcome message
+    await sendWelcomeMessage(token, config.channelId, {
+      ownerIds: config.allowedUsers,
+      provider: 'Claude Desktop MCP'
+    }).catch(() => { });
+
+    return true;
+  } catch (err) {
+    log(`Auto-bootstrap notice: ${err.message}`);
+    return false;
+  }
+}
+
+// Discord Interaction REST helpers
+async function replyToInteraction(interaction, data) {
+  return discordRequest(
+    config.token,
+    'POST',
+    `/interactions/${interaction.id}/${interaction.token}/callback`,
+    { type: 4, data }
+  );
+}
+
+async function deferInteractionReply(interaction, ephemeral = false) {
+  return discordRequest(
+    config.token,
+    'POST',
+    `/interactions/${interaction.id}/${interaction.token}/callback`,
+    { type: 5, data: ephemeral ? { flags: 64 } : {} }
+  );
+}
+
+async function deferInteractionUpdate(interaction) {
+  return discordRequest(
+    config.token,
+    'POST',
+    `/interactions/${interaction.id}/${interaction.token}/callback`,
+    { type: 6 }
+  );
+}
+
+async function updateInteractionMessage(interaction, data) {
+  return discordRequest(
+    config.token,
+    'POST',
+    `/interactions/${interaction.id}/${interaction.token}/callback`,
+    { type: 7, data }
+  );
+}
+
+async function editInteractionOriginal(interaction, payload, files = []) {
+  const appId = interaction.application_id || discordClient?.applicationId;
+  const body = typeof payload === 'string' ? { content: payload } : payload;
+  if (files && files.length > 0) {
+    return discordMultipartRequest(
+      config.token,
+      'PATCH',
+      `/webhooks/${appId}/${interaction.token}/messages/@original`,
+      body,
+      files
+    );
+  }
+  return discordRequest(
+    config.token,
+    'PATCH',
+    `/webhooks/${appId}/${interaction.token}/messages/@original`,
+    body
+  );
+}
+
+function getInteractionUser(interaction) {
+  const u = interaction.member?.user || interaction.user || {};
+  const tag = u.discriminator && u.discriminator !== '0'
+    ? `${u.username}#${u.discriminator}`
+    : (u.username || 'unknown');
+  return { id: u.id || '', username: u.username || 'unknown', tag };
+}
+
+function getSlashOptionString(interaction, optionName) {
+  const opts = interaction.data?.options;
+  if (!Array.isArray(opts)) return '';
+  const found = opts.find(o => o.name === optionName);
+  return found && found.value !== undefined ? String(found.value) : '';
+}
+
+// Handle Discord Gateway INTERACTION_CREATE events
+async function handleGatewayInteraction(interaction) {
+  try {
+    const user = getInteractionUser(interaction);
+    const isButton = interaction.type === 3;
+    const isChatInput = interaction.type === 2;
+    const customId = interaction.data?.custom_id || '';
+
+    // Check if this is an approval button click with an active waiter
+    if (isButton && (customId.startsWith('claude_allow_') || customId.startsWith('claude_deny_'))) {
+      for (const [waiterId, waiter] of pendingComponentWaiters.entries()) {
+        if (customId === `claude_allow_${waiter.actionId}` || customId === `claude_deny_${waiter.actionId}`) {
+          if (waiter.messageId && interaction.message?.id && interaction.message.id !== waiter.messageId) {
+            continue;
+          }
+          if (!isUserAllowed(user.id, config.allowedUsers)) {
+            const hasWhitelist = config.allowedUsers && config.allowedUsers.length > 0;
+            const denial = hasWhitelist
+              ? '⛔ **Unauthorized:** Your Discord User ID is not whitelisted in Dis-Gravity.'
+              : '⛔ **Unauthorized:** No `allowedUsers` configured in Dis-Gravity. Approval is blocked by default.';
+            await replyToInteraction(interaction, {
+              content: denial,
+              flags: 64
+            }).catch(() => { });
+            return;
+          }
+          pendingComponentWaiters.delete(waiterId);
+          waiter.resolve({ interaction, user, customId });
+          return;
+        }
+      }
+    }
+
+    // Fail-closed security check for all other slash commands and buttons
+    if (!isUserAllowed(user.id, config.allowedUsers)) {
+      const hasWhitelist = config.allowedUsers && config.allowedUsers.length > 0;
+      const denial = hasWhitelist
+        ? `⛔ **Unauthorized:** Your Discord User ID (\`${user.id}\`) is not in the Dis-Gravity whitelist.`
+        : `⛔ **Unauthorized:** No \`allowedUsers\` configured. Remote execution is blocked by default. Configure your Discord User ID in Claude Settings -> Extensions -> Dis-Gravity.`;
+      await replyToInteraction(interaction, { content: denial, flags: 64 }).catch(() => { });
+      return;
+    }
+
+    // Handle Interactive Dashboard Buttons
+    if (isButton) {
+      const targetWorkspace = resolveMcpThreadWorkspace(interaction.channel_id);
+      if (customId === 'mcp:status') {
+        await deferInteractionUpdate(interaction).catch(() => { });
+        const payload = getBridgeStatusPayload();
+        await editInteractionOriginal(interaction, payload).catch(() => { });
+        return;
+      }
+      if (customId === 'mcp:diff') {
+        await deferInteractionReply(interaction, true).catch(() => { });
+        const gitInfo = await getGitStatusAndDiff(targetWorkspace);
+        let reply = `🌿 **Git Status & Diff Preview (\`${path.basename(targetWorkspace)}\`)**\n\n\`\`\`diff\n${gitInfo.status}\n\`\`\`\n`;
+        if (gitInfo.stat) reply += `**Diff Stat:**\n\`\`\`text\n${gitInfo.stat}\n\`\`\``;
+        await editInteractionOriginal(interaction, reply).catch(() => { });
+        return;
+      }
+      if (customId === 'mcp:info') {
+        await deferInteractionReply(interaction, true).catch(() => { });
+        const health = getSystemHealth(targetWorkspace);
+        const gitInfo = await getGitStatusAndDiff(targetWorkspace);
+        let msg = `🖥️ **Dis-Gravity Host & System Info**\n\n`;
+        msg += `• **Project:** \`${path.basename(targetWorkspace)}\`\n`;
+        msg += `• **Workspace:** \`${targetWorkspace}\`\n`;
+        msg += `• **Branch:** \`${gitInfo.branch}\`\n`;
+        msg += `• **System:** ${health.platform} (${health.release}, ${health.arch})\n`;
+        msg += `• **CPU:** ${health.cpu}\n`;
+        msg += `• **Memory:** ${health.memory}\n`;
+        msg += `• **Engine:** Claude Desktop MCP Server (PID: ${health.pid})\n`;
+        await editInteractionOriginal(interaction, msg).catch(() => { });
+        return;
+      }
+      if (customId.startsWith('schedule:cancel:')) {
+        const jobId = customId.replace('schedule:cancel:', '').trim();
+        const cancelled = scheduler.cancelJob(jobId);
+        await updateInteractionMessage(interaction, {
+          content: cancelled ? `🛑 **Schedule \`#${jobId}\` Cancelled.**` : `⚠️ Schedule \`#${jobId}\` is no longer active.`,
+          components: []
+        }).catch(() => { });
+        return;
+      }
+      if (customId === 'schedule:cancel_all') {
+        const count = scheduler.cancelAll();
+        await updateInteractionMessage(interaction, {
+          content: `🛑 **Cancelled ${count} scheduled task(s).**`,
+          components: []
+        }).catch(() => { });
+        return;
+      }
+    }
+
+    // Handle Chat Input Slash Commands
+    if (isChatInput) {
+      const cmd = interaction.data?.name;
+      const targetWorkspace = resolveMcpThreadWorkspace(interaction.channel_id);
+
+      if (cmd === 'sh') {
+        const commandStr = getSlashOptionString(interaction, 'command');
+        await deferInteractionReply(interaction).catch(() => { });
+        const res = await executeShellCommand(commandStr, targetWorkspace);
+        const badge = res.code === 0 ? `✅ **Exit 0 (${res.duration}s)**` : `❌ **Exit ${res.code} (${res.duration}s)**`;
+        const out = (res.stdout || res.stderr || '(No output)').trim();
+
+        const parsedTable = parseMarkdownTable(out);
+        const files = [];
+        if (parsedTable) {
+          const pngBuf = await renderTableToPng(
+            parsedTable.headers,
+            parsedTable.rows,
+            parsedTable.alignments,
+            `Output: ${commandStr.substring(0, 30)}`
+          );
+          if (pngBuf) {
+            files.push({ name: 'table-output.png', buffer: pngBuf });
+          }
+        }
+
+        await editInteractionOriginal(
+          interaction,
+          { content: `${badge}\n\`\`\`text\n${out.substring(0, 1800)}\n\`\`\`` },
+          files
+        ).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'diff') {
+        await deferInteractionReply(interaction).catch(() => { });
+        const gitInfo = await getGitStatusAndDiff(targetWorkspace);
+        let reply = `🌿 **Git Status & Diff Preview (\`${path.basename(targetWorkspace)}\`)**\n\n`;
+        reply += `\`\`\`diff\n${gitInfo.status}\n\`\`\`\n`;
+        if (gitInfo.stat && gitInfo.stat !== 'No changes') {
+          reply += `**Diff Stat:**\n\`\`\`text\n${gitInfo.stat}\n\`\`\``;
+        }
+        await editInteractionOriginal(interaction, reply).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'cat') {
+        const file = getSlashOptionString(interaction, 'file');
+        await deferInteractionReply(interaction).catch(() => { });
+        const res = readWorkspaceFile(targetWorkspace, file);
+        if (res.error) {
+          await editInteractionOriginal(interaction, `❌ **Could not read file:** ${res.error}`).catch(() => { });
+          return;
+        }
+        const ext = path.extname(file).replace('.', '') || 'text';
+        const truncNotice = res.truncated ? `\n*(Truncated from ${res.size} bytes)*` : '';
+        await editInteractionOriginal(
+          interaction,
+          `📄 **\`${file}\`**${truncNotice}\n\`\`\`${ext}\n${res.content.substring(0, 1800)}\n\`\`\``
+        ).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'tree') {
+        await deferInteractionReply(interaction).catch(() => { });
+        const tree = listWorkspaceTree(targetWorkspace, '.', 2, 80);
+        await editInteractionOriginal(
+          interaction,
+          `📁 **Workspace Tree (\`${path.basename(targetWorkspace)}\`):**\n\`\`\`text\n${tree.substring(0, 1850)}\n\`\`\``
+        ).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'info') {
+        await deferInteractionReply(interaction).catch(() => { });
+        const health = getSystemHealth(targetWorkspace);
+        const gitInfo = await getGitStatusAndDiff(targetWorkspace);
+        let msg = `🖥️ **Dis-Gravity Host & Workspace Health**\n\n`;
+        msg += `• **Project:** \`${path.basename(targetWorkspace)}\`\n`;
+        msg += `• **Workspace:** \`${targetWorkspace}\`\n`;
+        msg += `• **Branch:** \`${gitInfo.branch}\`\n`;
+        msg += `• **System:** ${health.platform} (${health.release}, ${health.arch})\n`;
+        msg += `• **CPU:** ${health.cpu}\n`;
+        msg += `• **Memory:** ${health.memory}\n`;
+        msg += `• **Uptime:** ${Math.floor(health.uptimeSeconds / 60)} min\n`;
+        msg += `• **Engine:** Claude Desktop MCP Server (PID: ${health.pid})\n`;
+        await editInteractionOriginal(interaction, msg).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'status') {
+        await deferInteractionReply(interaction).catch(() => { });
+        const payload = getBridgeStatusPayload();
+        await editInteractionOriginal(interaction, payload).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'schedule') {
+        const specStr = getSlashOptionString(interaction, 'when').trim();
+        const promptStr = getSlashOptionString(interaction, 'prompt').trim();
+
+        if (!specStr || specStr.toLowerCase() === 'list') {
+          const jobs = scheduler.listJobs();
+          if (jobs.length === 0) {
+            await replyToInteraction(interaction, {
+              content: '⏰ **No active scheduled tasks.**\nUse `/schedule when:"15m" prompt:"!sh npm test"` or `/schedule when:"0 9 * * 1-5" prompt:"Summarize git status"` to schedule one.'
+            }).catch(() => { });
+            return;
+          }
+          let out = `⏰ **Active Scheduled Tasks (${jobs.length})**\n\n`;
+          for (const j of jobs) {
+            out += `• **\`#${j.id}\`** (${j.description}) — Next: \`${j.nextRunAt || 'N/A'}\` | Runs: ${j.runCount}\n  Prompt: \`${j.prompt.substring(0, 80)}\`\n`;
+          }
+          const actionRow = {
+            type: 1,
+            components: [{ type: 2, style: 4, custom_id: 'schedule:cancel_all', label: '🛑 Cancel All' }]
+          };
+          await replyToInteraction(interaction, { content: out.substring(0, 1900), components: [actionRow] }).catch(() => { });
+          return;
+        }
+
+        if (specStr.toLowerCase().startsWith('cancel')) {
+          const targetId = specStr.replace(/^cancel\s*/i, '').trim() || promptStr;
+          if (!targetId || targetId === 'all') {
+            const count = scheduler.cancelAll();
+            await replyToInteraction(interaction, { content: `🛑 **Cancelled ${count} scheduled task(s).**` }).catch(() => { });
+          } else {
+            const ok = scheduler.cancelJob(targetId);
+            await replyToInteraction(interaction, { content: ok ? `🛑 **Cancelled schedule \`#${targetId}\`.**` : `❌ Schedule \`#${targetId}\` not found.` }).catch(() => { });
+          }
+          return;
+        }
+
+        if (!promptStr) {
+          await replyToInteraction(interaction, { content: '⚠️ Please provide a `prompt` or command to run when the schedule triggers.', flags: 64 }).catch(() => { });
+          return;
+        }
+
+        const res = scheduler.addJob({
+          spec: specStr,
+          prompt: promptStr,
+          channelId: interaction.channel_id || config.channelId,
+          workspacePath: targetWorkspace,
+          userId: user.id
+        });
+        if (!res.ok) {
+          await replyToInteraction(interaction, { content: `❌ **Schedule Error:** ${res.error}`, flags: 64 }).catch(() => { });
+          return;
+        }
+        const job = res.job;
+        const row = {
+          type: 1,
+          components: [{ type: 2, style: 4, custom_id: `schedule:cancel:${job.id}`, label: `🛑 Cancel #${job.id}` }]
+        };
+        await replyToInteraction(interaction, {
+          content: `⏰ **Scheduled Task \`#${job.id}\` Created!**\n• **Schedule:** ${job.description}\n• **Next Run:** \`${job.nextRunAt}\`\n• **Workspace:** \`${job.workspacePath}\`\n• **Prompt:** \`${job.prompt}\``,
+          components: [row]
+        }).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'bind') {
+        const wsPath = getSlashOptionString(interaction, 'workspace').trim();
+        if (!wsPath || wsPath.toLowerCase() === 'status') {
+          const binding = threadWorkspaces.getThreadBinding(interaction.channel_id);
+          if (!binding) {
+            await replyToInteraction(interaction, {
+              content: `🔗 **Current Thread/Channel Workspace:** \`${config.workspace}\` *(default)*\nUse \`/bind workspace:<path>\` inside any thread to bind it to a specific project directory.`
+            }).catch(() => { });
+          } else {
+            await replyToInteraction(interaction, {
+              content: `🔗 **Bound Workspace:** \`${binding.workspacePath}\`\n• **Bound At:** \`${binding.boundAt}\``
+            }).catch(() => { });
+          }
+          return;
+        }
+        if (wsPath.toLowerCase() === 'unbind' || wsPath.toLowerCase() === 'reset') {
+          const removed = threadWorkspaces.unbindThread(interaction.channel_id);
+          await replyToInteraction(interaction, {
+            content: removed
+              ? `🔓 **Unbound thread.** Reverted to default workspace (\`${config.workspace}\`).`
+              : `ℹ️ This thread was not bound to a custom workspace.`
+          }).catch(() => { });
+          return;
+        }
+        const res = threadWorkspaces.bindThread(interaction.channel_id, wsPath, { userId: user.id });
+        if (!res.ok) {
+          await replyToInteraction(interaction, { content: `❌ **Bind Failed:** ${res.error}`, flags: 64 }).catch(() => { });
+          return;
+        }
+        await replyToInteraction(interaction, {
+          content: `🔗 **Thread Bound to Workspace!**\n• **Channel/Thread:** <#${interaction.channel_id}>\n• **Workspace:** \`${res.binding.workspacePath}\`\nAll commands (\`/sh\`, \`/diff\`, \`/cat\`, \`/tree\`) in this thread now run isolated in this directory.`
+        }).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'threads') {
+        const bindings = threadWorkspaces.listBindings();
+        if (bindings.length === 0) {
+          await replyToInteraction(interaction, {
+            content: `🧵 **No custom thread workspace bindings.**\nDefault workspace: \`${config.workspace}\`\nUse \`/bind workspace:<path>\` inside any thread to bind it to a dedicated project folder.`
+          }).catch(() => { });
+          return;
+        }
+        let out = `🧵 **Active Thread Workspace Bindings (${bindings.length})**\n\n`;
+        for (const b of bindings) {
+          out += `• <#${b.threadId}> → \`${b.workspacePath}\`${b.conversationName ? ` *(Session: ${b.conversationName})*` : ''}\n`;
+        }
+        await replyToInteraction(interaction, { content: out.substring(0, 1900) }).catch(() => { });
+        return;
+      }
+
+      if (cmd === 'help') {
+        let h = `🤖 **Dis-Gravity MCP Remote Control Commands**\n\n`;
+        h += `• \`/sh <cmd>\` — Run terminal command in workspace\n`;
+        h += `• \`/diff\` — View git status and unified diff preview\n`;
+        h += `• \`/cat <file>\` — Safely view workspace file contents\n`;
+        h += `• \`/tree\` — View workspace directory layout\n`;
+        h += `• \`/info\` — Host hardware telemetry and branch status\n`;
+        h += `• \`/status\` — View MCP bridge connection status\n`;
+        h += `• \`/schedule <when> [prompt]\` — Schedule one-shot or recurring cron tasks\n`;
+        h += `• \`/bind [workspace]\` — Bind a Discord thread to a dedicated project directory\n`;
+        h += `• \`/threads\` — List all thread-to-workspace bindings\n`;
+        h += `• 🎙️ **Voice Messages** — Send a Discord voice message to auto-transcribe & execute\n`;
+        await replyToInteraction(interaction, { content: h }).catch(() => { });
+        return;
+      }
+    }
+  } catch (err) {
+    log('Interaction error:', err.message);
+  }
+}
+
+// Reply to a channel message via Discord REST v10
+async function replyToChannelMessage(message, payload) {
+  const body = typeof payload === 'string' ? { content: payload } : { ...payload };
+  body.message_reference = { message_id: message.id, fail_if_not_exists: false };
+  return discordRequest(config.token, 'POST', `/channels/${message.channel_id}/messages`, body);
+}
+
+// Handle Discord Gateway MESSAGE_CREATE events
+async function handleGatewayMessage(message) {
+  try {
+    if (!message || !message.author || message.author.bot) return;
+    const isDm = !message.guild_id;
+    const isBoundThread = Boolean(threadWorkspaces.getThreadBinding(message.channel_id));
+    if (message.channel_id !== config.channelId && !isDm && !isBoundThread) return;
+
+    if (!isUserAllowed(message.author.id, config.allowedUsers)) {
+      const hasWhitelist = config.allowedUsers && config.allowedUsers.length > 0;
+      const denial = hasWhitelist
+        ? `⛔ **Unauthorized:** Your Discord User ID (\`${message.author.id}\`) is not on the Dis-Gravity whitelist.`
+        : `⛔ **Unauthorized:** No \`allowedUsers\` whitelist configured. Remote execution blocked by default.`;
+      await replyToChannelMessage(message, denial).catch(() => { });
+      return;
+    }
+
+    const targetWorkspace = resolveMcpThreadWorkspace(message.channel_id);
+    let text = (message.content || '').trim();
+
+    // Auto-transcribe Discord voice messages / audio attachments
+    if (Array.isArray(message.attachments) && message.attachments.length > 0) {
+      for (const att of message.attachments) {
+        if (isAudioAttachment(att, message.flags || 0)) {
+          const tempAudio = await downloadDiscordAttachmentToTemp(att.url, att.filename || 'voice.ogg');
+          if (tempAudio) {
+            try {
+              const stt = await transcribeAudioFile(tempAudio);
+              if (stt.ok && stt.text) {
+                text = text ? `${text}\n${stt.text}` : stt.text;
+                message.content = text;
+                await replyToChannelMessage(
+                  message,
+                  `🎙️ **Voice Prompt Transcribed (${stt.provider}):**\n> ${stt.text}`
+                ).catch(() => { });
+              } else {
+                await replyToChannelMessage(
+                  message,
+                  `⚠️ **Voice Transcription Notice:** ${stt.error}`
+                ).catch(() => { });
+              }
+            } finally {
+              try { fs.unlinkSync(tempAudio); } catch { }
+            }
+          }
+        }
+      }
+    }
+
+    // Record incoming message for Claude MCP inbound resource stream
+    recordIncomingMessage({ ...message, workspace: targetWorkspace });
+
+    if (text.startsWith('!sh ')) {
+      const cmd = text.substring(4).trim();
+      const res = await executeShellCommand(cmd, targetWorkspace);
+      const badge = res.code === 0 ? `✅ **Exit 0 (${res.duration}s)**` : `❌ **Exit ${res.code} (${res.duration}s)**`;
+      const out = (res.stdout || res.stderr || '(No output)').trim();
+      await replyToChannelMessage(message, `${badge}\n\`\`\`text\n${out.substring(0, 1800)}\n\`\`\``).catch(() => { });
+    } else if (text === '!diff') {
+      const gitInfo = await getGitStatusAndDiff(targetWorkspace);
+      let reply = `🌿 **Git Status & Diff Preview (\`${path.basename(targetWorkspace)}\`)**\n\n\`\`\`diff\n${gitInfo.status}\n\`\`\`\n`;
+      if (gitInfo.stat) reply += `**Diff Stat:**\n\`\`\`text\n${gitInfo.stat}\n\`\`\``;
+      await replyToChannelMessage(message, reply).catch(() => { });
+    } else if (text.startsWith('!cat ')) {
+      const file = text.substring(5).trim();
+      const res = readWorkspaceFile(targetWorkspace, file);
+      if (res.error) {
+        await replyToChannelMessage(message, `❌ **Could not read file:** ${res.error}`).catch(() => { });
+      } else {
+        const ext = path.extname(file).replace('.', '') || 'text';
+        await replyToChannelMessage(
+          message,
+          `📄 **\`${file}\`**\n\`\`\`${ext}\n${res.content.substring(0, 1800)}\n\`\`\``
+        ).catch(() => { });
+      }
+    } else if (text === '!tree') {
+      const tree = listWorkspaceTree(targetWorkspace, '.', 2, 80);
+      await replyToChannelMessage(message, `📁 **Workspace Tree (\`${path.basename(targetWorkspace)}\`):**\n\`\`\`text\n${tree.substring(0, 1850)}\n\`\`\``).catch(() => { });
+    } else if (text === '!info' || text === '!status') {
+      const payload = getBridgeStatusPayload();
+      await replyToChannelMessage(message, payload).catch(() => { });
+    } else if (text === '!schedule' || text.startsWith('!schedule ')) {
+      const rawArg = text.replace(/^!schedule\s*/i, '').trim();
+      const parsed = parseScheduleCommandInput(rawArg);
+      if (parsed.action === 'list') {
+        const jobs = scheduler.listJobs();
+        if (jobs.length === 0) {
+          await replyToChannelMessage(message, '⏰ **No active scheduled tasks.** Use `!schedule 15m | !sh npm test` or `!schedule 0 9 * * 1-5 | Check build` to create one.').catch(() => { });
+        } else {
+          let out = `⏰ **Active Scheduled Tasks (${jobs.length})**\n\n`;
+          for (const j of jobs) {
+            out += `• **\`#${j.id}\`** (${j.description}) — Next: \`${j.nextRunAt || 'N/A'}\` | Prompt: \`${j.prompt.substring(0, 80)}\`\n`;
+          }
+          await replyToChannelMessage(message, out.substring(0, 1900)).catch(() => { });
+        }
+      } else if (parsed.action === 'cancel') {
+        if (parsed.jobId === 'all') {
+          const count = scheduler.cancelAll();
+          await replyToChannelMessage(message, `🛑 **Cancelled ${count} scheduled task(s).**`).catch(() => { });
+        } else {
+          const ok = scheduler.cancelJob(parsed.jobId);
+          await replyToChannelMessage(message, ok ? `🛑 **Cancelled schedule \`#${parsed.jobId}\`.**` : `❌ Schedule \`#${parsed.jobId}\` not found.`).catch(() => { });
+        }
+      } else if (parsed.action === 'add') {
+        const res = scheduler.addJob({
+          spec: parsed.spec,
+          prompt: parsed.prompt,
+          channelId: message.channel_id,
+          workspacePath: targetWorkspace,
+          userId: message.author.id
+        });
+        if (!res.ok) {
+          await replyToChannelMessage(message, `❌ **Schedule Error:** ${res.error}`).catch(() => { });
+        } else {
+          await replyToChannelMessage(
+            message,
+            `⏰ **Scheduled Task \`#${res.job.id}\` Created!** (${res.job.description})\n• **Next Run:** \`${res.job.nextRunAt}\`\n• **Prompt:** \`${res.job.prompt}\``
+          ).catch(() => { });
+        }
+      } else {
+        await replyToChannelMessage(message, `❌ **Schedule Error:** ${parsed.error}`).catch(() => { });
+      }
+    } else if (text === '!bind' || text.startsWith('!bind ')) {
+      const arg = text.replace(/^!bind\s*/i, '').trim();
+      if (!arg || arg === 'status') {
+        const binding = threadWorkspaces.getThreadBinding(message.channel_id);
+        await replyToChannelMessage(
+          message,
+          binding
+            ? `🔗 **Bound Workspace:** \`${binding.workspacePath}\``
+            : `🔗 **Current Workspace:** \`${config.workspace}\` *(default)*`
+        ).catch(() => { });
+      } else if (arg === 'unbind' || arg === 'reset') {
+        threadWorkspaces.unbindThread(message.channel_id);
+        await replyToChannelMessage(message, `🔓 **Unbound thread.** Reverted to default workspace (\`${config.workspace}\`).`).catch(() => { });
+      } else {
+        const res = threadWorkspaces.bindThread(message.channel_id, arg, { userId: message.author.id });
+        await replyToChannelMessage(
+          message,
+          res.ok ? `🔗 **Bound <#${message.channel_id}> to workspace:** \`${res.binding.workspacePath}\`` : `❌ **Bind Failed:** ${res.error}`
+        ).catch(() => { });
+      }
+    } else if (text === '!threads') {
+      const bindings = threadWorkspaces.listBindings();
+      if (bindings.length === 0) {
+        await replyToChannelMessage(message, `🧵 **No custom thread workspace bindings.** Default: \`${config.workspace}\``).catch(() => { });
+      } else {
+        let out = `🧵 **Active Thread Bindings (${bindings.length})**\n\n`;
+        for (const b of bindings) {
+          out += `• <#${b.threadId}> → \`${b.workspacePath}\`\n`;
+        }
+        await replyToChannelMessage(message, out.substring(0, 1900)).catch(() => { });
+      }
+    }
+  } catch (err) {
+    log('messageCreate error:', err.message);
+  }
+}
+
+const SLASH_COMMANDS_DEFINITION = [
+  {
+    name: 'sh',
+    description: 'Execute shell command in workspace',
+    options: [{ name: 'command', description: 'Command to execute', type: 3, required: true }]
+  },
+  { name: 'diff', description: 'View git status and diff preview' },
+  {
+    name: 'cat',
+    description: 'Safely inspect workspace file contents',
+    options: [{ name: 'file', description: 'Relative file path', type: 3, required: true }]
+  },
+  { name: 'tree', description: 'View workspace directory layout' },
+  { name: 'info', description: 'View host telemetry and git branch status' },
+  { name: 'status', description: 'View Dis-Gravity MCP bridge status' },
+  {
+    name: 'schedule',
+    description: 'Schedule a one-shot or recurring cron prompt/command',
+    options: [
+      { name: 'when', description: 'Delay (15m, 2h), interval (every 30m), cron (0 9 * * 1-5), list, or cancel <id>', type: 3, required: true },
+      { name: 'prompt', description: 'Prompt or !sh command to execute when triggered', type: 3, required: false }
+    ]
+  },
+  {
+    name: 'bind',
+    description: 'Bind this Discord thread/channel to a dedicated workspace directory',
+    options: [
+      { name: 'workspace', description: 'Path to workspace directory (or "status" / "unbind")', type: 3, required: false }
+    ]
+  },
+  { name: 'threads', description: 'List all active Discord thread-to-workspace bindings' },
+  { name: 'help', description: 'Display Dis-Gravity slash commands' }
+];
+
+/**
+ * Zero-dependency Discord Gateway v10 WebSocket client using native Node 18+/24 WebSocket
+ */
+class NativeDiscordGateway {
+  constructor(token) {
+    this.token = token.trim().replace(/^Bot\s+/i, '');
+    this.ws = null;
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+    this.seq = null;
+    this.user = null;
+    this.applicationId = null;
+    this.destroyed = false;
+    // GUILDS (1) | GUILD_MESSAGES (512) | DIRECT_MESSAGES (4096) | MESSAGE_CONTENT (32768) = 37377
+    this.intents = (1 << 0) | (1 << 9) | (1 << 12) | (1 << 15);
+  }
+
+  connect() {
+    if (this.destroyed) return;
+    if (typeof WebSocket !== 'function') {
+      log('Native WebSocket is unavailable in this Node runtime. Falling back to REST-only mode.');
+      return;
+    }
+
+    try {
+      this.ws = new WebSocket('wss://gateway.discord.gg/?v=10&encoding=json');
+    } catch (err) {
+      log('WebSocket initialization error:', err.message);
+      this.scheduleReconnect(5000);
+      return;
+    }
+
+    this.ws.addEventListener('message', (event) => {
+      try {
+        const raw = typeof event.data === 'string' ? event.data : Buffer.from(event.data).toString('utf8');
+        const packet = JSON.parse(raw);
+        this.onPacket(packet);
+      } catch (err) {
+        log('Gateway packet parse error:', err.message);
+      }
+    });
+
+    this.ws.addEventListener('close', (event) => {
+      this.clearHeartbeat();
+      if (this.destroyed) return;
+      clientReady = false;
+
+      const code = event?.code || 0;
+      // 4004 = Authentication failed
+      if (code === 4004) {
+        log('Discord Gateway closed with 4004 (Invalid Bot Token). Not reconnecting.');
+        return;
+      }
+      // 4014 = Disallowed intent(s) — retry without privileged MESSAGE_CONTENT intent
+      if (code === 4014 && (this.intents & (1 << 15)) !== 0) {
+        log('Message Content Intent is not enabled on Discord Portal (4014). Reconnecting with standard intents...');
+        this.intents = (1 << 0) | (1 << 9) | (1 << 12);
+        this.scheduleReconnect(1000);
+        return;
+      }
+
+      this.scheduleReconnect(4000);
+    });
+
+    this.ws.addEventListener('error', (err) => {
+      if (err?.message) {
+        log('Gateway WebSocket error:', err.message);
+      }
+    });
+  }
+
+  send(payload) {
+    if (this.ws && this.ws.readyState === 1) {
+      try {
+        this.ws.send(JSON.stringify(payload));
+      } catch { }
+    }
+  }
+
+  startHeartbeat(intervalMs) {
+    this.clearHeartbeat();
+    const jitter = Math.floor(Math.random() * 1000);
+    this.heartbeatTimer = setInterval(() => {
+      this.send({ op: 1, d: this.seq });
+    }, Math.max(5000, intervalMs - jitter));
+    if (this.heartbeatTimer.unref) this.heartbeatTimer.unref();
+  }
+
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  scheduleReconnect(delayMs) {
+    if (this.destroyed || this.reconnectTimer) return;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delayMs);
+    if (this.reconnectTimer.unref) this.reconnectTimer.unref();
+  }
+
+  onPacket(packet) {
+    const { op, d, s, t } = packet;
+    if (s !== null && s !== undefined) {
+      this.seq = s;
+    }
+
+    switch (op) {
+      case 10: // HELLO
+        this.startHeartbeat(d.heartbeat_interval || 41250);
+        this.send({
+          op: 2,
+          d: {
+            token: this.token,
+            intents: this.intents,
+            properties: {
+              os: process.platform,
+              browser: 'dis-gravity-mcp',
+              device: 'dis-gravity-mcp'
+            }
+          }
+        });
+        break;
+
+      case 1: // HEARTBEAT REQUEST
+        this.send({ op: 1, d: this.seq });
+        break;
+
+      case 7: // RECONNECT
+      case 9: // INVALID_SESSION
+        try {
+          this.ws?.close();
+        } catch { }
+        this.scheduleReconnect(2000);
+        break;
+
+      case 0: // DISPATCH
+        if (t === 'READY') {
+          const u = d.user || {};
+          const tag = u.discriminator && u.discriminator !== '0'
+            ? `${u.username}#${u.discriminator}`
+            : (u.username || 'bot');
+          this.user = { id: u.id, username: u.username, discriminator: u.discriminator || '0', tag };
+          this.applicationId = d.application?.id || null;
+          clientReady = true;
+          log(`Connected to Discord Gateway as @${this.user.tag}`);
+          this.registerSlashCommands();
+        } else if (t === 'INTERACTION_CREATE') {
+          handleGatewayInteraction(d);
+        } else if (t === 'MESSAGE_CREATE') {
+          handleGatewayMessage(d);
+        }
+        break;
+    }
+  }
+
+  async registerSlashCommands() {
+    if (!this.applicationId) return;
+    try {
+      if (config.guildId) {
+        await discordRequest(
+          this.token,
+          'PUT',
+          `/applications/${this.applicationId}/guilds/${config.guildId}/commands`,
+          SLASH_COMMANDS_DEFINITION
+        );
+        log(`Registered ${SLASH_COMMANDS_DEFINITION.length} guild slash commands in guild ${config.guildId}`);
+      } else {
+        await discordRequest(
+          this.token,
+          'PUT',
+          `/applications/${this.applicationId}/commands`,
+          SLASH_COMMANDS_DEFINITION
+        );
+        log(`Registered ${SLASH_COMMANDS_DEFINITION.length} global slash commands`);
+      }
+    } catch (err) {
+      log('Slash command registration notice:', err.message);
+    }
+  }
+
+  destroy() {
+    this.destroyed = true;
+    this.clearHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close(1000, 'Shutting down');
+      } catch { }
+      this.ws = null;
+    }
+  }
+}
+
+// Initialize Discord Gateway Client when credentials are set
+async function initDiscordClient() {
+  if (!config.token) {
+    log('Discord Bot Token not configured. MCP Server running in standalone unconfigured mode.');
+    log('Configure token via setup_discord_bridge tool or in Claude Settings -> Extensions -> Dis-Gravity.');
+    return;
+  }
+
+  // If channelId is missing, attempt automatic frictionless bootstrap
+  if (!config.channelId) {
+    const bootstrapped = await autoBootstrapBridge(config.token);
+    if (!bootstrapped) {
+      log('Channel ID missing and auto-bootstrap did not resolve a guild/channel.');
+      log('Run setup_discord_bridge tool or authorize the bot in your Discord server.');
+      return;
+    }
+  }
+
+  // Destroy previous client if reconnecting
+  if (discordClient) {
+    try {
+      discordClient.destroy();
+    } catch { }
+    discordClient = null;
+    clientReady = false;
+  }
+
+  try {
+    discordClient = new NativeDiscordGateway(config.token);
+    discordClient.connect();
+  } catch (err) {
+    log('Could not start Discord Gateway client:', err.message);
+    discordClient = null;
+    clientReady = false;
+  }
+}
+
+function ensureDiscordStarted() {
+  if (discordInitStarted) return;
+  discordInitStarted = true;
+  initDiscordClient().catch(err => log('Init error:', err.message));
+}
+
+// Prompt definitions for MCP prompts/list & prompts/get (Claude Desktop 1-click wizard menu)
+const PROMPTS = [
+  {
+    name: 'setup-discord-bridge',
+    description: 'Run the interactive 60-second setup wizard to connect Claude Desktop to Discord and your mobile phone.',
+    arguments: [
+      {
+        name: 'bot_token',
+        description: 'Discord Bot Token from https://discord.com/developers/applications (optional — leave blank for step-by-step instructions)',
+        required: false
+      },
+      {
+        name: 'channel_name',
+        description: 'Private Discord channel name to create or reuse (default: dis-gravity)',
+        required: false
+      }
+    ]
+  },
+  {
+    name: 'discord-bridge-status',
+    description: 'Check Dis-Gravity Discord bridge connection status, host health, and send a test notification to mobile.',
+    arguments: []
+  }
+];
+
+// Tool definitions for MCP tools/list
+const TOOLS = [
+  {
+    name: 'notify_discord',
+    description: 'Send a rich status notification, milestone update, or message to the user\'s linked Discord channel and mobile phone. Automatically renders Markdown tables into 2x Retina PNG cards.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          description: 'Text message content to send to Discord'
+        },
+        level: {
+          type: 'string',
+          enum: ['info', 'success', 'warning', 'error'],
+          description: 'Notification severity level (default: info)'
+        },
+        title: {
+          type: 'string',
+          description: 'Optional bold title header for the notification'
+        }
+      },
+      required: ['message']
+    }
+  },
+  {
+    name: 'ask_discord_approval',
+    description: 'Pause execution and request interactive 1-tap confirmation from the developer on their mobile Discord app. Halts until the developer taps [ Allow ] or [ Deny ].',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Description of the sensitive action to approve (e.g. "Run terminal command: rm -rf dist/" or "Apply database migrations")'
+        },
+        details: {
+          type: 'string',
+          description: 'Additional context, diff preview, or command parameters'
+        },
+        timeout_seconds: {
+          type: 'number',
+          description: 'Approval timeout in seconds before auto-denying (default: 120)'
+        }
+      },
+      required: ['action']
+    }
+  },
+  {
+    name: 'get_discord_bridge_status',
+    description: 'Retrieve current Dis-Gravity Discord connection status, active channel, and host system health.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'run_workspace_command',
+    description: 'Execute a terminal shell command inside the workspace directory, with optional mobile Discord approval prompt for high-risk operations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: {
+          type: 'string',
+          description: 'Shell command string to execute (e.g. "npm test", "git status")'
+        },
+        timeout_seconds: {
+          type: 'number',
+          description: 'Maximum command duration in seconds (default: 30)'
+        },
+        require_approval: {
+          type: 'boolean',
+          description: 'If true, requests 1-tap mobile Discord approval before executing'
+        }
+      },
+      required: ['command']
+    }
+  },
+  {
+    name: 'get_git_diff',
+    description: 'Retrieve current Git branch, short status summary, and unified diff stat for the active workspace.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'render_table_card',
+    description: 'Convert structured tabular data (headers and rows) into a 2x Retina PNG card and deliver it to Discord.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: {
+          type: 'string',
+          description: 'Card title banner (e.g. "Benchmark Results")'
+        },
+        headers: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Array of column header titles'
+        },
+        rows: {
+          type: 'array',
+          items: {
+            type: 'array',
+            items: { type: 'string' }
+          },
+          description: '2D array of row cell values'
+        },
+        alignments: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Optional column alignments ("left", "center", "right")'
+        }
+      },
+      required: ['headers', 'rows']
+    }
+  },
+  {
+    name: 'read_workspace_file',
+    description: 'Safely inspect the content of a file within the workspace with path traversal protection.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Relative file path within workspace'
+        },
+        max_bytes: {
+          type: 'number',
+          description: 'Maximum bytes to read (default: 102400)'
+        }
+      },
+      required: ['path']
+    }
+  },
+  {
+    name: 'list_workspace_tree',
+    description: 'View the directory tree structure of the workspace.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sub_dir: {
+          type: 'string',
+          description: 'Relative subdirectory to list (default: ".")'
+        },
+        max_depth: {
+          type: 'number',
+          description: 'Maximum tree depth (default: 2)'
+        }
+      }
+    }
+  },
+  {
+    name: 'get_incoming_messages',
+    description: 'Retrieve recent messages and instructions sent from the developer in the linked Discord channel.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  },
+  {
+    name: 'setup_discord_bridge',
+    description: 'Run automated frictionless onboarding wizard to configure Dis-Gravity. Validates bot token, auto-enables Message Content intent, opens OAuth invite link, auto-creates private #dis-gravity channel, auto-whitelists bot owner, and connects live bridge.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        bot_token: {
+          type: 'string',
+          description: 'Discord Bot Token from Discord Developer Portal'
+        },
+        guild_id: {
+          type: 'string',
+          description: 'Optional Discord Server (Guild) ID to bind to'
+        },
+        channel_name: {
+          type: 'string',
+          description: 'Channel name to find or create (default: "dis-gravity")'
+        },
+        open_browser: {
+          type: 'boolean',
+          description: 'Whether to open the OAuth invite link in the default browser if bot is not in a server (default: true)'
+        }
+      },
+      required: ['bot_token']
+    }
+  }
+];
+
+// Tool handlers
+async function handleNotifyDiscord(args) {
+  const token = config.token;
+  const channelId = config.channelId;
+
+  if (!token || !channelId) {
+    throw new Error('Discord Bot Token or Channel ID is not configured. Please set them in Claude Settings -> Extensions -> Dis-Gravity, or run "npx dis-gravity setup" in your terminal.');
+  }
+
+  const levelEmojis = {
+    info: 'ℹ️',
+    success: '✅',
+    warning: '⚠️',
+    error: '❌'
+  };
+  const emoji = levelEmojis[args.level] || 'ℹ️';
+  let content = '';
+
+  if (args.title) {
+    content += `${emoji} **${args.title}**\n\n`;
+  }
+  content += args.message || '';
+
+  // Check if message contains a Markdown table for automatic 2x PNG rendering
+  let pngBuf = null;
+  const parsed = parseMarkdownTable(args.message);
+  if (parsed) {
+    pngBuf = await renderTableToPng(
+      parsed.headers,
+      parsed.rows,
+      parsed.alignments,
+      args.title || 'Data Table'
+    ).catch(() => null);
+  }
+
+  if (pngBuf) {
+    const res = await discordMultipartRequest(
+      token,
+      'POST',
+      `/channels/${channelId}/messages`,
+      { content: content.substring(0, 1950) },
+      [{ name: 'table-card.png', buffer: pngBuf }]
+    );
+    return {
+      delivered: true,
+      channelId,
+      messageId: res.id,
+      tableCardAttached: true
+    };
+  }
+
+  const res = await discordRequest(token, 'POST', `/channels/${channelId}/messages`, {
+    content: content.substring(0, 1950)
+  });
+
+  return {
+    delivered: true,
+    channelId,
+    messageId: res.id,
+    tableCardAttached: false
+  };
+}
+
+function awaitComponentInteraction(actionId, messageId, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pendingComponentWaiters.delete(actionId);
+      reject(new Error('Timed out waiting for component interaction'));
+    }, timeoutMs);
+
+    pendingComponentWaiters.set(actionId, {
+      actionId,
+      messageId,
+      resolve: (data) => {
+        clearTimeout(timer);
+        resolve(data);
+      }
+    });
+  });
+}
+
+async function handleAskDiscordApproval(args) {
+  const token = config.token;
+  const channelId = config.channelId;
+
+  if (!token || !channelId) {
+    throw new Error('Discord credentials not configured. Please configure DISCORD_BOT_TOKEN and DISCORD_CHANNEL_ID in extension settings, or run "npx dis-gravity setup".');
+  }
+
+  const action = args.action;
+  const details = args.details || '';
+  const timeoutSeconds = Math.max(10, Math.min(600, args.timeout_seconds || 120));
+  const actionId = `act_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
+
+  // If Gateway client is connected, use interactive Button components
+  if (discordClient && clientReady) {
+    let text = `🔔 **Claude Approval Request**\n\n`;
+    text += `Claude is requesting your permission to proceed with an action:\n`;
+    text += `> **Action:** \`${action}\`\n`;
+    if (details) {
+      text += `\`\`\`text\n${details.substring(0, 1000)}\n\`\`\`\n`;
+    }
+    text += `⏳ *Expires in ${timeoutSeconds}s. Tap an option below from mobile or desktop:*`;
+
+    const row = {
+      type: 1, // ACTION_ROW
+      components: [
+        {
+          type: 2, // BUTTON
+          style: 3, // Success
+          custom_id: `claude_allow_${actionId}`,
+          label: '🟢 Allow / Proceed'
+        },
+        {
+          type: 2, // BUTTON
+          style: 4, // Danger
+          custom_id: `claude_deny_${actionId}`,
+          label: '🔴 Deny / Cancel'
+        }
+      ]
+    };
+
+    const promptMessage = await discordRequest(token, 'POST', `/channels/${channelId}/messages`, {
+      content: text,
+      components: [row]
+    });
+
+    try {
+      const { interaction, user, customId } = await awaitComponentInteraction(actionId, promptMessage?.id, timeoutSeconds * 1000);
+
+      if (customId.startsWith(`claude_allow_${actionId}`)) {
+        await updateInteractionMessage(interaction, {
+          content: `✅ **Action Approved by <@${user.id}>:** \`${action}\``,
+          components: []
+        }).catch(() => { });
+
+        return {
+          approved: true,
+          action,
+          confirmedBy: user.tag,
+          confirmedById: user.id,
+          timestamp: new Date().toISOString()
+        };
+      } else {
+        await updateInteractionMessage(interaction, {
+          content: `❌ **Action Denied by <@${user.id}>:** \`${action}\``,
+          components: []
+        }).catch(() => { });
+
+        return {
+          approved: false,
+          action,
+          deniedBy: user.tag,
+          reason: 'User clicked Deny in Discord'
+        };
+      }
+    } catch {
+      // Timeout: remove buttons on original message
+      if (promptMessage?.id) {
+        await discordRequest(token, 'PATCH', `/channels/${channelId}/messages/${promptMessage.id}`, {
+          content: `⏳ **Approval Request Expired (${timeoutSeconds}s):** \`${action}\` was automatically cancelled.`,
+          components: []
+        }).catch(() => { });
+      }
+
+      return {
+        approved: false,
+        action,
+        error: `Timed out waiting for approval after ${timeoutSeconds} seconds`
+      };
+    }
+  }
+
+  // Fail-closed fallback if Gateway WebSocket client is not connected
+  let fallbackText = `⚠️ **Claude Approval Blocked (Gateway Offline)**\n\n`;
+  fallbackText += `Claude requested confirmation for:\n> **Action:** \`${action}\`\n`;
+  if (details) fallbackText += `\`\`\`text\n${details.substring(0, 800)}\n\`\`\`\n`;
+  fallbackText += `🛑 *Action was automatically denied because the Discord Gateway WebSocket is not currently connected to receive interactive button confirmation.*`;
+
+  await discordRequest(token, 'POST', `/channels/${channelId}/messages`, {
+    content: fallbackText
+  }).catch(() => { });
+
+  return {
+    approved: false,
+    action,
+    error: 'Discord Gateway WebSocket is not connected; interactive approval could not be verified (fail-closed).'
+  };
+}
+
+async function handleGetStatus() {
+  const health = getSystemHealth(config.workspace);
+  const gitInfo = await getGitStatusAndDiff(config.workspace);
+
+  return {
+    service: 'Dis-Gravity MCP Server',
+    version: SERVER_VERSION,
+    discordConnected: clientReady,
+    botUser: discordClient?.user?.tag || null,
+    channelId: config.channelId || null,
+    allowedUsersCount: config.allowedUsers.length,
+    workspace: config.workspace,
+    git: {
+      branch: gitInfo.branch,
+      isClean: gitInfo.isClean
+    },
+    host: {
+      platform: health.platform,
+      release: health.release,
+      arch: health.arch,
+      cpu: health.cpu,
+      memory: health.memory,
+      uptimeSeconds: health.uptimeSeconds
+    }
+  };
+}
+
+async function handleRunWorkspaceCommand(args) {
+  const cmd = args.command;
+  if (!cmd) throw new Error('Command string is required');
+  const timeoutMs = (args.timeout_seconds || 30) * 1000;
+  const requireApproval = Boolean(args.require_approval);
+
+  if (requireApproval) {
+    const approval = await handleAskDiscordApproval({
+      action: `Execute shell command: ${cmd}`,
+      details: `Directory: ${config.workspace}\nTimeout: ${args.timeout_seconds || 30}s`,
+      timeout_seconds: 120
+    });
+    if (!approval.approved) {
+      return {
+        executed: false,
+        denied: true,
+        reason: approval.reason || approval.error || 'Execution denied by user'
+      };
+    }
+  }
+
+  const res = await executeShellCommand(cmd, config.workspace, timeoutMs);
+  return {
+    executed: true,
+    code: res.code,
+    stdout: res.stdout,
+    stderr: res.stderr,
+    duration: res.duration,
+    error: res.error
+  };
+}
+
+async function handleGetGitDiff() {
+  return getGitStatusAndDiff(config.workspace);
+}
+
+async function handleRenderTableCard(args) {
+  const headers = args.headers || [];
+  const rows = args.rows || [];
+  const alignments = args.alignments || [];
+  const title = args.title || '📊 Dis-Gravity Data Table';
+
+  const pngBuf = await renderTableToPng(headers, rows, alignments, title);
+  if (!pngBuf) {
+    throw new Error('Headless browser not found on host system to render table card.');
+  }
+
+  let deliveredToDiscord = false;
+  if (config.token && config.channelId) {
+    try {
+      await discordMultipartRequest(
+        config.token,
+        'POST',
+        `/channels/${config.channelId}/messages`,
+        { content: `📊 **${title}**` },
+        [{ name: 'table-card.png', buffer: pngBuf }]
+      );
+      deliveredToDiscord = true;
+    } catch (err) {
+      log('Could not upload rendered table card to Discord:', err.message);
+    }
+  }
+
+  return {
+    rendered: true,
+    deliveredToDiscord,
+    sizeBytes: pngBuf.length,
+    rowCount: rows.length,
+    columnCount: headers.length
+  };
+}
+
+async function handleReadWorkspaceFile(args) {
+  const filePath = args.path;
+  if (!filePath) throw new Error('path parameter is required');
+  const maxBytes = args.max_bytes || 100 * 1024;
+  return readWorkspaceFile(config.workspace, filePath, maxBytes);
+}
+
+async function handleListWorkspaceTree(args) {
+  const subDir = args.sub_dir || '.';
+  const maxDepth = args.max_depth || 2;
+  const tree = listWorkspaceTree(config.workspace, subDir, maxDepth);
+  return { tree };
+}
+
+async function handleGetIncomingMessages() {
+  return {
+    count: incomingMessages.length,
+    messages: incomingMessages
+  };
+}
+
+async function handleSetupDiscordBridge(args) {
+  const token = cleanBotToken(args.bot_token || '');
+  if (!token) {
+    throw new Error('bot_token is required to run setup wizard.');
+  }
+  if (!looksLikeBotToken(token)) {
+    throw new Error('Invalid Discord Bot Token format. A valid token typically looks like: [24+ chars].[6 chars].[27+ chars]');
+  }
+
+  const channelName = (args.channel_name || 'dis-gravity').trim();
+  const openBrowserRequested = args.open_browser !== false;
+
+  const result = {
+    step: 'started',
+    botTag: null,
+    appName: null,
+    messageContentIntent: null,
+    guildName: null,
+    guildId: null,
+    channelName: null,
+    channelId: null,
+    whitelistedUserId: null,
+    inviteUrl: null,
+    connected: false
+  };
+
+  // 1. Ensure Message Content Intent
+  const intentRes = await ensureMessageContentIntent(token).catch(e => ({ success: false, message: e.message }));
+  result.messageContentIntent = intentRes?.alreadyEnabled ? 'already_enabled' : (intentRes?.autoEnabled ? 'auto_enabled' : 'manual_required');
+
+  // 2. Inspect application
+  const app = await inspectApplication(token);
+  result.botTag = app.botTag;
+  result.appName = app.appName;
+  result.whitelistedUserId = app.ownerId;
+
+  // 3. Check guild join status
+  const guilds = await listUserGuilds(token).catch(() => []);
+  let targetGuild = null;
+
+  if (args.guild_id) {
+    targetGuild = guilds.find(g => g.id === args.guild_id) || { id: args.guild_id };
+  } else if (guilds.length > 0) {
+    targetGuild = guilds[0];
+  }
+
+  // If not joined to any guild, generate invite link and optionally open browser
+  if (!targetGuild) {
+    const inviteUrl = buildInviteUrl(app.appId);
+    result.inviteUrl = inviteUrl;
+
+    if (openBrowserRequested) {
+      try { openBrowser(inviteUrl); } catch { }
+    }
+
+    try {
+      // Wait up to 30 seconds for user to authorize in browser
+      targetGuild = await waitForGuildJoin(token, { timeoutMs: 30000 });
+    } catch {
+      return {
+        ...result,
+        step: 'awaiting_server_join',
+        message: `Bot @${app.botTag} is not yet added to a server. Please open the invite link to authorize it, then run this tool again.`,
+        inviteUrl
+      };
+    }
+  }
+
+  result.guildName = targetGuild.name || 'Discord Server';
+  result.guildId = targetGuild.id;
+
+  // 4. Find or create channel
+  const channelRes = await findOrCreateChannel(token, targetGuild.id, {
+    channelName,
+    botId: app.botId,
+    ownerId: app.ownerId
+  });
+
+  result.channelName = `#${channelRes.channel.name}`;
+  result.channelId = channelRes.channel.id;
+
+  // 5. Update active config
+  config.token = token;
+  config.channelId = channelRes.channel.id;
+  config.guildId = targetGuild.id;
+  if (!config.allowedUsers || config.allowedUsers.length === 0) {
+    config.allowedUsers = app.ownerId ? [app.ownerId] : [];
+  }
+
+  // 6. Save config to ~/.dis-gravity/config.json
+  saveConfig({
+    token: config.token,
+    channelId: config.channelId,
+    guildId: config.guildId,
+    allowedUsers: config.allowedUsers,
+    workspace: config.workspace
+  });
+
+  // 7. Send welcome message
+  await sendWelcomeMessage(token, config.channelId, {
+    ownerIds: config.allowedUsers,
+    provider: 'Claude Desktop MCP'
+  }).catch(() => { });
+
+  // 8. Connect Discord client live
+  discordInitStarted = true;
+  await initDiscordClient();
+  result.connected = clientReady || Boolean(discordClient);
+  result.step = 'completed';
+
+  return result;
+}
+
+// JSON-RPC Dispatcher
+function sendResponse(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+async function handleRpc(req) {
+  const { id, method, params } = req;
+
+  // Handle Notifications (no response needed) — note: id === 0 is a valid JSON-RPC request ID!
+  if ((id === undefined || id === null) && method) {
+    if (method === 'notifications/initialized') {
+      log('Client initialized notification received.');
+      ensureDiscordStarted();
+    }
+    return;
+  }
+
+  try {
+    switch (method) {
+      case 'initialize': {
+        const requestedVersion = params?.protocolVersion;
+        const negotiatedVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion)
+          ? requestedVersion
+          : '2024-11-05';
+
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            protocolVersion: negotiatedVersion,
+            capabilities: {
+              tools: {},
+              resources: {},
+              prompts: {}
+            },
+            serverInfo: {
+              name: 'dis-gravity',
+              version: SERVER_VERSION
+            }
+          }
+        });
+
+        // Start Discord Gateway connection asynchronously after handshake response is sent
+        ensureDiscordStarted();
+        break;
+      }
+
+      case 'ping':
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {}
+        });
+        break;
+
+      case 'resources/list':
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            resources: [
+              {
+                uri: 'discord://chat',
+                name: 'Discord Live Messages',
+                description: 'Recent incoming messages and instructions sent from developers in Discord',
+                mimeType: 'application/json'
+              },
+              {
+                uri: 'discord://latest-prompt',
+                name: 'Discord Latest Prompt',
+                description: 'The most recent command or prompt sent from Discord',
+                mimeType: 'text/plain'
+              }
+            ]
+          }
+        });
+        break;
+
+      case 'resources/templates/list':
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            resourceTemplates: []
+          }
+        });
+        break;
+
+      case 'prompts/list':
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            prompts: PROMPTS
+          }
+        });
+        break;
+
+      case 'prompts/get': {
+        const promptName = params?.name;
+        const promptArgs = params?.arguments || {};
+
+        if (promptName === 'setup-discord-bridge') {
+          const tokenArg = cleanBotToken(promptArgs.bot_token || '');
+          const channelArg = (promptArgs.channel_name || 'dis-gravity').trim();
+          const promptText = tokenArg
+            ? `Please run the Dis-Gravity onboarding wizard now by calling the \`setup_discord_bridge\` tool with \`bot_token: "${tokenArg}"\` and \`channel_name: "${channelArg}"\`, then report the connected server, private channel, and security whitelist status.`
+            : `Please help me set up the Dis-Gravity Discord Bridge using the interactive wizard:\n1. First call \`get_discord_bridge_status\` to check if a token/channel is already configured.\n2. If not configured, guide me in 3 quick steps to get a Discord Bot Token from https://discord.com/developers/applications (New Application -> Bot -> Reset Token -> Copy Token).\n3. As soon as I provide my Bot Token, call the \`setup_discord_bridge\` tool so Dis-Gravity automatically enables Message Content Intent, opens the server invite link, creates the private locked \`#dis-gravity\` channel, whitelists my Discord User ID, and connects the live bridge.`;
+
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              description: 'Dis-Gravity Interactive Setup Wizard',
+              messages: [
+                {
+                  role: 'user',
+                  content: {
+                    type: 'text',
+                    text: promptText
+                  }
+                }
+              ]
+            }
+          });
+        } else if (promptName === 'discord-bridge-status') {
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              description: 'Check Dis-Gravity Discord bridge status and send a test ping',
+              messages: [
+                {
+                  role: 'user',
+                  content: {
+                    type: 'text',
+                    text: 'Please check the Dis-Gravity Discord bridge status using `get_discord_bridge_status`. If connected, send a quick test notification to Discord using `notify_discord` to confirm mobile delivery.'
+                  }
+                }
+              ]
+            }
+          });
+        } else {
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            error: {
+              code: -32602,
+              message: `Unknown prompt: ${promptName}`
+            }
+          });
+        }
+        break;
+      }
+
+      case 'resources/read': {
+        const uri = params?.uri;
+        if (uri === 'discord://chat') {
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              contents: [
+                {
+                  uri: 'discord://chat',
+                  mimeType: 'application/json',
+                  text: JSON.stringify(incomingMessages, null, 2)
+                }
+              ]
+            }
+          });
+        } else if (uri === 'discord://latest-prompt') {
+          const latest = incomingMessages[incomingMessages.length - 1];
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            result: {
+              contents: [
+                {
+                  uri: 'discord://latest-prompt',
+                  mimeType: 'text/plain',
+                  text: latest ? latest.content : ''
+                }
+              ]
+            }
+          });
+        } else {
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            error: {
+              code: -32602,
+              message: `Unknown resource URI: ${uri}`
+            }
+          });
+        }
+        break;
+      }
+
+      case 'tools/list':
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            tools: TOOLS
+          }
+        });
+        break;
+
+      case 'tools/call': {
+        ensureDiscordStarted();
+        const name = params?.name;
+        const args = params?.arguments || {};
+        let result;
+
+        if (name === 'notify_discord') {
+          result = await handleNotifyDiscord(args);
+        } else if (name === 'ask_discord_approval') {
+          result = await handleAskDiscordApproval(args);
+        } else if (name === 'get_discord_bridge_status') {
+          result = await handleGetStatus();
+        } else if (name === 'run_workspace_command') {
+          result = await handleRunWorkspaceCommand(args);
+        } else if (name === 'get_git_diff') {
+          result = await handleGetGitDiff();
+        } else if (name === 'render_table_card') {
+          result = await handleRenderTableCard(args);
+        } else if (name === 'read_workspace_file') {
+          result = await handleReadWorkspaceFile(args);
+        } else if (name === 'list_workspace_tree') {
+          result = await handleListWorkspaceTree(args);
+        } else if (name === 'get_incoming_messages') {
+          result = await handleGetIncomingMessages();
+        } else if (name === 'setup_discord_bridge') {
+          result = await handleSetupDiscordBridge(args);
+        } else {
+          sendResponse({
+            jsonrpc: '2.0',
+            id,
+            error: {
+              code: -32601,
+              message: `Unknown tool: ${name}`
+            }
+          });
+          return;
+        }
+
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          result: {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          }
+        });
+        break;
+      }
+
+      default:
+        sendResponse({
+          jsonrpc: '2.0',
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`
+          }
+        });
+        break;
+    }
+  } catch (err) {
+    sendResponse({
+      jsonrpc: '2.0',
+      id,
+      result: {
+        content: [
+          {
+            type: 'text',
+            text: `❌ Error: ${err.message}`
+          }
+        ],
+        isError: true
+      }
+    });
+  }
+}
+
+// Start stdio reader
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  terminal: false
+});
+
+rl.on('line', (line) => {
+  const trimmed = line.trim();
+  if (!trimmed) return;
+  try {
+    const request = JSON.parse(trimmed);
+    handleRpc(request);
+  } catch (err) {
+    sendResponse({
+      jsonrpc: '2.0',
+      id: 0,
+      error: { code: -32700, message: 'Parse error: ' + err.message }
+    });
+  }
+});
+
+log('Dis-Gravity MCP Server started on stdio.');