agent-window 1.0.0

package/src/bot.js

@@ -0,0 +1,1518 @@
+/**
+ * AgentBridge - Bridge AI coding agents to chat platforms
+ *
+ * Features:
+ * - Docker sandbox isolation for secure CLI execution
+ * - Permission system with chat-based approval buttons
+ * - Session management with channel binding
+ * - Multi-agent support (Claude Code, Codex, OpenCode)
+ *
+ * Commands:
+ *   @bot <message>       - Send message (continues last conversation)
+ *   @bot -n <message>    - Start new conversation
+ *   @bot -r <id> [msg]   - Resume specific session
+ *   @bot /pick           - Choose session (button UI)
+ *   @bot /sessions       - List recent sessions
+ *   @bot /status         - Check bot status
+ *   @bot /help           - Show help
+ */
+
+import { Client, GatewayIntentBits, Partials, Events, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
+import { spawn, execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync, mkdirSync } from 'fs';
+import { join } from 'path';
+
+// Import centralized configuration
+import config from './core/config.js';
+
+// Import performance monitoring
+import { createMonitor, formatMonitorSummary } from './core/perf-monitor.js';
+
+// Extract commonly used config values for convenience
+const BOT_TOKEN = config.discord.token;
+const PROJECT_DIR = config.workspace.projectDir;
+const OAUTH_TOKEN = config.backend.oauthToken;
+const ALLOWED_CHANNELS = config.discord.allowedChannels;
+const CHANNEL_SESSIONS_FILE = config.paths.sessions;
+const PENDING_DIR = config.paths.pending;
+const HOOK_DIR = config.paths.hooks;
+const CONTAINER_NAME = config.workspace.containerName;
+const DOCKER_IMAGE = config.workspace.dockerImage;
+
+// Docker container internal paths
+const CONTAINER_WORKSPACE = config.docker.containerPaths.workspace;
+const CONTAINER_CONFIG_DIR = config.docker.containerPaths.configDir;
+const CONTAINER_HOOK_DIR = config.docker.containerPaths.hookDir;
+const CONTAINER_PENDING_DIR = config.docker.containerPaths.pendingDir;
+const CONTAINER_SETTINGS_FILE = config.docker.containerPaths.settingsFile;
+const PORT_MAPPINGS = config.workspace.portMappings;
+const CLI_MAX_TURNS = config.cli.maxTurns;
+const CLI_COMMAND = config.cli.command;
+const CLI_TASK_TIMEOUT = config.cli.taskTimeout;
+const PERMISSION_POLL_INTERVAL = config.permissions.pollInterval;
+const DOCKER_CHECK_TIMEOUT = config.docker.checkTimeout;
+const STATUS_UPDATE_THROTTLE = config.ui.statusUpdateThrottle;
+const THEME = config.ui.theme;
+
+// Platform configuration
+const PLATFORM = config.platform.type;
+const MESSAGE_MAX_LENGTH = config.platform.messageMaxLength;
+const RETRY_DELAY = config.platform.retryDelay;
+const PREVIEW_LENGTHS = config.platform.previewLengths;
+
+// Track active tasks and their channels
+const activeTasks = new Map();
+const messageQueues = new Map();
+const pendingPermissions = new Map(); // requestId -> { channelId, message }
+
+let containerReady = false;
+
+// Ensure pending directory exists
+try {
+  mkdirSync(PENDING_DIR, { recursive: true });
+} catch (e) {}
+
+// Check if persistent container exists and is running
+function isContainerRunning() {
+  try {
+    const result = execSync(
+      `docker inspect -f '{{.State.Running}}' ${CONTAINER_NAME} 2>/dev/null`,
+      { encoding: 'utf-8' }
+    ).trim();
+    return result === 'true';
+  } catch (e) {
+    return false;
+  }
+}
+
+// Start or ensure persistent container is running
+function ensureContainer() {
+  // Log the paths being used
+  console.log('[Docker] PENDING_DIR (host):', PENDING_DIR);
+  console.log('[Docker] HOOK_DIR (host):', HOOK_DIR);
+
+  if (isContainerRunning()) {
+    // Verify the container has correct mounts by checking if we can see our pending dir
+    console.log('[Docker] Container already running, verifying mounts...');
+    try {
+      // Create a test file and check if container can see it
+      const testFile = join(PENDING_DIR, '.mount-test');
+      writeFileSync(testFile, 'test');
+      const result = execSync(
+        `docker exec ${CONTAINER_NAME} cat ${CONTAINER_PENDING_DIR}/.mount-test 2>/dev/null`,
+        { encoding: 'utf-8', timeout: DOCKER_CHECK_TIMEOUT }
+      ).trim();
+      unlinkSync(testFile);
+      if (result === 'test') {
+        console.log('[Docker] Mount verification: OK');
+        return true;
+      }
+    } catch (e) {
+      console.log('[Docker] Mount verification failed, restarting container...');
+      stopContainer();
+      // Fall through to create new container
+    }
+  }
+
+  console.log('[Docker] Starting persistent container...');
+  try {
+    // Remove old container if exists
+    try {
+      execSync(`docker rm -f ${CONTAINER_NAME} 2>/dev/null`);
+    } catch (e) {}
+
+    // Start new persistent container
+    const portArgs = PORT_MAPPINGS.map(p => `-p ${p}`).join(' ');
+    const envArgs = Object.entries(config.docker.env)
+      .map(([k, v]) => `-e '${k}=${v}'`)
+      .join(' ');
+
+    const dockerCmd = [
+      'docker', 'run', '-d',
+      '--name', CONTAINER_NAME,
+      portArgs,
+      '--user', `${process.getuid()}:${process.getgid()}`,
+      '-v', `${PROJECT_DIR}:${CONTAINER_WORKSPACE}:rw`,
+      '-v', `${config.backend.configDir}:${CONTAINER_CONFIG_DIR}:rw`,
+      '-v', `${HOOK_DIR}:${CONTAINER_HOOK_DIR}:ro`,
+      '-v', `${PENDING_DIR}:${CONTAINER_PENDING_DIR}:rw`,
+      `-e 'CLAUDE_CODE_OAUTH_TOKEN=${OAUTH_TOKEN || ''}'`,
+      envArgs,
+      '--entrypoint', 'tail',
+      DOCKER_IMAGE,
+      '-f', '/dev/null'
+    ].join(' ');
+
+    execSync(dockerCmd);
+    console.log('[Docker] Container started successfully');
+    return true;
+  } catch (e) {
+    console.error('[Docker] Failed to start container:', e.message);
+    return false;
+  }
+}
+
+// Stop persistent container (call on bot shutdown)
+function stopContainer() {
+  try {
+    execSync(`docker stop ${CONTAINER_NAME} 2>/dev/null`);
+    execSync(`docker rm ${CONTAINER_NAME} 2>/dev/null`);
+    console.log('[Docker] Container stopped');
+  } catch (e) {}
+}
+
+// Cleanup on exit
+process.on('SIGINT', () => {
+  console.log('Shutting down...');
+  stopContainer();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  stopContainer();
+  process.exit(0);
+});
+
+// Load channel-session mappings
+function loadChannelSessions() {
+  try {
+    if (existsSync(CHANNEL_SESSIONS_FILE)) {
+      return JSON.parse(readFileSync(CHANNEL_SESSIONS_FILE, 'utf-8'));
+    }
+  } catch (e) {
+    console.error('[Sessions] Failed to load:', e.message);
+  }
+  return {};
+}
+
+// Save channel-session mappings
+function saveChannelSessions(sessions) {
+  try {
+    writeFileSync(CHANNEL_SESSIONS_FILE, JSON.stringify(sessions, null, 2));
+  } catch (e) {
+    console.error('[Sessions] Failed to save:', e.message);
+  }
+}
+
+// Get session ID for a channel
+function getChannelSession(channelId) {
+  const sessions = loadChannelSessions();
+  return sessions[channelId] || null;
+}
+
+// Set session ID for a channel
+function setChannelSession(channelId, sessionId) {
+  const sessions = loadChannelSessions();
+  sessions[channelId] = sessionId;
+  saveChannelSessions(sessions);
+  console.log(`[Sessions] Channel ${channelId} bound to session ${sessionId.substring(0, 8)}...`);
+}
+
+// Format elapsed time (excluding blocked time) for display
+function formatElapsedTime(task) {
+  if (!task || !task.startTime) return '';
+  const now = Date.now();
+  const totalElapsed = now - task.startTime;
+  const blocked = task.blockedTime + (task.lastBlockStart ? (now - task.lastBlockStart) : 0);
+  const activeTime = Math.max(0, totalElapsed - blocked);
+
+  const seconds = Math.floor(activeTime / 1000);
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m${remainingSeconds}s`;
+}
+
+// Initialize client
+const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.DirectMessages,
+  ],
+  partials: [Partials.Channel, Partials.Message],
+});
+
+// Parse a single JSON line from stream
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line.trim());
+  } catch (e) {
+    return null;
+  }
+}
+
+// Extract text content from assistant message
+function extractAssistantText(msg) {
+  if (!msg.message?.content) return '';
+  return msg.message.content
+    .filter(c => c.type === 'text')
+    .map(c => c.text)
+    .join('\n');
+}
+
+// Format permission request for display
+function formatPermissionRequest(request) {
+  const { tool_name, input } = request;
+  const cmdLen = PREVIEW_LENGTHS.command;
+  const fileLen = PREVIEW_LENGTHS.fileContent;
+  const editLen = PREVIEW_LENGTHS.editPreview;
+  const jsonLen = PREVIEW_LENGTHS.jsonInput;
+
+  let description = '';
+  switch (tool_name) {
+    case 'Bash':
+      const cmd = input.command || '';
+      description = `**Command:**\n\`\`\`bash\n${cmd.substring(0, cmdLen)}${cmd.length > cmdLen ? '...' : ''}\n\`\`\``;
+      break;
+    case 'Write':
+      const wPath = input.file_path || '';
+      const wContent = input.content || '';
+      description = `**File:** \`${wPath}\`\n**Content preview:**\n\`\`\`\n${wContent.substring(0, fileLen)}${wContent.length > fileLen ? '...' : ''}\n\`\`\``;
+      break;
+    case 'Edit':
+      const ePath = input.file_path || '';
+      const oldStr = input.old_string || '';
+      const newStr = input.new_string || '';
+      description = `**File:** \`${ePath}\`\n**Replace:**\n\`\`\`\n${oldStr.substring(0, editLen)}${oldStr.length > editLen ? '...' : ''}\n\`\`\`\n**With:**\n\`\`\`\n${newStr.substring(0, editLen)}${newStr.length > editLen ? '...' : ''}\n\`\`\``;
+      break;
+    case 'NotebookEdit':
+      description = `**Notebook:** \`${input.notebook_path || ''}\`\n**Cell:** ${input.cell_number || 0}`;
+      break;
+    default:
+      description = `**Input:**\n\`\`\`json\n${JSON.stringify(input, null, 2).substring(0, jsonLen)}\n\`\`\``;
+  }
+
+  return description;
+}
+
+// Track completed button clicks to prevent duplicate processing
+const completedClicks = new Set();
+// Track requests being processed (to prevent duplicate Discord messages)
+const processingRequests = new Set();
+
+/**
+ * Clean up all pending permissions for a channel
+ * Called when task completes, errors out, or is cancelled
+ * @param {string} channelId - Discord channel ID
+ * @param {string} reason - Reason for cleanup (for logging)
+ */
+async function cleanupPermissions(channelId, reason = 'task ended') {
+  console.log(`[Permission] Cleaning up permissions for channel ${channelId} (${reason})`);
+
+  // Clean up pending permissions
+  for (const [requestId, perm] of pendingPermissions) {
+    if (perm.channelId === channelId) {
+      try {
+        // Update the permission card to show cancelled/timeout
+        await perm.message.edit({
+          embeds: [{
+            title: '⚠️ Cancelled',
+            description: `Task ${reason}. Permission request automatically cancelled.`,
+            color: THEME.warning,
+          }],
+          components: [],
+        });
+      } catch (e) {
+        // Message might have been deleted, ignore
+      }
+
+      // Clean up request files
+      try {
+        unlinkSync(join(PENDING_DIR, `${requestId}.request.json`));
+      } catch (e) {}
+      try {
+        unlinkSync(join(PENDING_DIR, `${requestId}.response.json`));
+      } catch (e) {}
+
+      pendingPermissions.delete(requestId);
+      processingRequests.delete(requestId);
+      completedClicks.add(requestId);
+    }
+  }
+}
+
+// Watch for permission requests from MCP server
+function startPermissionWatcher() {
+  console.log('[Permission] Starting watcher for:', PENDING_DIR);
+
+  // Poll directory for new request files
+  setInterval(async () => {
+    try {
+      const files = readdirSync(PENDING_DIR);
+      for (const file of files) {
+        if (!file.endsWith('.request.json')) continue;
+
+        const requestId = file.replace('.request.json', '');
+        // Skip if already processing or already have Discord message
+        if (processingRequests.has(requestId) || pendingPermissions.has(requestId)) continue;
+
+        // Mark as processing IMMEDIATELY (before any async work)
+        processingRequests.add(requestId);
+
+        const requestFile = join(PENDING_DIR, file);
+        try {
+          const request = JSON.parse(readFileSync(requestFile, 'utf-8'));
+          console.log(`[Permission] New request: ${request.tool_name} (${requestId.substring(0, 8)}...)`);
+
+          // Find the channel that has an active task
+          let targetChannelId = null;
+          for (const [channelId, task] of activeTasks) {
+            targetChannelId = channelId;
+            break;
+          }
+
+          if (!targetChannelId) {
+            console.error('[Permission] No active task channel found');
+            processingRequests.delete(requestId);
+            continue;
+          }
+
+          const channel = await client.channels.fetch(targetChannelId);
+          if (!channel) {
+            console.error('[Permission] Channel not found:', targetChannelId);
+            processingRequests.delete(requestId);
+            continue;
+          }
+
+          // Create buttons
+          const row = new ActionRowBuilder()
+            .addComponents(
+              new ButtonBuilder()
+                .setCustomId(`perm_allow_${requestId}`)
+                .setLabel('Allow')
+                .setEmoji('✅')
+                .setStyle(ButtonStyle.Success),
+              new ButtonBuilder()
+                .setCustomId(`perm_deny_${requestId}`)
+                .setLabel('Deny')
+                .setEmoji('❌')
+                .setStyle(ButtonStyle.Danger),
+            );
+
+          // Send permission request message with retry
+          const description = formatPermissionRequest(request);
+          let msg = null;
+          let retries = 3;
+          while (retries > 0 && !msg) {
+            try {
+              msg = await channel.send({
+                embeds: [{
+                  title: `🔒 Permission: ${request.tool_name}`,
+                  description: description,
+                  color: THEME.warning,
+                  footer: { text: `ID: ${requestId.substring(0, 8)}` },
+                }],
+                components: [row],
+              });
+            } catch (sendErr) {
+              retries--;
+              console.error(`[Permission] Send failed (${retries} retries left):`, sendErr.message);
+              if (retries > 0) await new Promise(r => setTimeout(r, RETRY_DELAY));
+            }
+          }
+
+          if (!msg) {
+            console.error('[Permission] Failed to send after retries, skipping');
+            processingRequests.delete(requestId);
+            continue;
+          }
+
+          // Mark as pending AFTER successfully sending message
+          pendingPermissions.set(requestId, {
+            channelId: targetChannelId,
+            message: msg,
+            request,
+          });
+
+          // Update task status - move status to bottom by re-sending
+          const task = activeTasks.get(targetChannelId);
+          if (task && !task.aborted) {
+            // Start tracking blocked time
+            task.lastBlockStart = Date.now();
+
+            // Delete old status message and send new one below permission card
+            if (task.statusMsg && task.channel) {
+              try {
+                await task.statusMsg.delete();
+              } catch (e) {}
+
+              // Send new status message (will appear below permission card)
+              const elapsed = formatElapsedTime(task);
+              const statusText = `🔒 Waiting for permission: ${request.tool_name}`;
+              const statusWithTime = elapsed ? `${statusText}\n⏱️ ${elapsed}` : statusText;
+              task.statusMsg = await task.channel.send({
+                content: statusWithTime,
+                components: [task.stopButton],
+              });
+            }
+          }
+
+        } catch (e) {
+          console.error('[Permission] Error processing request:', e.message);
+          processingRequests.delete(requestId);
+        }
+      }
+    } catch (e) {
+      // Directory might not exist yet
+    }
+  }, PERMISSION_POLL_INTERVAL);
+}
+
+// Track processed session button clicks to prevent duplicates
+const processedSessionClicks = new Set();
+// Track processed stop button clicks to prevent duplicates
+const processedStopClicks = new Set();
+
+// Handle button interactions
+client.on(Events.InteractionCreate, async (interaction) => {
+  if (!interaction.isButton()) return;
+
+  const customId = interaction.customId;
+
+  // Handle session selection buttons
+  if (customId.startsWith('session_')) {
+    // CRITICAL: Acknowledge interaction FIRST within 3-second Discord limit
+    try { await interaction.deferUpdate(); } catch (e) {}
+
+    // Generate unique click ID (messageId + customId)
+    const clickId = `${interaction.message.id}_${customId}`;
+
+    // Check if already processed
+    if (processedSessionClicks.has(clickId)) {
+      console.log('[Session] Duplicate click ignored');
+      return;
+    }
+
+    // Mark as processed IMMEDIATELY
+    processedSessionClicks.add(clickId);
+
+    const channelId = interaction.channelId;
+    const originalMessage = interaction.message;
+
+    if (customId === 'session_new') {
+      console.log('[Session] User selected: new session');
+
+      // Clear saved session for this channel
+      const sessions = loadChannelSessions();
+      delete sessions[channelId];
+      saveChannelSessions(sessions);
+
+      // Update card using direct message.edit()
+      try {
+        await originalMessage.edit({
+          embeds: [{
+            title: '✨ New Session Ready',
+            description: 'Next message will start a fresh conversation.',
+            color: THEME.success,
+          }],
+          components: [],
+        });
+      } catch (e) {
+        console.log('[Session] Card update failed:', e.message);
+      }
+
+    } else if (customId.startsWith('session_resume_')) {
+      const sessionId = customId.replace('session_resume_', '');
+      console.log('[Session] User selected: resume', sessionId.substring(0, 8));
+
+      setChannelSession(channelId, sessionId);
+
+      try {
+        await originalMessage.edit({
+          embeds: [{
+            title: '▶️ Session Selected',
+            description: `Next message will continue session \`${sessionId.substring(0, 8)}...\``,
+            color: THEME.success,
+          }],
+          components: [],
+        });
+      } catch (e) {
+        console.log('[Session] Card update failed:', e.message);
+      }
+    }
+
+    // Clean up old processed clicks (keep last 100)
+    if (processedSessionClicks.size > 100) {
+      const arr = Array.from(processedSessionClicks);
+      arr.slice(0, arr.length - 100).forEach(id => processedSessionClicks.delete(id));
+    }
+
+    return;
+  }
+
+  // Handle stop button
+  if (customId.startsWith('stop_')) {
+    // CRITICAL: Acknowledge interaction FIRST within 3-second Discord limit
+    try { await interaction.deferUpdate(); } catch (e) {}
+
+    // Generate unique click ID (messageId + customId)
+    const clickId = `${interaction.message.id}_${customId}`;
+
+    // Check if already processed
+    if (processedStopClicks.has(clickId)) {
+      console.log('[Stop] Duplicate click ignored');
+      return;
+    }
+
+    // Mark as processed IMMEDIATELY
+    processedStopClicks.add(clickId);
+
+    const targetChannelId = customId.replace('stop_', '');
+    console.log('[Stop] User clicked stop for channel:', targetChannelId);
+
+    const task = activeTasks.get(targetChannelId);
+    const originalMessage = interaction.message;
+
+    if (task) {
+      task.aborted = true;
+      if (task.child && !task.child.killed) {
+        task.child.kill('SIGTERM');
+        console.log('[Stop] Task aborted');
+      }
+
+      // Update card using direct message.edit()
+      try {
+        await originalMessage.edit({
+          content: '⏹️ Task stopped by user',
+          components: [],
+        });
+      } catch (e) {
+        console.log('[Stop] Card update failed:', e.message);
+      }
+    }
+
+    // Clean up old processed clicks (keep last 100)
+    if (processedStopClicks.size > 100) {
+      const arr = Array.from(processedStopClicks);
+      arr.slice(0, arr.length - 100).forEach(id => processedStopClicks.delete(id));
+    }
+
+    return;
+  }
+
+  // Handle permission buttons
+  if (!customId.startsWith('perm_')) return;
+
+  const parts = customId.split('_');
+  const action = parts[1]; // 'allow' or 'deny'
+  const requestId = parts.slice(2).join('_');
+
+  console.log(`[Permission] Button clicked: ${action} for ${requestId.substring(0, 8)}`);
+
+  // Check if already clicked (duplicate click protection)
+  if (completedClicks.has(requestId)) {
+    console.log('[Permission] Duplicate click ignored:', requestId.substring(0, 8));
+    try { await interaction.deferUpdate(); } catch (e) {}
+    return;
+  }
+
+  // Mark as clicked IMMEDIATELY to prevent race conditions
+  completedClicks.add(requestId);
+
+  const pending = pendingPermissions.get(requestId);
+  if (!pending) {
+    console.log('[Permission] Request not found in pending:', requestId.substring(0, 8));
+    try { await interaction.deferUpdate(); } catch (e) {}
+    return;
+  }
+
+  // STEP 1: Immediately remove buttons (best UX - instant feedback)
+  try {
+    await interaction.update({ components: [] });
+    console.log('[Permission] Buttons removed immediately');
+  } catch (e) {
+    // Fallback to deferUpdate if update fails
+    try { await interaction.deferUpdate(); } catch (e2) {}
+    try { await pending.message.edit({ components: [] }); } catch (e3) {}
+  }
+
+  // STEP 2: Write response file
+  const response = action === 'allow'
+    ? { behavior: 'allow' }
+    : { behavior: 'deny', message: 'User denied permission' };
+
+  const responseFile = join(PENDING_DIR, `${requestId}.response.json`);
+
+  // Also delete request file to prevent re-detection by watcher
+  const requestFile = join(PENDING_DIR, `${requestId}.request.json`);
+
+  try {
+    writeFileSync(responseFile, JSON.stringify(response));
+    console.log(`[Permission] Response file written: ${action}`);
+    // Delete request file immediately to prevent re-detection
+    try { unlinkSync(requestFile); } catch (e) {}
+  } catch (writeErr) {
+    console.error('[Permission] Failed to write response file:', writeErr.message);
+    // Remove from clicked so user can retry
+    completedClicks.delete(requestId);
+    // Send new permission card
+    try {
+      const row = new ActionRowBuilder()
+        .addComponents(
+          new ButtonBuilder()
+            .setCustomId(`perm_allow_${requestId}`)
+            .setLabel('Allow')
+            .setEmoji('✅')
+            .setStyle(ButtonStyle.Success),
+          new ButtonBuilder()
+            .setCustomId(`perm_deny_${requestId}`)
+            .setLabel('Deny')
+            .setEmoji('❌')
+            .setStyle(ButtonStyle.Danger),
+        );
+      await pending.message.channel.send({
+        content: '⚠️ Permission write failed, please try again:',
+        embeds: [pending.message.embeds[0]],
+        components: [row],
+      });
+    } catch (e) {}
+    return;
+  }
+
+  // STEP 3: Update card to show final status
+  const statusEmoji = action === 'allow' ? '✅' : '❌';
+  const statusText = action === 'allow' ? 'Allowed' : 'Denied';
+  const color = action === 'allow' ? THEME.success : THEME.error;
+
+  try {
+    await pending.message.edit({
+      embeds: [{
+        title: `${statusEmoji} ${statusText}: ${pending.request.tool_name}`,
+        description: formatPermissionRequest(pending.request),
+        color: color,
+        footer: { text: `ID: ${requestId.substring(0, 8)}` },
+      }],
+    });
+    console.log('[Permission] Card updated with status');
+  } catch (e) {
+    console.log('[Permission] Card status update failed (OK, permission granted):', e.message);
+  }
+
+  // Remove from pending and processing
+  pendingPermissions.delete(requestId);
+  processingRequests.delete(requestId);
+  console.log(`[Permission] Completed: ${action} ${requestId.substring(0, 8)}`);
+
+  // Update task status to show permission was handled
+  // Update task timing and status
+  const task = activeTasks.get(pending.channelId);
+  if (task && !task.aborted) {
+    // Stop tracking blocked time
+    if (task.lastBlockStart) {
+      task.blockedTime += Date.now() - task.lastBlockStart;
+      task.lastBlockStart = null;
+    }
+    if (action === 'allow' && task.updateStatus) {
+      await task.updateStatus(`✅ Permission granted: ${pending.request.tool_name}\n⏳ Continuing...`, true);
+    }
+  }
+
+  // Clean up old completed clicks (keep last 200)
+  if (completedClicks.size > 200) {
+    const arr = Array.from(completedClicks);
+    arr.slice(0, arr.length - 200).forEach(id => completedClicks.delete(id));
+  }
+});
+
+// Command handlers
+const commands = {
+  async help(message) {
+    const helpText = `**AgentBridge** - AI Coding Agent Bridge
+
+**Usage:**
+\`@bot <message>\` - Send message (continues last session)
+\`@bot -n <message>\` - Start new session
+\`@bot -r <session_id> [message]\` - Resume specific session
+
+**Security:**
+🐳 Docker sandbox isolation
+🔒 Permission approval for dangerous operations
+⚡ Persistent container for fast response
+
+**Auto-approved:** Read, Glob, Grep, WebFetch, WebSearch, Task
+**Needs approval:** Write, Edit, Bash, NotebookEdit
+
+**Commands:**
+\`@bot /pick\` - Choose session (new or resume)
+\`@bot /sessions\` - List all recent sessions
+\`@bot /status\` - Check bot status
+\`@bot /help\` - Show this help`;
+
+    await message.channel.send({
+      embeds: [{
+        title: 'Help',
+        description: helpText,
+        color: THEME.info,
+      }]
+    });
+  },
+
+  async pick(message) {
+    await commands.showSessionPicker(message);
+  },
+
+  async status(message) {
+    const uptime = process.uptime();
+    const hours = Math.floor(uptime / 3600);
+    const minutes = Math.floor((uptime % 3600) / 60);
+    const containerRunning = isContainerRunning();
+
+    const statusText = `**Status**: Online
+**Mode**: Docker Sandbox + Hooks Permission
+**Uptime**: ${hours}h ${minutes}m
+**Container**: ${CONTAINER_NAME} (${containerRunning ? '🟢 running' : '🔴 stopped'})
+**Project**: ${PROJECT_DIR}
+**Workspace**: ${CONTAINER_WORKSPACE}
+**OAuth**: ${OAUTH_TOKEN ? 'configured' : 'not set'}`;
+
+    await message.channel.send({
+      embeds: [{
+        title: 'Bot Status',
+        description: statusText,
+        color: containerRunning ? THEME.success : THEME.error,
+      }]
+    });
+  },
+
+  async sessions(message) {
+    try {
+      // Sessions are stored on host, use host path
+      const projectPath = PROJECT_DIR.replace(/\//g, '-');
+      const sessionsFile = join(config.backend.configDir, 'projects', projectPath, 'sessions-index.json');
+
+      if (!existsSync(sessionsFile)) {
+        await message.channel.send('No sessions found');
+        return;
+      }
+
+      const data = JSON.parse(readFileSync(sessionsFile, 'utf-8'));
+      const sessions = data.entries || [];
+
+      const recentSessions = sessions
+        .sort((a, b) => new Date(b.modified) - new Date(a.modified))
+        .slice(0, 10);
+
+      if (recentSessions.length === 0) {
+        await message.channel.send('No sessions found');
+        return;
+      }
+
+      const list = recentSessions.map((s, i) => {
+        const date = new Date(s.modified);
+        const dateStr = `${date.getMonth() + 1}/${date.getDate()} ${date.getHours()}:${String(date.getMinutes()).padStart(2, '0')}`;
+        const preview = (s.firstPrompt || '').substring(0, 30).replace(/\n/g, ' ');
+        const shortId = s.sessionId.substring(0, 8);
+        return `**${i + 1}.** ${dateStr}\n\`-r ${shortId}\`\n${preview}${preview.length >= 30 ? '...' : ''}`;
+      }).join('\n\n');
+
+      await message.channel.send({
+        embeds: [{
+          title: `Recent Sessions (${recentSessions.length}/${sessions.length})`,
+          description: list + '\n\n**Usage:** `@bot -r <session_id> <message>`',
+          color: THEME.info,
+        }]
+      });
+    } catch (err) {
+      console.error('Sessions error:', err);
+      await message.channel.send(`Error: ${err.message}`);
+    }
+  },
+
+  // Show session selection card with buttons
+  async showSessionPicker(message) {
+    try {
+      const projectPath = PROJECT_DIR.replace(/\//g, '-');
+      const sessionsFile = join(config.backend.configDir, 'projects', projectPath, 'sessions-index.json');
+
+      let recentSessions = [];
+      if (existsSync(sessionsFile)) {
+        const data = JSON.parse(readFileSync(sessionsFile, 'utf-8'));
+        recentSessions = (data.entries || [])
+          .sort((a, b) => new Date(b.modified) - new Date(a.modified))
+          .slice(0, 3); // Top 3 recent sessions
+      }
+
+      // Create buttons
+      const buttons = [
+        new ButtonBuilder()
+          .setCustomId('session_new')
+          .setLabel('New Session')
+          .setEmoji('✨')
+          .setStyle(ButtonStyle.Primary),
+      ];
+
+      // Add recent session buttons
+      recentSessions.forEach((s, i) => {
+        const preview = (s.firstPrompt || '').substring(0, 20).replace(/\n/g, ' ');
+        buttons.push(
+          new ButtonBuilder()
+            .setCustomId(`session_resume_${s.sessionId}`)
+            .setLabel(`${preview}${preview.length >= 20 ? '...' : ''}`)
+            .setStyle(ButtonStyle.Secondary)
+        );
+      });
+
+      const row = new ActionRowBuilder().addComponents(buttons);
+
+      const description = recentSessions.length > 0
+        ? `Choose to start a new session or continue a recent one:\n\n${recentSessions.map((s, i) => {
+            const date = new Date(s.modified);
+            const dateStr = `${date.getMonth() + 1}/${date.getDate()} ${date.getHours()}:${String(date.getMinutes()).padStart(2, '0')}`;
+            const preview = (s.firstPrompt || '').substring(0, 40).replace(/\n/g, ' ');
+            return `**${i + 1}.** ${dateStr}\n${preview}${preview.length >= 40 ? '...' : ''}`;
+          }).join('\n\n')}`
+        : 'No recent sessions found. Start a new conversation!';
+
+      await message.channel.send({
+        embeds: [{
+          title: '🗂️ Choose Session',
+          description: description,
+          color: THEME.info,
+          footer: { text: 'Select a button or send a message to start' }
+        }],
+        components: [row],
+      });
+    } catch (err) {
+      console.error('Session picker error:', err);
+      await message.channel.send('Starting new session...');
+    }
+  },
+
+  async claude(message, args) {
+    const userMessage = args.join(' ').trim();
+    if (!userMessage) {
+      await commands.help(message);
+      return;
+    }
+
+    const channelId = message.channel.id;
+
+    // Check if there's an active task
+    if (activeTasks.has(channelId)) {
+      const task = activeTasks.get(channelId);
+
+      // Check if there are pending permissions for this channel
+      const hasPendingPermissions = Array.from(pendingPermissions.values())
+        .some(p => p.channelId === channelId);
+
+      if (hasPendingPermissions) {
+        // User sent new message while waiting for permission - cancel current task
+        console.log('[Claude] New message received while permission pending - cancelling task');
+
+        // Abort the current task
+        task.aborted = true;
+        if (task.child && !task.child.killed) {
+          task.child.kill('SIGTERM');
+        }
+
+        // Clean up pending permissions for this channel
+        for (const [requestId, perm] of pendingPermissions) {
+          if (perm.channelId === channelId) {
+            // Update the permission card to show cancelled
+            try {
+              await perm.message.edit({
+                embeds: [{
+                  title: '⚠️ Cancelled',
+                  description: 'User sent new message - permission request cancelled',
+                  color: THEME.warning,
+                }],
+                components: [],
+              });
+            } catch (e) {}
+
+            // Clean up request files
+            try {
+              unlinkSync(join(PENDING_DIR, `${requestId}.request.json`));
+            } catch (e) {}
+            try {
+              unlinkSync(join(PENDING_DIR, `${requestId}.response.json`));
+            } catch (e) {}
+
+            pendingPermissions.delete(requestId);
+            processingRequests.delete(requestId);  // Also clean up processingRequests!
+            completedClicks.add(requestId);
+          }
+        }
+
+        // Update status message
+        try {
+          await task.statusMsg.edit({
+            content: '⚠️ Previous task cancelled - starting new request...',
+            components: [],
+          });
+        } catch (e) {}
+
+        // Clean up
+        activeTasks.delete(channelId);
+        messageQueues.delete(channelId);
+
+        // Start new task
+        await commands._processClaudeMessage(message, userMessage, channelId);
+        return;
+      }
+
+      // No pending permissions - just queue the message
+      if (!messageQueues.has(channelId)) {
+        messageQueues.set(channelId, []);
+      }
+      messageQueues.get(channelId).push({ content: userMessage, timestamp: Date.now() });
+      const queueSize = messageQueues.get(channelId).length;
+      await message.channel.send(`📥 Queued (#${queueSize}) - will process after current task`);
+      return;
+    }
+
+    await commands._processClaudeMessage(message, userMessage, channelId);
+  },
+
+  async _processClaudeMessage(message, userMessage, channelId) {
+    // Create stop button
+    const stopButton = new ActionRowBuilder()
+      .addComponents(
+        new ButtonBuilder()
+          .setCustomId(`stop_${channelId}`)
+          .setLabel('Stop')
+          .setEmoji('⏹️')
+          .setStyle(ButtonStyle.Danger)
+      );
+
+    const statusMsg = await message.channel.send({
+      content: '🐳 Connecting to container...',
+      components: [stopButton],
+    });
+
+    // Track timing for this task
+    const taskStartTime = Date.now();
+    // Create performance monitor for this task
+    const perfMonitor = createMonitor(channelId, { enabled: true, verbose: false });
+
+    activeTasks.set(channelId, {
+      statusMsg,
+      channel: message.channel,  // Store channel for re-sending status
+      aborted: false,
+      stopButton,
+      startTime: taskStartTime,
+      blockedTime: 0,  // Time spent waiting for permissions
+      lastBlockStart: null,  // When current block started
+      perfMonitor,  // Performance monitoring
+    });
+
+    try {
+      // Parse flags
+      let actualMessage = userMessage;
+
+      // Base CLI args with PreToolUse hook for permission control
+      // Hook handles: auto-approve safe tools, request Discord approval for risky tools
+      const cliArgs = [
+        '--print',
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--max-turns', String(CLI_MAX_TURNS),
+        '--settings', CONTAINER_SETTINGS_FILE,
+      ];
+
+      // Track if we're forcing a new session or resuming a specific one
+      if (userMessage.startsWith('-n ') || userMessage.startsWith('--new ')) {
+        // Force new session
+        actualMessage = userMessage.replace(/^--?n(ew)?\s+/, '');
+        cliArgs.push(actualMessage);
+      } else if (userMessage.match(/^-r\s+\S+/) || userMessage.match(/^--resume\s+\S+/)) {
+        // Manual resume specific session
+        const match = userMessage.match(/^--?r(esume)?\s+(\S+)(?:\s+(.*))?$/);
+        if (match) {
+          let sessionId = match[2];
+
+          // Resolve short session ID
+          if (sessionId.length < 36) {
+            try {
+              const projectPath = PROJECT_DIR.replace(/\//g, '-');
+              const sessionsFile = join(config.backend.configDir, 'projects', projectPath, 'sessions-index.json');
+              if (existsSync(sessionsFile)) {
+                const data = JSON.parse(readFileSync(sessionsFile, 'utf-8'));
+                const found = (data.entries || []).find(s => s.sessionId.startsWith(sessionId));
+                if (found) {
+                  console.log('[Claude] Resolved', sessionId, '->', found.sessionId);
+                  sessionId = found.sessionId;
+                }
+              }
+            } catch (e) {
+              console.log('[Claude] Session lookup failed:', e.message);
+            }
+          }
+
+          cliArgs.push('--resume', sessionId);
+          actualMessage = match[3] || 'continue';
+          cliArgs.push(actualMessage);
+        }
+      } else {
+        // Default: auto-resume channel's saved session or start new
+        const savedSessionId = getChannelSession(channelId);
+        if (savedSessionId) {
+          console.log('[Claude] Auto-resuming channel session:', savedSessionId.substring(0, 8));
+          cliArgs.push('--resume', savedSessionId);
+        }
+        cliArgs.push(actualMessage);
+      }
+
+      console.log('[Claude] Starting Docker + Hooks mode');
+
+      // Ensure persistent container is running
+      if (!ensureContainer()) {
+        throw new Error('Failed to start Docker container');
+      }
+
+      const result = await new Promise((resolve, reject) => {
+        let jsonBuffer = '';
+        let assistantTexts = [];
+        let finalResult = '';
+        let capturedSessionId = null;
+        let lastStatusUpdate = 0;
+        const task = activeTasks.get(channelId);
+
+        // Use docker exec to run CLI in the persistent container
+        const dockerArgs = [
+          'exec', '-i',
+          CONTAINER_NAME,
+          CLI_COMMAND,
+          ...cliArgs
+        ];
+
+        console.log('[Docker] Executing in container:', CONTAINER_NAME);
+
+        const child = spawn('docker', dockerArgs, {
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        child.stdin.end();
+
+        // Update status periodically (with stop button)
+        // forceUpdate=true bypasses throttle for important state changes
+        // Uses task.statusMsg to support message re-creation after permission cards
+        const updateStatus = async (status, forceUpdate = false) => {
+          const now = Date.now();
+          if ((forceUpdate || now - lastStatusUpdate > STATUS_UPDATE_THROTTLE) && task && !task.aborted) {
+            lastStatusUpdate = now;
+            // Add elapsed time to status
+            const elapsed = formatElapsedTime(task);
+            const statusWithTime = elapsed ? `${status}\n⏱️ ${elapsed}` : status;
+            // Use task.statusMsg which may be updated when permission cards are sent
+            const currentStatusMsg = task.statusMsg;
+            if (currentStatusMsg) {
+              try {
+                await currentStatusMsg.edit({
+                  content: statusWithTime,
+                  components: [task.stopButton],
+                });
+              } catch (e) {
+                // Ignore edit errors (message may have been deleted)
+              }
+            }
+          }
+        };
+
+        // Store updateStatus in task so permission handler can use it
+        task.updateStatus = updateStatus;
+
+        child.stdout.on('data', async (data) => {
+          jsonBuffer += data.toString();
+
+          // Process complete JSON lines
+          const lines = jsonBuffer.split('\n');
+          jsonBuffer = lines.pop(); // Keep incomplete line in buffer
+
+          for (const line of lines) {
+            if (!line.trim()) continue;
+
+            const json = parseJsonLine(line);
+            if (!json) continue;
+
+            console.log('[JSON]', json.type, json.subtype || '');
+
+            // Capture session_id from any message that has it
+            if (json.session_id && !capturedSessionId) {
+              capturedSessionId = json.session_id;
+              console.log('[Claude] Captured session_id:', capturedSessionId.substring(0, 8));
+            }
+
+            switch (json.type) {
+              case 'system':
+                if (json.subtype === 'init') {
+                  await updateStatus('🐳 Initializing...');
+                  if (json.session_id) {
+                    capturedSessionId = json.session_id;
+                  }
+                }
+                break;
+
+              case 'assistant':
+                const text = extractAssistantText(json);
+                if (text) {
+                  assistantTexts.push(text);
+                  const previewLen = PREVIEW_LENGTHS.response;
+                  const preview = text.substring(0, previewLen);
+                  await updateStatus(`💭 Responding...\n\`\`\`\n${preview}${text.length > previewLen ? '...' : ''}\n\`\`\``);
+                }
+                break;
+
+              case 'result':
+                finalResult = json.result || '';
+                break;
+
+              case 'tool_use':
+                const toolName = json.tool_name || json.name || 'unknown';
+                // Record tool call in performance monitor
+                const task = activeTasks.get(channelId);
+                if (task && task.perfMonitor) {
+                  task.perfMonitor.recordToolCall(toolName, json.input || {});
+                }
+                if (toolName === 'Task') {
+                  const agentType = json.input?.subagent_type || 'agent';
+                  const desc = json.input?.description || '';
+                  await updateStatus(`🤖 Subagent [${agentType}]: ${desc || 'running'}...`);
+                  // Track subagent depth
+                  if (task && task.perfMonitor) {
+                    task.perfMonitor.recordSubagentCall(agentType);
+                  }
+                } else if (toolName === 'Bash') {
+                  const cmd = json.input?.command?.substring(0, 50) || '';
+                  await updateStatus(`⚡ Bash: ${cmd}${cmd.length >= 50 ? '...' : ''}`);
+                } else if (toolName === 'Read' || toolName === 'Edit' || toolName === 'Write') {
+                  const file = json.input?.file_path?.split('/').pop() || '';
+                  await updateStatus(`📄 ${toolName}: ${file}`);
+                } else {
+                  await updateStatus(`🔧 ${toolName}...`);
+                }
+                break;
+
+              case 'tool_result':
+                break;
+            }
+          }
+        });
+
+        child.stderr.on('data', (data) => {
+          const text = data.toString();
+          // Filter out MCP server logs for cleaner output
+          if (!text.includes('[MCP]')) {
+            console.error('[Docker stderr]', text);
+          } else {
+            console.log('[MCP]', text.trim());
+          }
+        });
+
+        child.on('error', (err) => {
+          console.error('[Docker] spawn error:', err);
+          reject(err);
+        });
+
+        child.on('close', (code, signal) => {
+          console.log('[Docker] Process closed - code:', code, 'signal:', signal);
+
+          // Process any remaining buffer
+          if (jsonBuffer.trim()) {
+            const json = parseJsonLine(jsonBuffer);
+            if (json?.type === 'result') {
+              finalResult = json.result || '';
+              if (json.session_id) {
+                capturedSessionId = json.session_id;
+              }
+            }
+          }
+
+          if (code === 0) {
+            // Save session binding if we captured a session_id
+            if (capturedSessionId) {
+              setChannelSession(channelId, capturedSessionId);
+            }
+            // Prefer final result, fall back to assistant texts
+            const output = finalResult || assistantTexts.join('\n');
+            resolve(output);
+          } else if (signal) {
+            reject(new Error(`Process killed: ${signal}`));
+          } else {
+            reject(new Error(`Process exited with code ${code}`));
+          }
+        });
+
+        // Store child process for potential abort
+        if (task) {
+          task.child = child;
+        }
+
+        // Task timeout (configurable, default 1 hour)
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill('SIGTERM');
+            reject(new Error(`Timeout (${CLI_TASK_TIMEOUT / 60000} min)`));
+          }
+        }, CLI_TASK_TIMEOUT);
+      });
+
+      // Delete status message
+      await statusMsg.delete().catch(() => {});
+
+      // Parse response for file sends (convert container paths to host paths)
+      const response = result.trim() || '(no output)';
+      const fileMatches = response.matchAll(/\[SEND_FILE:(.+?)\]/g);
+      const filesToSend = [];
+
+      for (const match of fileMatches) {
+        let filePath = match[1].trim();
+        // Convert container path to host path
+        if (filePath.startsWith(CONTAINER_WORKSPACE + '/')) {
+          filePath = filePath.replace(CONTAINER_WORKSPACE + '/', PROJECT_DIR + '/');
+        }
+        if (existsSync(filePath)) {
+          filesToSend.push(filePath);
+        }
+      }
+
+      // Remove SEND_FILE tags from text
+      const textResponse = response.replace(/\[SEND_FILE:.+?\]/g, '').trim();
+
+      // Send text response (split if needed, with retry)
+      if (textResponse) {
+        const chunkRegex = new RegExp(`[\\s\\S]{1,${MESSAGE_MAX_LENGTH}}`, 'g');
+        const chunks = textResponse.match(chunkRegex) || [textResponse];
+        for (const chunk of chunks) {
+          let retries = 3;
+          while (retries > 0) {
+            try {
+              await message.channel.send(chunk);
+              break;
+            } catch (sendErr) {
+              retries--;
+              console.error(`[Send] Failed (${retries} retries left):`, sendErr.message);
+              if (retries > 0) await new Promise(r => setTimeout(r, RETRY_DELAY));
+            }
+          }
+        }
+      }
+
+      // Send files
+      if (filesToSend.length > 0) {
+        await message.channel.send({
+          content: `${filesToSend.length} file(s)`,
+          files: filesToSend.map(f => ({
+            attachment: f,
+            name: f.split('/').pop()
+          }))
+        });
+      }
+
+      // Show "cooked for" summary at task end
+      const finalTask = activeTasks.get(channelId);
+      const cookedTime = formatElapsedTime(finalTask);
+      if (cookedTime) {
+        const perfSummary = finalTask?.perfMonitor ? formatMonitorSummary(finalTask.perfMonitor) : '';
+        await message.channel.send(`⏱️ Cooked for ${cookedTime}${perfSummary ? ' | ' + perfSummary : ''}`);
+      }
+
+      activeTasks.delete(channelId);
+      // Clean up any pending permissions for this channel
+      await cleanupPermissions(channelId, 'completed');
+      await commands._processQueue(message, channelId);
+
+    } catch (err) {
+      console.error('Claude CLI error:', err);
+      // Try to send error message (statusMsg might be deleted)
+      try {
+        await statusMsg.edit(`Error: ${err.message}`);
+      } catch (editErr) {
+        // statusMsg was deleted, send new message
+        await message.channel.send(`❌ Error: ${err.message}`);
+      }
+      activeTasks.delete(channelId);
+      // Clean up any pending permissions for this channel
+      await cleanupPermissions(channelId, 'encountered an error');
+      await commands._processQueue(message, channelId);
+    }
+  },
+
+  async _processQueue(message, channelId) {
+    const queue = messageQueues.get(channelId);
+    if (!queue || queue.length === 0) return;
+
+    const queuedMessages = queue.splice(0, queue.length);
+
+    if (queuedMessages.length === 1) {
+      await message.channel.send('Processing queued message...');
+      await commands._processClaudeMessage(message, queuedMessages[0].content, channelId);
+    } else {
+      const combined = queuedMessages.map((m, i) => `[${i + 1}] ${m.content}`).join('\n\n');
+      const prompt = `User sent ${queuedMessages.length} messages while you were busy:\n\n${combined}`;
+      await message.channel.send(`Processing ${queuedMessages.length} queued messages...`);
+      await commands._processClaudeMessage(message, prompt, channelId);
+    }
+  },
+
+  // Abort current task for a channel
+  async abort(message) {
+    const channelId = message.channel.id;
+    const task = activeTasks.get(channelId);
+
+    if (!task) {
+      await message.channel.send('No active task to abort');
+      return;
+    }
+
+    task.aborted = true;
+    if (task.child && !task.child.killed) {
+      task.child.kill('SIGTERM');
+      await message.channel.send('Task aborted');
+    }
+  },
+};
+
+// Process messages
+client.on(Events.MessageCreate, async (message) => {
+  // DEBUG: Log ALL messages
+  console.log(`[MSG] Channel: ${message.channel.id}, Author: ${message.author.tag}, Bot: ${message.author.bot}, Content: ${message.content.substring(0, 80)}`);
+  console.log(`[MSG] Mentions: ${JSON.stringify(Array.from(message.mentions.users.keys()))}`);
+
+  if (message.author.bot) {
+    console.log('[MSG] Ignored: author is bot');
+    return;
+  }
+
+  const content = message.content.trim();
+  const isMentioned = message.mentions.has(client.user);
+  const isDM = message.channel.type === 1;
+
+  console.log(`[MSG] isMentioned: ${isMentioned}, isDM: ${isDM}, clientUserId: ${client.user.id}`);
+
+  if (!isMentioned && !isDM) {
+    console.log('[MSG] Ignored: not mentioned and not DM');
+    return;
+  }
+
+  if (ALLOWED_CHANNELS && !isDM) {
+    if (!ALLOWED_CHANNELS.includes(message.channel.id)) {
+      console.log('[MSG] Ignored: channel not allowed');
+      return;
+    }
+  }
+
+  const cleanContent = content.replace(/<@!?\d+>/g, '').trim();
+
+  // Commands
+  if (cleanContent.startsWith('/')) {
+    const [cmd, ...args] = cleanContent.slice(1).split(/\s+/);
+    const handler = commands[cmd.toLowerCase()];
+
+    if (handler) {
+      try {
+        await handler(message, args);
+      } catch (err) {
+        console.error(`Command error (${cmd}):`, err);
+        await message.channel.send(`Error: ${err.message}`);
+      }
+    } else {
+      await message.channel.send(`Unknown command: \`/${cmd}\`. Use \`/help\` for available commands.`);
+    }
+    return;
+  }
+
+  // Default to claude
+  if (cleanContent) {
+    await commands.claude(message, [cleanContent]);
+  } else {
+    await commands.help(message);
+  }
+});
+
+// Ready event
+client.on(Events.ClientReady, () => {
+  console.log(`AgentBridge logged in as ${client.user.tag}`);
+  console.log(`Bot User ID: ${client.user.id}`);
+  console.log(`Project: ${PROJECT_DIR}`);
+  console.log(`Mode: Docker Sandbox + Hooks Permission`);
+  console.log(`Container: ${CONTAINER_NAME}`);
+  console.log(`OAuth: ${OAUTH_TOKEN ? 'configured' : 'not set'}`);
+
+  // Start persistent container
+  ensureContainer();
+  console.log(`Allowed Channels Config: ${ALLOWED_CHANNELS ? ALLOWED_CHANNELS.join(', ') : 'All'}`);
+  console.log(`Guilds: ${client.guilds.cache.size}`);
+  client.guilds.cache.forEach(guild => {
+    console.log(`  Guild: ${guild.name} (${guild.id})`);
+    console.log(`  Channels bot can see:`);
+    guild.channels.cache.forEach(channel => {
+      if (channel.type === 0) { // Text channel
+        console.log(`    - #${channel.name} (${channel.id})`);
+      }
+    });
+  });
+
+  // Start permission watcher
+  startPermissionWatcher();
+
+  console.log(`Ready! @${client.user.username} to interact`);
+});
+
+// Error handling
+client.on(Events.Error, (error) => {
+  console.error('Discord client error:', error);
+});
+
+// Debug: log all raw events
+client.on('raw', (event) => {
+  if (event.t === 'MESSAGE_CREATE') {
+    console.log('[RAW] MESSAGE_CREATE received:', event.d?.content?.substring(0, 50));
+  }
+});
+
+// Debug: connection status
+client.on('debug', (info) => {
+  if (info.includes('Heartbeat') || info.includes('Session')) {
+    console.log('[DEBUG]', info);
+  }
+});
+
+client.on('warn', (info) => {
+  console.warn('[WARN]', info);
+});
+
+client.on('disconnect', () => {
+  console.error('[DISCONNECT] Bot disconnected from Discord');
+});
+
+client.on('reconnecting', () => {
+  console.log('[RECONNECTING] Bot reconnecting...');
+});
+
+process.on('unhandledRejection', (error) => {
+  console.error('Unhandled rejection:', error);
+});
+
+// Error handling - prevent crashes on network issues
+client.on('error', (e) => {
+  console.error('[Client] Error:', e.message);
+});
+
+client.on('shardError', (e) => {
+  console.error('[Shard] Error:', e.message);
+});
+
+client.on('shardDisconnect', (e, shardId) => {
+  console.log(`[Shard ${shardId}] Disconnected, will auto-reconnect...`);
+});
+
+client.on('shardReconnecting', (shardId) => {
+  console.log(`[Shard ${shardId}] Reconnecting...`);
+});
+
+client.on('shardResume', (shardId) => {
+  console.log(`[Shard ${shardId}] Resumed`);
+});
+
+process.on('unhandledRejection', (e) => {
+  console.error('[Process] Unhandled rejection:', e);
+});
+
+// Start
+console.log('Starting AgentBridge...');
+client.login(BOT_TOKEN);