cowork-os 0.3.21

package/src/electron/gateway/router.ts

@@ -0,0 +1,3206 @@
+/**
+ * Message Router
+ *
+ * Routes incoming messages from channels to appropriate handlers.
+ * Manages message flow: Security → Session → Task/Response
+ */
+
+import { BrowserWindow } from 'electron';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ChannelAdapter,
+  IncomingMessage,
+  OutgoingMessage,
+  ChannelType,
+  GatewayEvent,
+  GatewayEventHandler,
+  CallbackQuery,
+  InlineKeyboardButton,
+} from './channels/types';
+import { TelegramAdapter } from './channels/telegram';
+import { SecurityManager } from './security';
+import { SessionManager } from './session';
+import {
+  ChannelRepository,
+  ChannelUserRepository,
+  ChannelSessionRepository,
+  ChannelMessageRepository,
+  WorkspaceRepository,
+  TaskRepository,
+  ArtifactRepository,
+} from '../database/repositories';
+import Database from 'better-sqlite3';
+import { AgentDaemon } from '../agent/daemon';
+import { Task, IPC_CHANNELS, TEMP_WORKSPACE_ID, TEMP_WORKSPACE_NAME, Workspace } from '../../shared/types';
+import * as os from 'os';
+import { LLMProviderFactory, LLMSettings } from '../agent/llm/provider-factory';
+import { ModelKey, LLMProviderType } from '../agent/llm/types';
+import { getCustomSkillLoader } from '../agent/custom-skill-loader';
+import { app } from 'electron';
+import { getVoiceService } from '../voice/VoiceService';
+import { PersonalityManager } from '../settings/personality-manager';
+import {
+  getChannelMessage,
+  getCompletionMessage,
+  DEFAULT_CHANNEL_CONTEXT,
+  type ChannelMessageContext,
+} from '../../shared/channelMessages';
+import { DEFAULT_QUIRKS } from '../../shared/types';
+
+export interface RouterConfig {
+  /** Default workspace ID to use for new sessions */
+  defaultWorkspaceId?: string;
+  /** Welcome message for new users */
+  welcomeMessage?: string;
+  /** Message shown when user is not authorized */
+  unauthorizedMessage?: string;
+  /** Message shown when pairing is required */
+  pairingRequiredMessage?: string;
+}
+
+const DEFAULT_CONFIG: RouterConfig = {
+  welcomeMessage: '👋 Welcome to CoWork! I can help you with tasks in your workspace.',
+  unauthorizedMessage: '⚠️ You are not authorized to use this bot. Please contact the administrator.',
+  pairingRequiredMessage: '🔐 Please enter your pairing code to get started.',
+};
+
+export class MessageRouter {
+  private adapters: Map<ChannelType, ChannelAdapter> = new Map();
+  private securityManager: SecurityManager;
+  private sessionManager: SessionManager;
+  private config: RouterConfig;
+  private eventHandlers: GatewayEventHandler[] = [];
+  private mainWindow: BrowserWindow | null = null;
+  private agentDaemon?: AgentDaemon;
+  private db: Database.Database;
+
+  // Repositories
+  private channelRepo: ChannelRepository;
+  private userRepo: ChannelUserRepository;
+  private sessionRepo: ChannelSessionRepository;
+  private messageRepo: ChannelMessageRepository;
+  private workspaceRepo: WorkspaceRepository;
+  private taskRepo: TaskRepository;
+  private artifactRepo: ArtifactRepository;
+
+  // Track pending responses for tasks
+  private pendingTaskResponses: Map<string, {
+    adapter: ChannelAdapter;
+    chatId: string;
+    sessionId: string;
+    originalMessageId?: string; // For reaction updates
+  }> = new Map();
+
+  // Track pending approval requests for Discord/Telegram
+  private pendingApprovals: Map<string, { taskId: string; approval: any; sessionId: string }> = new Map();
+
+  constructor(db: Database.Database, config: RouterConfig = {}, agentDaemon?: AgentDaemon) {
+    this.db = db;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.agentDaemon = agentDaemon;
+
+    // Initialize repositories
+    this.channelRepo = new ChannelRepository(db);
+    this.userRepo = new ChannelUserRepository(db);
+    this.sessionRepo = new ChannelSessionRepository(db);
+    this.messageRepo = new ChannelMessageRepository(db);
+    this.workspaceRepo = new WorkspaceRepository(db);
+    this.taskRepo = new TaskRepository(db);
+    this.artifactRepo = new ArtifactRepository(db);
+
+    // Initialize managers
+    this.securityManager = new SecurityManager(db);
+    this.sessionManager = new SessionManager(db);
+
+    // Listen for task events if agent daemon is available
+    if (this.agentDaemon) {
+      this.setupTaskEventListener();
+    }
+  }
+
+  /**
+   * Set up listener for task events to send responses back to channels
+   */
+  private setupTaskEventListener(): void {
+    // We'll listen for task events through BrowserWindow IPC
+    // The agent daemon emits events to all windows
+  }
+
+  /**
+   * Set the main window for sending IPC events
+   */
+  setMainWindow(window: BrowserWindow): void {
+    this.mainWindow = window;
+  }
+
+  /**
+   * Get the main window for sending IPC events
+   */
+  getMainWindow(): BrowserWindow | null {
+    return this.mainWindow;
+  }
+
+  /**
+   * Get the channel message context from personality settings
+   */
+  private getMessageContext(): ChannelMessageContext {
+    try {
+      if (PersonalityManager.isInitialized()) {
+        const settings = PersonalityManager.loadSettings();
+        return {
+          agentName: settings.agentName || 'CoWork',
+          userName: settings.relationship?.userName,
+          personality: settings.activePersonality || 'professional',
+          emojiUsage: settings.responseStyle?.emojiUsage || 'minimal',
+          quirks: settings.quirks || DEFAULT_QUIRKS,
+        };
+      }
+    } catch (error) {
+      console.error('[MessageRouter] Failed to load personality settings:', error);
+    }
+    return DEFAULT_CHANNEL_CONTEXT;
+  }
+
+  /**
+   * Get or create the temp workspace for sessions without a workspace
+   */
+  private getOrCreateTempWorkspace(): Workspace {
+    // Check if temp workspace exists
+    const existing = this.workspaceRepo.findById(TEMP_WORKSPACE_ID);
+    if (existing) {
+      const updatedPermissions = {
+        ...existing.permissions,
+        read: true,
+        write: true,
+        delete: true,
+        network: true,
+        shell: existing.permissions.shell ?? false,
+        unrestrictedFileAccess: true,
+      };
+
+      if (!existing.permissions.unrestrictedFileAccess) {
+        this.workspaceRepo.updatePermissions(existing.id, updatedPermissions);
+      }
+
+      // Verify directory exists
+      if (fs.existsSync(existing.path)) {
+        return { ...existing, permissions: updatedPermissions, isTemp: true };
+      }
+      // Directory was deleted, recreate it
+      const tempDir = path.join(os.tmpdir(), 'cowork-os-temp');
+      fs.mkdirSync(tempDir, { recursive: true });
+      return { ...existing, permissions: updatedPermissions, isTemp: true };
+    }
+
+    // Create temp directory
+    const tempDir = path.join(os.tmpdir(), 'cowork-os-temp');
+    fs.mkdirSync(tempDir, { recursive: true });
+
+    // Create workspace record
+    const tempWorkspace: Workspace = {
+      id: TEMP_WORKSPACE_ID,
+      name: TEMP_WORKSPACE_NAME,
+      path: tempDir,
+      createdAt: Date.now(),
+      permissions: {
+        read: true,
+        write: true,
+        delete: true,
+        network: true,
+        shell: false,
+        unrestrictedFileAccess: true,
+      },
+      isTemp: true,
+    };
+
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO workspaces (id, name, path, created_at, permissions)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      tempWorkspace.id,
+      tempWorkspace.name,
+      tempWorkspace.path,
+      tempWorkspace.createdAt,
+      JSON.stringify(tempWorkspace.permissions)
+    );
+
+    return tempWorkspace;
+  }
+
+  /**
+   * Register a channel adapter
+   */
+  registerAdapter(adapter: ChannelAdapter): void {
+    // Set up message handler
+    adapter.onMessage(async (message) => {
+      await this.handleMessage(adapter, message);
+    });
+
+    // Set up callback query handler for inline keyboards
+    if (adapter.onCallbackQuery) {
+      adapter.onCallbackQuery(async (query) => {
+        await this.handleCallbackQuery(adapter, query);
+      });
+    }
+
+    // Set up error handler
+    adapter.onError((error, context) => {
+      console.error(`[${adapter.type}] Error in ${context}:`, error);
+      this.emitEvent({
+        type: 'channel:error',
+        channel: adapter.type,
+        timestamp: new Date(),
+        data: { error: error.message, context },
+      });
+    });
+
+    // Set up status handler
+    adapter.onStatusChange((status, error) => {
+      const eventType = status === 'connected' ? 'channel:connected' : 'channel:disconnected';
+      this.emitEvent({
+        type: eventType,
+        channel: adapter.type,
+        timestamp: new Date(),
+        data: { status, error: error?.message },
+      });
+
+      // Update channel status in database
+      const channel = this.channelRepo.findByType(adapter.type);
+      if (channel) {
+        this.channelRepo.update(channel.id, {
+          status,
+          botUsername: adapter.botUsername,
+        });
+      }
+    });
+
+    this.adapters.set(adapter.type, adapter);
+  }
+
+  /**
+   * Get a registered adapter
+   */
+  getAdapter(type: ChannelType): ChannelAdapter | undefined {
+    return this.adapters.get(type);
+  }
+
+  /**
+   * Get all registered adapters
+   */
+  getAllAdapters(): ChannelAdapter[] {
+    return Array.from(this.adapters.values());
+  }
+
+  /**
+   * Connect all enabled adapters
+   */
+  async connectAll(): Promise<void> {
+    const enabledChannels = this.channelRepo.findEnabled();
+
+    for (const channel of enabledChannels) {
+      const adapter = this.adapters.get(channel.type as ChannelType);
+      if (adapter && adapter.status !== 'connected') {
+        try {
+          await adapter.connect();
+        } catch (error) {
+          console.error(`Failed to connect ${channel.type}:`, error);
+        }
+      }
+    }
+  }
+
+  /**
+   * Disconnect all adapters
+   */
+  async disconnectAll(): Promise<void> {
+    for (const adapter of this.adapters.values()) {
+      if (adapter.status === 'connected') {
+        try {
+          await adapter.disconnect();
+        } catch (error) {
+          console.error(`Failed to disconnect ${adapter.type}:`, error);
+        }
+      }
+    }
+  }
+
+  /**
+   * Send a message through a channel
+   */
+  async sendMessage(channelType: ChannelType, message: OutgoingMessage): Promise<string> {
+    const adapter = this.adapters.get(channelType);
+    if (!adapter) {
+      throw new Error(`No adapter registered for channel type: ${channelType}`);
+    }
+
+    if (adapter.status !== 'connected') {
+      throw new Error(`Adapter ${channelType} is not connected`);
+    }
+
+    const messageId = await adapter.sendMessage(message);
+
+    // Find channel for logging
+    const channel = this.channelRepo.findByType(channelType);
+    if (channel) {
+      // Log outgoing message
+      this.messageRepo.create({
+        channelId: channel.id,
+        channelMessageId: messageId,
+        chatId: message.chatId,
+        direction: 'outgoing',
+        content: message.text,
+        timestamp: Date.now(),
+      });
+
+      this.emitEvent({
+        type: 'message:sent',
+        channel: channelType,
+        timestamp: new Date(),
+        data: { chatId: message.chatId, messageId },
+      });
+    }
+
+    return messageId;
+  }
+
+  /**
+   * Register an event handler
+   */
+  onEvent(handler: GatewayEventHandler): void {
+    this.eventHandlers.push(handler);
+  }
+
+  // Private methods
+
+  /**
+   * Transcribe audio attachments in a message
+   * Downloads audio from URL or uses buffer, transcribes via VoiceService
+   * Saves audio file to a temp folder for transcription and sets message text to include full transcript with context
+   */
+  private async transcribeAudioAttachments(message: IncomingMessage, workspacePath?: string): Promise<void> {
+    if (!message.attachments || message.attachments.length === 0) {
+      return;
+    }
+
+    const audioAttachments = message.attachments.filter(a => a.type === 'audio');
+    if (audioAttachments.length === 0) {
+      return;
+    }
+
+    const voiceService = getVoiceService();
+
+    // Check if transcription is available
+    if (!voiceService.isTranscriptionAvailable()) {
+      console.log('[Router] Audio transcription not available - no STT provider configured');
+      // Add placeholder for audio messages
+      for (const attachment of audioAttachments) {
+        const fileName = attachment.fileName || 'voice message';
+        message.text += message.text ? `\n[Audio: ${fileName} - transcription unavailable]` : `[Audio: ${fileName} - transcription unavailable]`;
+      }
+      return;
+    }
+
+    console.log(`[Router] Transcribing ${audioAttachments.length} audio attachment(s)...`);
+
+    for (const attachment of audioAttachments) {
+      let savedAudioPath: string | undefined;
+      try {
+        let audioBuffer: Buffer | undefined;
+
+        // Get audio data from buffer or file
+        if (attachment.data) {
+          audioBuffer = attachment.data;
+        } else if (attachment.url) {
+          // Check if it's a local file path
+          if (attachment.url.startsWith('/') || attachment.url.startsWith('file://')) {
+            const filePath = attachment.url.replace('file://', '');
+            if (fs.existsSync(filePath)) {
+              audioBuffer = fs.readFileSync(filePath);
+            }
+          } else if (attachment.url.startsWith('http')) {
+            // Download from URL
+            try {
+              const response = await fetch(attachment.url);
+              if (response.ok) {
+                const arrayBuffer = await response.arrayBuffer();
+                audioBuffer = Buffer.from(arrayBuffer);
+              }
+            } catch (fetchError) {
+              console.error('[Router] Failed to download audio:', fetchError);
+            }
+          }
+        }
+
+        if (!audioBuffer || audioBuffer.length === 0) {
+          console.log('[Router] No audio data available for transcription');
+          const fileName = attachment.fileName || 'voice message';
+          message.text += message.text ? `\n[Audio: ${fileName} - could not load]` : `[Audio: ${fileName} - could not load]`;
+          continue;
+        }
+
+        // Save audio file to temp directory for transcription
+        try {
+          const tempDir = path.join(os.tmpdir(), 'cowork-audio');
+          if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+          }
+          const audioFileName = attachment.fileName || `voice_message_${Date.now()}.ogg`;
+          savedAudioPath = path.join(tempDir, audioFileName);
+          fs.writeFileSync(savedAudioPath, audioBuffer);
+          console.log(`[Router] Saved audio file to: ${savedAudioPath}`);
+        } catch (saveError) {
+          console.error('[Router] Failed to save audio file:', saveError);
+        }
+
+        // Transcribe the audio
+        const transcript = await voiceService.transcribe(audioBuffer, { force: true });
+
+        if (transcript && transcript.trim()) {
+          console.log(`[Router] Transcribed audio: "${transcript.substring(0, 100)}${transcript.length > 100 ? '...' : ''}"`);
+
+          // Create a structured message with the full transcript
+          // This ensures the agent knows it's a voice message and has the complete transcript
+          const voiceMessageContext = [
+            '📢 **Voice Message Received**',
+            '',
+            'The user sent a voice message. Here is the complete transcription:',
+            '',
+            '---',
+            transcript,
+            '---',
+            '',
+            'Please respond to the user\'s voice message above.',
+          ].filter(line => line !== undefined).join('\n');
+
+          // Append or set the transcribed text with context
+          if (message.text && message.text.trim()) {
+            message.text += `\n\n${voiceMessageContext}`;
+          } else {
+            message.text = voiceMessageContext;
+          }
+        } else {
+          const fileName = attachment.fileName || 'voice message';
+          message.text += message.text ? `\n[Audio: ${fileName} - no speech detected]` : `[Audio: ${fileName} - no speech detected]`;
+        }
+      } catch (error) {
+        console.error('[Router] Failed to transcribe audio:', error);
+        const fileName = attachment.fileName || 'voice message';
+        message.text += message.text ? `\n[Audio: ${fileName} - transcription failed]` : `[Audio: ${fileName} - transcription failed]`;
+      } finally {
+        if (savedAudioPath && fs.existsSync(savedAudioPath)) {
+          try {
+            fs.unlinkSync(savedAudioPath);
+          } catch (cleanupError) {
+            console.error('[Router] Failed to delete temp audio file:', cleanupError);
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Handle an incoming message
+   */
+  private async handleMessage(adapter: ChannelAdapter, message: IncomingMessage): Promise<void> {
+    const channelType = adapter.type;
+    const channel = this.channelRepo.findByType(channelType);
+
+    if (!channel) {
+      console.error(`No channel configuration found for ${channelType}`);
+      return;
+    }
+
+    // Transcribe any audio attachments before processing
+    await this.transcribeAudioAttachments(message);
+
+    // Log incoming message
+    this.messageRepo.create({
+      channelId: channel.id,
+      channelMessageId: message.messageId,
+      chatId: message.chatId,
+      direction: 'incoming',
+      content: message.text,
+      timestamp: message.timestamp.getTime(),
+    });
+
+    this.emitEvent({
+      type: 'message:received',
+      channel: channelType,
+      timestamp: new Date(),
+      data: {
+        messageId: message.messageId,
+        chatId: message.chatId,
+        userId: message.userId,
+        preview: message.text.slice(0, 100),
+      },
+    });
+
+    // Security check
+    const securityResult = await this.securityManager.checkAccess(channel, message);
+
+    if (!securityResult.allowed) {
+      // Handle unauthorized access
+      await this.handleUnauthorizedMessage(adapter, message, securityResult);
+      return;
+    }
+
+    // Update user's last seen
+    if (securityResult.user) {
+      this.userRepo.update(securityResult.user.id, {
+        lastSeenAt: Date.now(),
+      });
+    }
+
+    // Get or create session
+    const session = await this.sessionManager.getOrCreateSession(
+      channel,
+      message.chatId,
+      securityResult.user?.id,
+      this.config.defaultWorkspaceId
+    );
+
+    // Handle the message based on content
+    await this.routeMessage(adapter, message, session.id);
+  }
+
+  /**
+   * Handle unauthorized message
+   */
+  private async handleUnauthorizedMessage(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    securityResult: { reason?: string; pairingRequired?: boolean }
+  ): Promise<void> {
+    // If pairing is required, check if the message IS a pairing code or /pair command
+    if (securityResult.pairingRequired) {
+      const text = message.text.trim();
+
+      // Check if it's a /pair command
+      if (text.toLowerCase().startsWith('/pair ')) {
+        const code = text.slice(6).trim(); // Remove '/pair ' prefix
+        if (code) {
+          await this.handlePairingAttempt(adapter, message, code);
+          return;
+        }
+      }
+
+      // Check if the raw text looks like a pairing code
+      if (this.looksLikePairingCode(text)) {
+        // This looks like a pairing code - try to verify it
+        await this.handlePairingAttempt(adapter, message, text);
+        return;
+      }
+    }
+
+    // Not a pairing code or pairing not required - send appropriate message
+    let responseText: string;
+
+    if (securityResult.pairingRequired) {
+      responseText = this.config.pairingRequiredMessage!;
+    } else {
+      responseText = this.config.unauthorizedMessage!;
+    }
+
+    try {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: responseText,
+        replyTo: message.messageId,
+      });
+    } catch (error) {
+      console.error('Failed to send unauthorized message response:', error);
+    }
+  }
+
+  /**
+   * Route message to appropriate handler
+   */
+  private async routeMessage(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const text = message.text.trim();
+
+    // Handle commands
+    if (text.startsWith('/')) {
+      await this.handleCommand(adapter, message, sessionId);
+      return;
+    }
+
+    // Check if this is a pairing code
+    if (this.looksLikePairingCode(text)) {
+      await this.handlePairingAttempt(adapter, message, text);
+      return;
+    }
+
+    // Check if session has no workspace - might be workspace selection
+    const session = this.sessionRepo.findById(sessionId);
+    if (!session?.workspaceId) {
+      // Check if this looks like workspace selection (number or short name)
+      const workspaces = this.workspaceRepo.findAll();
+      if (workspaces.length > 0) {
+        // Try to match by number
+        const num = parseInt(text, 10);
+        if (!isNaN(num) && num > 0 && num <= workspaces.length) {
+          const workspace = workspaces[num - 1];
+          this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+          await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ *${workspace.name}* selected!\n\nYou can now send me tasks.\n\nExample: "Create a new React component called Button"`,
+            parseMode: 'markdown',
+          });
+          return;
+        }
+
+        // Try to match by name (case-insensitive partial match)
+        const matchedWorkspace = workspaces.find(
+          ws => ws.name.toLowerCase() === text.toLowerCase() ||
+                ws.name.toLowerCase().startsWith(text.toLowerCase())
+        );
+        if (matchedWorkspace) {
+          this.sessionManager.setSessionWorkspace(sessionId, matchedWorkspace.id);
+          await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `✅ *${matchedWorkspace.name}* selected!\n\nYou can now send me tasks.\n\nExample: "Create a new React component called Button"`,
+            parseMode: 'markdown',
+          });
+          return;
+        }
+      }
+
+      // No workspace match found - auto-assign temp workspace so tasks can proceed
+      const tempWorkspace = this.getOrCreateTempWorkspace();
+      this.sessionManager.setSessionWorkspace(sessionId, tempWorkspace.id);
+    }
+
+    // Regular message - send to desktop app for task processing
+    await this.forwardToDesktopApp(adapter, message, sessionId);
+  }
+
+  /**
+   * Handle bot commands
+   */
+  private async handleCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const [command, ...args] = message.text.trim().split(/\s+/);
+
+    switch (command.toLowerCase()) {
+      case '/start':
+        await this.handleStartCommand(adapter, message, sessionId);
+        break;
+
+      case '/help':
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: this.getHelpText(adapter.type),
+          parseMode: 'markdown',
+        });
+        break;
+
+      case '/status':
+        await this.handleStatusCommand(adapter, message, sessionId);
+        break;
+
+      case '/workspaces':
+        await this.handleWorkspacesCommand(adapter, message);
+        break;
+
+      case '/workspace':
+        await this.handleWorkspaceCommand(adapter, message, sessionId, args);
+        break;
+
+      case '/cancel':
+        // Cancel current task if any
+        await this.handleCancelCommand(adapter, message, sessionId);
+        break;
+
+      case '/newtask':
+        // Start a new task (unlink current session)
+        await this.handleNewTaskCommand(adapter, message, sessionId);
+        break;
+
+      case '/addworkspace':
+        await this.handleAddWorkspaceCommand(adapter, message, sessionId, args);
+        break;
+
+      case '/models':
+        await this.handleModelsCommand(adapter, message);
+        break;
+
+      case '/model':
+        await this.handleModelCommand(adapter, message, args);
+        break;
+
+      case '/provider':
+        await this.handleProviderCommand(adapter, message, args);
+        break;
+
+      case '/pair':
+        // Handle pairing code
+        if (args.length === 0) {
+          await adapter.sendMessage({
+            chatId: message.chatId,
+            text: '🔐 Please provide a pairing code.\n\nUsage: `/pair <code>`',
+            parseMode: 'markdown',
+          });
+        } else {
+          const code = args[0].trim();
+          await this.handlePairingAttempt(adapter, message, code);
+        }
+        break;
+
+      case '/shell':
+        await this.handleShellCommand(adapter, message, sessionId, args);
+        break;
+
+      case '/approve':
+      case '/yes':
+      case '/y':
+        await this.handleApproveCommand(adapter, message, sessionId);
+        break;
+
+      case '/deny':
+      case '/no':
+      case '/n':
+        await this.handleDenyCommand(adapter, message, sessionId);
+        break;
+
+      case '/queue':
+        await this.handleQueueCommand(adapter, message, args);
+        break;
+
+      case '/removeworkspace':
+        await this.handleRemoveWorkspaceCommand(adapter, message, sessionId, args);
+        break;
+
+      case '/retry':
+        await this.handleRetryCommand(adapter, message, sessionId);
+        break;
+
+      case '/history':
+        await this.handleHistoryCommand(adapter, message, sessionId);
+        break;
+
+      case '/skills':
+        await this.handleSkillsCommand(adapter, message, sessionId);
+        break;
+
+      case '/skill':
+        await this.handleSkillCommand(adapter, message, sessionId, args);
+        break;
+
+      case '/providers':
+        await this.handleProvidersCommand(adapter, message);
+        break;
+
+      case '/settings':
+        await this.handleSettingsCommand(adapter, message, sessionId);
+        break;
+
+      case '/debug':
+        await this.handleDebugCommand(adapter, message, sessionId);
+        break;
+
+      case '/version':
+        await this.handleVersionCommand(adapter, message);
+        break;
+
+      default:
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: `Unknown command: ${command}\n\nUse /help to see available commands.`,
+          replyTo: message.messageId,
+        });
+    }
+  }
+
+  /**
+   * Handle /status command
+   */
+  private async handleStatusCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const session = this.sessionRepo.findById(sessionId);
+    let statusText = '✅ Bot is online and ready.\n\n';
+
+    if (session?.workspaceId) {
+      const workspace = this.workspaceRepo.findById(session.workspaceId);
+      if (workspace) {
+        statusText += `📁 Current workspace: ${workspace.name}\n`;
+        statusText += `   Path: ${workspace.path}\n`;
+      }
+    } else {
+      statusText += '⚠️ No workspace selected. Use /workspaces to see available workspaces.';
+    }
+
+    if (session?.taskId) {
+      const task = this.taskRepo.findById(session.taskId);
+      if (task) {
+        statusText += `\n🔄 Active task: ${task.title} (${task.status})`;
+      }
+    }
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: statusText,
+    });
+  }
+
+  /**
+   * Handle /workspaces command - list available workspaces
+   */
+  private async handleWorkspacesCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage
+  ): Promise<void> {
+    const workspaces = this.workspaceRepo.findAll();
+
+    if (workspaces.length === 0) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '📁 No workspaces configured yet.\n\nAdd a workspace in the CoWork desktop app first, or use:\n`/addworkspace /path/to/your/project`',
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // WhatsApp and iMessage don't support inline keyboards - use text-based selection
+    if (adapter.type === 'whatsapp' || adapter.type === 'imessage') {
+      let text = '📁 *Available Workspaces*\n\n';
+      workspaces.forEach((ws, index) => {
+        text += `${index + 1}. *${ws.name}*\n   \`${ws.path}\`\n\n`;
+      });
+      text += '━━━━━━━━━━━━━━━\n';
+      text += 'Reply with the number or name to select.\n';
+      text += 'Example: `1` or `myproject`';
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Build inline keyboard with workspace buttons for Telegram/Discord
+    const keyboard: InlineKeyboardButton[][] = [];
+    for (const ws of workspaces) {
+      // Create one button per row for better readability
+      keyboard.push([{
+        text: `📁 ${ws.name}`,
+        callbackData: `workspace:${ws.id}`,
+      }]);
+    }
+
+    let text = '📁 *Available Workspaces*\n\nTap a workspace to select it:';
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text,
+      parseMode: 'markdown',
+      inlineKeyboard: keyboard,
+      threadId: message.threadId,
+    });
+  }
+
+  /**
+   * Handle /workspace command - set current workspace
+   */
+  private async handleWorkspaceCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string,
+    args: string[]
+  ): Promise<void> {
+    if (args.length === 0) {
+      // Show current workspace
+      let session = this.sessionRepo.findById(sessionId);
+
+      // Auto-assign temp workspace if none selected
+      if (!session?.workspaceId) {
+        const tempWorkspace = this.getOrCreateTempWorkspace();
+        this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+        session = this.sessionRepo.findById(sessionId);
+      }
+
+      if (session?.workspaceId) {
+        const workspace = this.workspaceRepo.findById(session.workspaceId);
+        if (workspace) {
+          const isTempWorkspace = workspace.id === TEMP_WORKSPACE_ID;
+          const displayName = isTempWorkspace ? 'Temporary Workspace (work in a folder for persistence)' : workspace.name;
+          await adapter.sendMessage({
+            chatId: message.chatId,
+            text: `📁 Current workspace: *${displayName}*\n\`${workspace.path}\`\n\nUse \`/workspaces\` to see available workspaces.`,
+            parseMode: 'markdown',
+          });
+          return;
+        }
+      }
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: 'No workspace selected. Use `/workspaces` to see available workspaces.',
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    const workspaces = this.workspaceRepo.findAll();
+    const selector = args.join(' ');
+    let workspace;
+
+    // Try to find by number
+    const num = parseInt(selector, 10);
+    if (!isNaN(num) && num > 0 && num <= workspaces.length) {
+      workspace = workspaces[num - 1];
+    } else {
+      // Try to find by name (case-insensitive)
+      workspace = workspaces.find(
+        ws => ws.name.toLowerCase() === selector.toLowerCase()
+      );
+    }
+
+    if (!workspace) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `❌ Workspace not found: "${selector}"\n\nUse /workspaces to see available workspaces.`,
+      });
+      return;
+    }
+
+    // Update session workspace
+    this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `✅ Workspace set to: *${workspace.name}*\n\`${workspace.path}\`\n\nYou can now send messages to create tasks in this workspace.`,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /addworkspace command - add a new workspace by path
+   */
+  private async handleAddWorkspaceCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string,
+    args: string[]
+  ): Promise<void> {
+    if (args.length === 0) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '📁 *Add Workspace*\n\nUsage: `/addworkspace <path>`\n\nExample:\n`/addworkspace /Users/john/projects/myapp`\n`/addworkspace ~/Documents`',
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Join args to handle paths with spaces
+    let workspacePath = args.join(' ');
+
+    // Expand ~ to home directory
+    if (workspacePath.startsWith('~')) {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+      workspacePath = workspacePath.replace('~', homeDir);
+    }
+
+    // Resolve to absolute path
+    workspacePath = path.resolve(workspacePath);
+
+    // Check if path exists and is a directory
+    try {
+      const stats = fs.statSync(workspacePath);
+      if (!stats.isDirectory()) {
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: `❌ Path is not a directory: \`${workspacePath}\``,
+          parseMode: 'markdown',
+        });
+        return;
+      }
+    } catch {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `❌ Directory not found: \`${workspacePath}\``,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Check if workspace already exists
+    const existingWorkspaces = this.workspaceRepo.findAll();
+    const existing = existingWorkspaces.find(ws => ws.path === workspacePath);
+    if (existing) {
+      // Workspace exists, just select it
+      this.sessionManager.setSessionWorkspace(sessionId, existing.id);
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `📁 Workspace already exists!\n\n✅ Selected: *${existing.name}*\n\`${existing.path}\``,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Create workspace name from path
+    const workspaceName = path.basename(workspacePath);
+
+    // Create new workspace with default permissions
+    // Note: network is enabled by default for browser tools (web access)
+    const workspace = this.workspaceRepo.create(
+      workspaceName,
+      workspacePath,
+      {
+        read: true,
+        write: true,
+        delete: false, // Requires approval
+        network: true,
+        shell: false, // Requires approval
+      }
+    );
+
+    // Set as current workspace
+    this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+
+    // Notify desktop app
+    if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+      this.mainWindow.webContents.send('workspace:added', {
+        id: workspace.id,
+        name: workspace.name,
+        path: workspace.path,
+      });
+    }
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `✅ Workspace added and selected!\n\n📁 *${workspace.name}*\n\`${workspace.path}\`\n\nYou can now send messages to create tasks in this workspace.`,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /models command - list available models and providers
+   */
+  private async handleModelsCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage
+  ): Promise<void> {
+    const status = LLMProviderFactory.getConfigStatus();
+    const settings = LLMProviderFactory.loadSettings();
+    const providerType = status.currentProvider;
+
+    let text = '🤖 *AI Models & Providers*\n\n';
+
+    // Get provider-specific models and current model
+    let models: Array<{ key: string; displayName: string }> = [];
+    let currentModel = settings.modelKey;
+
+    // Provider display names
+    const providerModelNames: Record<string, string> = {
+      'anthropic': 'Claude',
+      'bedrock': 'Claude',
+      'openai': 'OpenAI',
+      'gemini': 'Gemini',
+      'openrouter': 'OpenRouter',
+      'ollama': 'Ollama',
+    };
+
+    // Get models based on current provider
+    switch (providerType) {
+      case 'anthropic':
+      case 'bedrock':
+        models = status.models;
+        break;
+
+      case 'openai': {
+        currentModel = settings.openai?.model || 'gpt-4o-mini';
+        const cachedOpenAI = LLMProviderFactory.getCachedModels('openai');
+        if (cachedOpenAI && cachedOpenAI.length > 0) {
+          models = cachedOpenAI;
+        } else {
+          // Default OpenAI models
+          models = [
+            { key: 'gpt-4o', displayName: 'GPT-4o' },
+            { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini' },
+            { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo' },
+            { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo' },
+            { key: 'o1', displayName: 'o1' },
+            { key: 'o1-mini', displayName: 'o1 Mini' },
+          ];
+        }
+        break;
+      }
+
+      case 'gemini': {
+        currentModel = settings.gemini?.model || 'gemini-2.0-flash';
+        const cachedGemini = LLMProviderFactory.getCachedModels('gemini');
+        if (cachedGemini && cachedGemini.length > 0) {
+          models = cachedGemini;
+        } else {
+          models = [
+            { key: 'gemini-2.0-flash', displayName: 'Gemini 2.0 Flash' },
+            { key: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro' },
+            { key: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash' },
+          ];
+        }
+        break;
+      }
+
+      case 'openrouter': {
+        currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
+        const cachedOpenRouter = LLMProviderFactory.getCachedModels('openrouter');
+        if (cachedOpenRouter && cachedOpenRouter.length > 0) {
+          models = cachedOpenRouter.slice(0, 10); // Limit to 10 for readability
+        } else {
+          models = [
+            { key: 'anthropic/claude-3.5-sonnet', displayName: 'Claude 3.5 Sonnet' },
+            { key: 'openai/gpt-4o', displayName: 'GPT-4o' },
+            { key: 'google/gemini-pro', displayName: 'Gemini Pro' },
+          ];
+        }
+        break;
+      }
+
+      case 'ollama': {
+        // Ollama handled separately below
+        break;
+      }
+
+      default:
+        models = status.models;
+    }
+
+    // Current configuration
+    text += '*Current:*\n';
+    const currentProvider = status.providers.find(p => p.type === providerType);
+    text += `• Provider: ${currentProvider?.name || providerType}\n`;
+
+    if (providerType === 'ollama') {
+      const ollamaModel = settings.ollama?.model || 'llama3.2';
+      text += `• Model: ${ollamaModel}\n\n`;
+    } else {
+      const modelInfo = models.find(m => m.key === currentModel);
+      text += `• Model: ${modelInfo?.displayName || currentModel}\n\n`;
+    }
+
+    // Available providers
+    text += '*Available Providers:*\n';
+    status.providers.forEach(provider => {
+      const isActive = provider.type === providerType ? ' ✓' : '';
+      const configStatus = provider.configured ? '🟢' : '⚪';
+      text += `${configStatus} ${provider.name}${isActive}\n`;
+    });
+    text += '\n';
+
+    // Available models - show different list based on provider
+    if (providerType === 'ollama') {
+      text += '*Available Ollama Models:*\n';
+      try {
+        const ollamaModels = await LLMProviderFactory.getOllamaModels();
+        const currentOllamaModel = settings.ollama?.model || 'llama3.2';
+
+        if (ollamaModels.length === 0) {
+          text += '⚠️ No models found. Run `ollama pull <model>` to download.\n';
+        } else {
+          ollamaModels.slice(0, 10).forEach((model, index) => {
+            const isActive = model.name === currentOllamaModel ? ' ✓' : '';
+            const sizeGB = (model.size / 1e9).toFixed(1);
+            text += `${index + 1}. ${model.name} (${sizeGB}GB)${isActive}\n`;
+          });
+          if (ollamaModels.length > 10) {
+            text += `   ... and ${ollamaModels.length - 10} more\n`;
+          }
+        }
+      } catch {
+        text += '⚠️ Could not fetch Ollama models. Is Ollama running?\n';
+      }
+      text += '\n💡 Use `/model <name>` to switch (e.g., `/model llama3.2`)';
+    } else {
+      const modelBrand = providerModelNames[providerType] || 'Available';
+      text += `*Available ${modelBrand} Models:*\n`;
+      models.forEach((model, index) => {
+        const isActive = model.key === currentModel ? ' ✓' : '';
+        text += `${index + 1}. ${model.displayName}${isActive}\n`;
+      });
+      text += '\n💡 Use `/model <name>` to switch\n';
+      text += 'Example: `/model 2` or `/model <model-name>`';
+    }
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /model command - show or change current model within current provider
+   */
+  private async handleModelCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    args: string[]
+  ): Promise<void> {
+    const status = LLMProviderFactory.getConfigStatus();
+    const settings = LLMProviderFactory.loadSettings();
+    const providerType = status.currentProvider;
+    const currentProviderInfo = status.providers.find(p => p.type === providerType);
+
+    // Get provider-specific models and current model
+    let models: Array<{ key: string; displayName: string }> = [];
+    let currentModel = settings.modelKey;
+
+    // Get models based on current provider
+    switch (providerType) {
+      case 'anthropic':
+      case 'bedrock':
+        models = status.models;
+        break;
+
+      case 'openai': {
+        currentModel = settings.openai?.model || 'gpt-4o-mini';
+        const cachedOpenAI = LLMProviderFactory.getCachedModels('openai');
+        if (cachedOpenAI && cachedOpenAI.length > 0) {
+          models = cachedOpenAI;
+        } else {
+          models = [
+            { key: 'gpt-4o', displayName: 'GPT-4o' },
+            { key: 'gpt-4o-mini', displayName: 'GPT-4o Mini' },
+            { key: 'gpt-4-turbo', displayName: 'GPT-4 Turbo' },
+            { key: 'gpt-3.5-turbo', displayName: 'GPT-3.5 Turbo' },
+            { key: 'o1', displayName: 'o1' },
+            { key: 'o1-mini', displayName: 'o1 Mini' },
+          ];
+        }
+        break;
+      }
+
+      case 'gemini': {
+        currentModel = settings.gemini?.model || 'gemini-2.0-flash';
+        const cachedGemini = LLMProviderFactory.getCachedModels('gemini');
+        if (cachedGemini && cachedGemini.length > 0) {
+          models = cachedGemini;
+        } else {
+          models = [
+            { key: 'gemini-2.0-flash', displayName: 'Gemini 2.0 Flash' },
+            { key: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro' },
+            { key: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash' },
+          ];
+        }
+        break;
+      }
+
+      case 'openrouter': {
+        currentModel = settings.openrouter?.model || 'anthropic/claude-3.5-sonnet';
+        const cachedOpenRouter = LLMProviderFactory.getCachedModels('openrouter');
+        if (cachedOpenRouter && cachedOpenRouter.length > 0) {
+          models = cachedOpenRouter.slice(0, 10);
+        } else {
+          models = [
+            { key: 'anthropic/claude-3.5-sonnet', displayName: 'Claude 3.5 Sonnet' },
+            { key: 'openai/gpt-4o', displayName: 'GPT-4o' },
+            { key: 'google/gemini-pro', displayName: 'Gemini Pro' },
+          ];
+        }
+        break;
+      }
+
+      case 'ollama':
+        // Handled separately
+        break;
+
+      default:
+        models = status.models;
+    }
+
+    // If no args, show current model and available models
+    if (args.length === 0) {
+      let text = '🤖 *Current Model*\n\n';
+      text += `• Provider: ${currentProviderInfo?.name || providerType}\n`;
+
+      if (providerType === 'ollama') {
+        const ollamaModel = settings.ollama?.model || 'llama3.2';
+        text += `• Model: ${ollamaModel}\n\n`;
+
+        text += '*Available Models:*\n';
+        try {
+          const ollamaModels = await LLMProviderFactory.getOllamaModels();
+          if (ollamaModels.length === 0) {
+            text += '⚠️ No models found.\n';
+          } else {
+            ollamaModels.slice(0, 8).forEach((model, index) => {
+              const isActive = model.name === ollamaModel ? ' ✓' : '';
+              const sizeGB = (model.size / 1e9).toFixed(1);
+              text += `${index + 1}. ${model.name} (${sizeGB}GB)${isActive}\n`;
+            });
+            if (ollamaModels.length > 8) {
+              text += `   ... and ${ollamaModels.length - 8} more\n`;
+            }
+          }
+        } catch {
+          text += '⚠️ Could not fetch models.\n';
+        }
+        text += '\n💡 Use `/model <name>` or `/model <number>` to switch';
+      } else {
+        const modelInfo = models.find(m => m.key === currentModel);
+        text += `• Model: ${modelInfo?.displayName || currentModel}\n\n`;
+
+        text += '*Available Models:*\n';
+        models.forEach((model, index) => {
+          const isActive = model.key === currentModel ? ' ✓' : '';
+          text += `${index + 1}. ${model.displayName}${isActive}\n`;
+        });
+        text += '\n💡 Use `/model <name>` or `/model <number>` to switch';
+      }
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Change model within current provider
+    const selector = args.join(' ').toLowerCase();
+
+    if (providerType === 'ollama') {
+      const result = await this.selectOllamaModel(selector, args);
+      if (!result.success) {
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: result.error!,
+          parseMode: 'markdown',
+        });
+        return;
+      }
+
+      const newSettings: LLMSettings = {
+        ...settings,
+        ollama: {
+          ...settings.ollama,
+          model: result.model!,
+        },
+      };
+
+      LLMProviderFactory.saveSettings(newSettings);
+      LLMProviderFactory.clearCache();
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `✅ Model changed to: *${result.model}*`,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // For all other providers, use the provider-specific model list
+    const result = this.selectClaudeModel(selector, models);
+    if (!result.success) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: result.error!,
+      });
+      return;
+    }
+
+    // Save to the appropriate provider-specific setting
+    let newSettings: LLMSettings = { ...settings };
+
+    switch (providerType) {
+      case 'openai':
+        newSettings.openai = {
+          ...settings.openai,
+          model: result.model!.key,
+        };
+        break;
+
+      case 'gemini':
+        newSettings.gemini = {
+          ...settings.gemini,
+          model: result.model!.key,
+        };
+        break;
+
+      case 'openrouter':
+        newSettings.openrouter = {
+          ...settings.openrouter,
+          model: result.model!.key,
+        };
+        break;
+
+      case 'anthropic':
+      case 'bedrock':
+      default:
+        newSettings.modelKey = result.model!.key as ModelKey;
+        break;
+    }
+
+    LLMProviderFactory.saveSettings(newSettings);
+    LLMProviderFactory.clearCache();
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `✅ Model changed to: *${result.model!.displayName}*`,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /provider command - show or change current provider
+   */
+  private async handleProviderCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    args: string[]
+  ): Promise<void> {
+    const status = LLMProviderFactory.getConfigStatus();
+    const settings = LLMProviderFactory.loadSettings();
+
+    // If no args, show current provider and available options
+    if (args.length === 0) {
+      const currentProvider = status.providers.find(p => p.type === status.currentProvider);
+
+      let text = '🔌 *Current Provider*\n\n';
+      text += `• Provider: ${currentProvider?.name || status.currentProvider}\n`;
+
+      // Show current model for context
+      if (status.currentProvider === 'ollama') {
+        text += `• Model: ${settings.ollama?.model || 'gpt-oss:20b'}\n\n`;
+      } else {
+        const currentModel = status.models.find(m => m.key === status.currentModel);
+        text += `• Model: ${currentModel?.displayName || status.currentModel}\n\n`;
+      }
+
+      text += '*Available Providers:*\n';
+      text += '1. anthropic - Anthropic API (direct)\n';
+      text += '2. openai - OpenAI/ChatGPT\n';
+      text += '3. gemini - Google Gemini\n';
+      text += '4. openrouter - OpenRouter\n';
+      text += '5. bedrock - AWS Bedrock\n';
+      text += '6. ollama - Ollama (local)\n\n';
+
+      text += '💡 Use `/provider <name>` to switch\n';
+      text += 'Example: `/provider bedrock` or `/provider 2`';
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    const selector = args[0].toLowerCase();
+
+    // Map of provider shortcuts
+    const providerMap: Record<string, LLMProviderType> = {
+      '1': 'anthropic',
+      'anthropic': 'anthropic',
+      'api': 'anthropic',
+      '2': 'openai',
+      'openai': 'openai',
+      'chatgpt': 'openai',
+      '3': 'gemini',
+      'gemini': 'gemini',
+      'google': 'gemini',
+      '4': 'openrouter',
+      'openrouter': 'openrouter',
+      'or': 'openrouter',
+      '5': 'bedrock',
+      'bedrock': 'bedrock',
+      'aws': 'bedrock',
+      '6': 'ollama',
+      'ollama': 'ollama',
+      'local': 'ollama',
+    };
+
+    const targetProvider = providerMap[selector];
+    if (!targetProvider) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `❌ Unknown provider: "${args[0]}"\n\n*Available providers:*\n1. anthropic\n2. openai\n3. gemini\n4. openrouter\n5. bedrock\n6. ollama\n\nUse \`/provider <name>\` or \`/provider <number>\``,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Update provider
+    const newSettings: LLMSettings = {
+      ...settings,
+      providerType: targetProvider,
+    };
+
+    LLMProviderFactory.saveSettings(newSettings);
+    LLMProviderFactory.clearCache();
+
+    // Get provider display info
+    const providerInfo = status.providers.find(p => p.type === targetProvider);
+    let modelInfo: string;
+
+    if (targetProvider === 'ollama') {
+      modelInfo = settings.ollama?.model || 'gpt-oss:20b';
+    } else {
+      const model = status.models.find(m => m.key === settings.modelKey);
+      modelInfo = model?.displayName || settings.modelKey;
+    }
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `✅ Provider changed to: *${providerInfo?.name || targetProvider}*\n\nCurrent model: ${modelInfo}\n\nUse \`/model\` to see available models for this provider.`,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /shell command - enable or disable shell execution permission
+   */
+  private async handleShellCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string,
+    args: string[]
+  ): Promise<void> {
+    let session = this.sessionRepo.findById(sessionId);
+
+    // Auto-assign temp workspace if none selected
+    if (!session?.workspaceId) {
+      const tempWorkspace = this.getOrCreateTempWorkspace();
+      this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+      session = this.sessionRepo.findById(sessionId);
+    }
+
+    const workspace = this.workspaceRepo.findById(session!.workspaceId!);
+    if (!workspace) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Workspace not found.',
+      });
+      return;
+    }
+
+    // If no args, show current status
+    if (args.length === 0) {
+      const status = workspace.permissions.shell ? '🟢 Enabled' : '🔴 Disabled';
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `🖥️ *Shell Commands*\n\nStatus: ${status}\n\nWhen enabled, the AI can execute shell commands like \`npm install\`, \`git\`, etc. Each command requires your approval before running.\n\n*Usage:*\n• \`/shell on\` - Enable shell commands\n• \`/shell off\` - Disable shell commands`,
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    const action = args[0].toLowerCase();
+    let newShellPermission: boolean;
+
+    if (action === 'on' || action === 'enable' || action === '1' || action === 'true') {
+      newShellPermission = true;
+    } else if (action === 'off' || action === 'disable' || action === '0' || action === 'false') {
+      newShellPermission = false;
+    } else {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Invalid option. Use `/shell on` or `/shell off`',
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    // Update workspace permissions
+    const updatedPermissions = {
+      ...workspace.permissions,
+      shell: newShellPermission,
+    };
+
+    // Update in database
+    this.workspaceRepo.updatePermissions(workspace.id, updatedPermissions);
+
+    const statusText = newShellPermission ? '🟢 enabled' : '🔴 disabled';
+    const warning = newShellPermission
+      ? '\n\n⚠️ The AI will now ask for approval before running each command.'
+      : '';
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `✅ Shell commands ${statusText} for workspace *${workspace.name}*${warning}`,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Helper to select an Ollama model from available models
+   */
+  private async selectOllamaModel(
+    selector: string,
+    originalArgs: string[]
+  ): Promise<{ success: boolean; model?: string; error?: string }> {
+    let ollamaModels: Array<{ name: string; size: number; modified: string }> = [];
+    try {
+      ollamaModels = await LLMProviderFactory.getOllamaModels();
+    } catch {
+      return {
+        success: false,
+        error: `❌ Could not fetch Ollama models. Is Ollama running?\n\nMake sure Ollama is running with \`ollama serve\``,
+      };
+    }
+
+    if (ollamaModels.length === 0) {
+      return {
+        success: false,
+        error: `❌ No Ollama models found.\n\nRun \`ollama pull <model>\` to download a model first.`,
+      };
+    }
+
+    let selectedModel: string | undefined;
+
+    // Try to find model by number
+    const num = parseInt(selector, 10);
+    if (!isNaN(num) && num > 0 && num <= ollamaModels.length) {
+      selectedModel = ollamaModels[num - 1].name;
+    } else {
+      // Try to find by name (exact or partial match)
+      const match = ollamaModels.find(
+        m => m.name.toLowerCase() === selector ||
+             m.name.toLowerCase().includes(selector)
+      );
+      if (match) {
+        selectedModel = match.name;
+      }
+    }
+
+    if (!selectedModel) {
+      const modelList = ollamaModels.slice(0, 5).map((m, i) => `${i + 1}. ${m.name}`).join('\n');
+      const moreText = ollamaModels.length > 5 ? `\n   ... and ${ollamaModels.length - 5} more` : '';
+      return {
+        success: false,
+        error: `❌ Model not found: "${originalArgs.join(' ')}"\n\n*Available Ollama models:*\n${modelList}${moreText}\n\nUse \`/model <name>\` or \`/model <number>\``,
+      };
+    }
+
+    return { success: true, model: selectedModel };
+  }
+
+  /**
+   * Helper to select a Claude model from available models
+   */
+  private selectClaudeModel(
+    selector: string,
+    models: Array<{ key: string; displayName: string }>
+  ): { success: boolean; model?: { key: string; displayName: string }; error?: string } {
+    let selectedModel: { key: string; displayName: string } | undefined;
+
+    // Try to find model by number
+    const num = parseInt(selector, 10);
+    if (!isNaN(num) && num > 0 && num <= models.length) {
+      selectedModel = models[num - 1];
+    } else {
+      // Try to find by name (partial match)
+      selectedModel = models.find(
+        m => m.key.toLowerCase() === selector ||
+             m.key.toLowerCase().includes(selector) ||
+             m.displayName.toLowerCase().includes(selector)
+      );
+    }
+
+    if (!selectedModel) {
+      return {
+        success: false,
+        error: `❌ Model not found: "${selector}"\n\nUse /models to see available options.`,
+      };
+    }
+
+    return { success: true, model: selectedModel };
+  }
+
+  /**
+   * Check if text looks like a pairing code
+   */
+  private looksLikePairingCode(text: string): boolean {
+    // Pairing codes are typically 6-8 alphanumeric characters
+    return /^[A-Z0-9]{6,8}$/i.test(text);
+  }
+
+  /**
+   * Handle pairing code attempt
+   */
+  private async handlePairingAttempt(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    code: string
+  ): Promise<void> {
+    const channel = this.channelRepo.findByType(adapter.type);
+    if (!channel) return;
+
+    const result = await this.securityManager.verifyPairingCode(channel, message.userId, code);
+
+    if (result.success) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '✅ Pairing successful! You can now use the bot.',
+        replyTo: message.messageId,
+      });
+
+      this.emitEvent({
+        type: 'user:paired',
+        channel: adapter.type,
+        timestamp: new Date(),
+        data: { userId: message.userId, userName: message.userName },
+      });
+    } else {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `❌ ${result.error || 'Invalid pairing code. Please try again.'}`,
+        replyTo: message.messageId,
+      });
+    }
+  }
+
+  /**
+   * Forward message to desktop app / create task
+   */
+  private async forwardToDesktopApp(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    let session = this.sessionRepo.findById(sessionId);
+
+    // Auto-assign temp workspace if none selected
+    if (!session?.workspaceId) {
+      const tempWorkspace = this.getOrCreateTempWorkspace();
+      this.sessionManager.setSessionWorkspace(sessionId, tempWorkspace.id);
+      session = this.sessionRepo.findById(sessionId);
+    }
+
+    // Check if there's an existing task for this session (active or completed)
+    if (session!.taskId) {
+      const existingTask = this.taskRepo.findById(session!.taskId);
+      if (existingTask) {
+        // For active tasks, send follow-up message
+        // For completed tasks, also allow follow-up (continues the conversation)
+        const activeStatuses = ['pending', 'planning', 'executing', 'paused'];
+        const isActive = activeStatuses.includes(existingTask.status);
+        const isCompleted = existingTask.status === 'completed';
+
+        if (isActive || isCompleted) {
+          if (this.agentDaemon) {
+            try {
+              const statusMsg = isActive
+                ? '💬 Sending follow-up message...'
+                : '💬 Continuing conversation...';
+              await adapter.sendMessage({
+                chatId: message.chatId,
+                text: statusMsg,
+                replyTo: message.messageId,
+              });
+
+              // Re-register task for response tracking (may have been removed after initial completion)
+              this.pendingTaskResponses.set(session!.taskId!, {
+                adapter,
+                chatId: message.chatId,
+                sessionId,
+              });
+
+              await this.agentDaemon.sendMessage(session!.taskId!, message.text);
+            } catch (error) {
+              console.error('Error sending follow-up message:', error);
+              await adapter.sendMessage({
+                chatId: message.chatId,
+                text: '❌ Failed to send message. Use /newtask to start a new task.',
+              });
+            }
+          }
+          return;
+        }
+        // Task is in failed/cancelled state - unlink and create new task
+        this.sessionManager.unlinkSessionFromTask(sessionId);
+      }
+    }
+
+    // Create a new task
+    if (!this.agentDaemon) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Agent not available. Please try again later.',
+        replyTo: message.messageId,
+      });
+      return;
+    }
+
+    // Get workspace
+    const workspace = this.workspaceRepo.findById(session!.workspaceId!);
+    if (!workspace) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Workspace not found. Please select a workspace with /workspace.',
+        replyTo: message.messageId,
+      });
+      return;
+    }
+
+    // Create task
+    const taskTitle = message.text.length > 50
+      ? message.text.substring(0, 50) + '...'
+      : message.text;
+
+    const task = this.taskRepo.create({
+      workspaceId: workspace.id,
+      title: taskTitle,
+      prompt: message.text,
+      status: 'pending',
+    });
+
+    // Link session to task
+    this.sessionManager.linkSessionToTask(sessionId, task.id);
+
+    // Track this task for response handling
+    this.pendingTaskResponses.set(task.id, {
+      adapter,
+      chatId: message.chatId,
+      sessionId,
+      originalMessageId: message.messageId, // Track for reaction updates
+    });
+
+    // Start draft streaming for real-time response preview (Telegram)
+    if (adapter instanceof TelegramAdapter) {
+      await adapter.startDraftStream(message.chatId);
+    }
+
+    // Send acknowledgment - concise for WhatsApp and iMessage
+    const ackMessage = (adapter.type === 'whatsapp' || adapter.type === 'imessage')
+      ? `⏳ Working on it...`
+      : `🚀 Task Started: "${taskTitle}"\n\nI'll notify you when it's complete or if I need your input.`;
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: ackMessage,
+      replyTo: message.messageId,
+    });
+
+    // Notify desktop app via IPC
+    if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+      this.mainWindow.webContents.send('gateway:message', {
+        channel: adapter.type,
+        sessionId,
+        taskId: task.id,
+        message: {
+          id: message.messageId,
+          userId: message.userId,
+          userName: message.userName,
+          chatId: message.chatId,
+          text: message.text,
+          timestamp: message.timestamp.getTime(),
+        },
+      });
+    }
+
+    // Start task execution
+    try {
+      await this.agentDaemon.startTask(task);
+    } catch (error) {
+      console.error('Error starting task:', error);
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `❌ Failed to start task: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      });
+
+      // Cleanup
+      this.pendingTaskResponses.delete(task.id);
+      this.sessionManager.unlinkSessionFromTask(sessionId);
+    }
+  }
+
+  /**
+   * Send task update to channel
+   * Uses draft streaming for Telegram to show real-time progress
+   */
+  async sendTaskUpdate(taskId: string, text: string, isStreaming = false): Promise<void> {
+    const pending = this.pendingTaskResponses.get(taskId);
+    if (!pending) {
+      // This is expected for tasks started from the UI (not via Telegram)
+      return;
+    }
+
+    try {
+      // Use draft streaming for Telegram when streaming content
+      if (isStreaming && pending.adapter instanceof TelegramAdapter) {
+        await pending.adapter.updateDraftStream(pending.chatId, text);
+      } else {
+        await pending.adapter.sendMessage({
+          chatId: pending.chatId,
+          text,
+          parseMode: 'markdown',
+        });
+      }
+    } catch (error) {
+      console.error('Error sending task update:', error);
+    }
+  }
+
+  /**
+   * Send typing indicator to channel
+   */
+  async sendTypingIndicator(taskId: string): Promise<void> {
+    const pending = this.pendingTaskResponses.get(taskId);
+    if (!pending) return;
+
+    if (pending.adapter instanceof TelegramAdapter) {
+      await pending.adapter.sendTyping(pending.chatId);
+    }
+  }
+
+  /**
+   * Send any artifacts (images, documents) created during task execution
+   * Called when follow-ups complete to deliver screenshots, etc.
+   */
+  async sendArtifacts(taskId: string): Promise<void> {
+    const pending = this.pendingTaskResponses.get(taskId);
+    if (!pending) {
+      return;
+    }
+
+    await this.sendTaskArtifacts(taskId, pending.adapter, pending.chatId);
+  }
+
+  /**
+   * Handle task completion
+   * Note: We keep the session linked to the task for follow-up messages
+   */
+  async handleTaskCompletion(taskId: string, result?: string): Promise<void> {
+    const pending = this.pendingTaskResponses.get(taskId);
+    if (!pending) return;
+
+    try {
+      // WhatsApp/iMessage-optimized completion message (no follow-up hint)
+      const isSimpleMessaging = pending.adapter.type === 'whatsapp' || pending.adapter.type === 'imessage';
+      const msgCtx = this.getMessageContext();
+      const message = getCompletionMessage(msgCtx, result, !isSimpleMessaging);
+
+      // Finalize draft stream if using Telegram
+      if (pending.adapter instanceof TelegramAdapter) {
+        // Finalize the streaming draft with final message
+        await pending.adapter.finalizeDraftStream(pending.chatId, message);
+
+        // Update reaction from 👀 to ✅ on the original message
+        if (pending.originalMessageId) {
+          await pending.adapter.sendCompletionReaction(pending.chatId, pending.originalMessageId);
+        }
+      } else {
+        // Split long messages (Telegram has 4096 char limit, WhatsApp/iMessage ~65k but keep it reasonable)
+        const maxLen = isSimpleMessaging ? 4000 : 4000;
+        const chunks = this.splitMessage(message, maxLen);
+        for (const chunk of chunks) {
+          await pending.adapter.sendMessage({
+            chatId: pending.chatId,
+            text: chunk,
+            parseMode: 'markdown',
+          });
+        }
+      }
+
+      // Send artifacts if any were created
+      await this.sendTaskArtifacts(taskId, pending.adapter, pending.chatId);
+
+      // Don't unlink session - keep it linked for follow-up messages
+      // User can use /newtask to explicitly start a new task
+    } catch (error) {
+      console.error('Error sending task completion:', error);
+    } finally {
+      this.pendingTaskResponses.delete(taskId);
+    }
+  }
+
+  /**
+   * Send task artifacts as documents/images to the channel
+   */
+  private async sendTaskArtifacts(
+    taskId: string,
+    adapter: ChannelAdapter,
+    chatId: string
+  ): Promise<void> {
+    try {
+      const artifacts = this.artifactRepo.findByTaskId(taskId);
+      if (artifacts.length === 0) return;
+
+      // Image extensions
+      const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp'];
+
+      // Document extensions
+      const documentExtensions = [
+        '.docx', '.xlsx', '.pptx', '.pdf', '.doc', '.xls', '.ppt',
+        '.txt', '.csv', '.json', '.md', '.html', '.xml'
+      ];
+
+      // Filter for sendable file types
+      const sendableArtifacts = artifacts.filter(artifact => {
+        const ext = path.extname(artifact.path).toLowerCase();
+        return (imageExtensions.includes(ext) || documentExtensions.includes(ext)) && fs.existsSync(artifact.path);
+      });
+
+      if (sendableArtifacts.length === 0) return;
+
+      // Send each artifact
+      for (const artifact of sendableArtifacts) {
+        try {
+          const ext = path.extname(artifact.path).toLowerCase();
+          const fileName = path.basename(artifact.path);
+
+          if (imageExtensions.includes(ext) && adapter.sendPhoto) {
+            // Send as photo for better display
+            await adapter.sendPhoto(chatId, artifact.path, `📷 ${fileName}`);
+            console.log(`Sent image: ${fileName}`);
+          } else if (adapter.sendDocument) {
+            // Send as document
+            await adapter.sendDocument(chatId, artifact.path, `📎 ${fileName}`);
+            console.log(`Sent document: ${fileName}`);
+          } else {
+            console.log(`Adapter does not support sending ${ext} files, skipping: ${fileName}`);
+          }
+        } catch (err) {
+          console.error(`Failed to send artifact ${artifact.path}:`, err);
+        }
+      }
+    } catch (error) {
+      console.error('Error sending task artifacts:', error);
+    }
+  }
+
+  /**
+   * Handle task failure
+   */
+  async handleTaskFailure(taskId: string, error: string): Promise<void> {
+    const pending = this.pendingTaskResponses.get(taskId);
+    if (!pending) return;
+
+    try {
+      // Cancel any draft stream
+      if (pending.adapter instanceof TelegramAdapter) {
+        await pending.adapter.cancelDraftStream(pending.chatId);
+
+        // Remove ACK reaction on failure
+        if (pending.originalMessageId) {
+          await pending.adapter.removeAckReaction(pending.chatId, pending.originalMessageId);
+        }
+      }
+
+      const message = getChannelMessage('taskFailed', this.getMessageContext(), { error });
+      await pending.adapter.sendMessage({
+        chatId: pending.chatId,
+        text: message,
+      });
+
+      // Unlink session from task
+      this.sessionManager.unlinkSessionFromTask(pending.sessionId);
+    } catch (err) {
+      console.error('Error sending task failure:', err);
+    } finally {
+      this.pendingTaskResponses.delete(taskId);
+    }
+  }
+
+  /**
+   * Send approval request to Discord/Telegram
+   */
+  async sendApprovalRequest(taskId: string, approval: any): Promise<void> {
+    const pending = this.pendingTaskResponses.get(taskId);
+    if (!pending) return;
+
+    // Store approval for response handling
+    this.pendingApprovals.set(approval.id, {
+      taskId,
+      approval,
+      sessionId: pending.sessionId,
+    });
+
+    // Format approval message
+    let message = `🔐 *Approval Required*\n\n`;
+    message += `**${approval.description}**\n\n`;
+
+    if (approval.type === 'run_command' && approval.details?.command) {
+      message += `\`\`\`\n${approval.details.command}\n\`\`\`\n\n`;
+    } else if (approval.details) {
+      message += `Details: ${JSON.stringify(approval.details, null, 2)}\n\n`;
+    }
+
+    message += `⏳ _Expires in 5 minutes_`;
+
+    // WhatsApp/iMessage don't support inline keyboards - use text commands
+    if (pending.adapter.type === 'whatsapp' || pending.adapter.type === 'imessage') {
+      message += `\n\n━━━━━━━━━━━━━━━\nReply */approve* or */deny*`;
+
+      try {
+        await pending.adapter.sendMessage({
+          chatId: pending.chatId,
+          text: message,
+          parseMode: 'markdown',
+        });
+      } catch (error) {
+        console.error('Error sending approval request:', error);
+      }
+    } else {
+      // Create inline keyboard with Approve/Deny buttons for Telegram/Discord
+      const keyboard: InlineKeyboardButton[][] = [
+        [
+          { text: '✅ Approve', callbackData: 'approve:' + approval.id },
+          { text: '❌ Deny', callbackData: 'deny:' + approval.id },
+        ],
+      ];
+
+      try {
+        await pending.adapter.sendMessage({
+          chatId: pending.chatId,
+          text: message,
+          parseMode: 'markdown',
+          inlineKeyboard: keyboard,
+        });
+      } catch (error) {
+        console.error('Error sending approval request:', error);
+      }
+    }
+  }
+
+  /**
+   * Handle /approve command
+   */
+  private async handleApproveCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    // Find pending approval for this session
+    const approvalEntry = Array.from(this.pendingApprovals.entries())
+      .find(([, data]) => data.sessionId === sessionId);
+
+    if (!approvalEntry) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ No pending approval request.',
+      });
+      return;
+    }
+
+    const [approvalId, data] = approvalEntry;
+    this.pendingApprovals.delete(approvalId);
+
+    try {
+      await this.agentDaemon?.respondToApproval(approvalId, true);
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '✅ Approved! Executing...',
+      });
+    } catch (error) {
+      console.error('Error responding to approval:', error);
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Failed to process approval.',
+      });
+    }
+  }
+
+  /**
+   * Handle /deny command
+   */
+  private async handleDenyCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    // Find pending approval for this session
+    const approvalEntry = Array.from(this.pendingApprovals.entries())
+      .find(([, data]) => data.sessionId === sessionId);
+
+    if (!approvalEntry) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ No pending approval request.',
+      });
+      return;
+    }
+
+    const [approvalId] = approvalEntry;
+    this.pendingApprovals.delete(approvalId);
+
+    try {
+      await this.agentDaemon?.respondToApproval(approvalId, false);
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '🛑 Denied. Action cancelled.',
+      });
+    } catch (error) {
+      console.error('Error responding to denial:', error);
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Failed to process denial.',
+      });
+    }
+  }
+
+  /**
+   * Handle /queue command - view or clear task queue
+   */
+  private async handleQueueCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    args: string[]
+  ): Promise<void> {
+    if (!this.agentDaemon) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Agent daemon not available.',
+      });
+      return;
+    }
+
+    const subcommand = args[0]?.toLowerCase();
+
+    if (subcommand === 'clear' || subcommand === 'reset') {
+      // Clear stuck tasks (also properly cancels running tasks to clean up browser sessions)
+      const result = await this.agentDaemon.clearStuckTasks();
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `✅ Queue cleared!\n\n• Running tasks cancelled: ${result.clearedRunning}\n• Queued tasks removed: ${result.clearedQueued}\n\nBrowser sessions and other resources have been cleaned up. You can now start new tasks.`,
+      });
+    } else {
+      // Show queue status
+      const status = this.agentDaemon.getQueueStatus();
+      const statusText = `📊 *Queue Status*
+
+• Running: ${status.runningCount}/${status.maxConcurrent}
+• Queued: ${status.queuedCount}
+
+${status.runningCount > 0 ? `Running task IDs: ${status.runningTaskIds.join(', ')}` : ''}
+${status.queuedCount > 0 ? `Queued task IDs: ${status.queuedTaskIds.join(', ')}` : ''}
+
+*Commands:*
+• \`/queue\` - Show this status
+• \`/queue clear\` - Clear stuck tasks`;
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: statusText,
+        parseMode: 'markdown',
+      });
+    }
+  }
+
+  /**
+   * Split a message into chunks for Telegram's character limit
+   */
+  private splitMessage(text: string, maxLength: number): string[] {
+    if (text.length <= maxLength) {
+      return [text];
+    }
+
+    const chunks: string[] = [];
+    let remaining = text;
+
+    while (remaining.length > 0) {
+      if (remaining.length <= maxLength) {
+        chunks.push(remaining);
+        break;
+      }
+
+      // Try to split at newline
+      let splitIndex = remaining.lastIndexOf('\n', maxLength);
+      if (splitIndex === -1 || splitIndex < maxLength / 2) {
+        // Try to split at space
+        splitIndex = remaining.lastIndexOf(' ', maxLength);
+      }
+      if (splitIndex === -1 || splitIndex < maxLength / 2) {
+        // Force split
+        splitIndex = maxLength;
+      }
+
+      chunks.push(remaining.substring(0, splitIndex));
+      remaining = remaining.substring(splitIndex).trimStart();
+    }
+
+    return chunks;
+  }
+
+  /**
+   * Handle cancel command
+   */
+  private async handleCancelCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const session = this.sessionRepo.findById(sessionId);
+
+    if (session?.taskId) {
+      // Notify desktop app to cancel the task
+      if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+        this.mainWindow.webContents.send('gateway:cancel-task', {
+          taskId: session.taskId,
+          sessionId,
+        });
+      }
+
+      // Update session state
+      this.sessionRepo.update(sessionId, { state: 'idle', taskId: undefined });
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '🛑 Task cancelled.',
+      });
+    } else {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: 'No active task to cancel.',
+      });
+    }
+  }
+
+  /**
+   * Handle newtask command - start a fresh task session
+   */
+  private async handleNewTaskCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const session = this.sessionRepo.findById(sessionId);
+
+    if (session?.taskId) {
+      // Unlink current task from session
+      this.sessionManager.unlinkSessionFromTask(sessionId);
+      this.pendingTaskResponses.delete(session.taskId);
+    }
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: '🆕 Ready for a new task!\n\nSend me a message describing what you want to do.',
+    });
+  }
+
+  /**
+   * Handle /removeworkspace command
+   */
+  private async handleRemoveWorkspaceCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string,
+    args: string[]
+  ): Promise<void> {
+    if (args.length === 0) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Please specify a workspace name to remove.\n\nUsage: `/removeworkspace <name>`',
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    const workspaceName = args.join(' ');
+    const workspaces = this.workspaceRepo.findAll();
+    const workspace = workspaces.find(
+      (w) => w.name.toLowerCase() === workspaceName.toLowerCase()
+    );
+
+    if (!workspace) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `❌ Workspace "${workspaceName}" not found.\n\nUse /workspaces to see available workspaces.`,
+      });
+      return;
+    }
+
+    // Check if this is the current workspace for the session
+    const session = this.sessionRepo.findById(sessionId);
+    if (session?.workspaceId === workspace.id) {
+      // Clear the workspace from session
+      this.sessionRepo.update(sessionId, { workspaceId: undefined });
+    }
+
+    // Remove the workspace
+    this.workspaceRepo.delete(workspace.id);
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `✅ Workspace "${workspace.name}" removed successfully.`,
+    });
+  }
+
+  /**
+   * Handle /retry command - retry the last failed task
+   */
+  private async handleRetryCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    let session = this.sessionRepo.findById(sessionId);
+
+    // Auto-assign temp workspace if none selected
+    if (!session?.workspaceId) {
+      const tempWorkspace = this.getOrCreateTempWorkspace();
+      this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+      session = this.sessionRepo.findById(sessionId);
+    }
+
+    // Find the last task for this session's workspace that failed or was cancelled
+    const tasks = this.taskRepo.findByWorkspace(session!.workspaceId!);
+    const lastFailedTask = tasks
+      .filter((t: Task) => t.status === 'failed' || t.status === 'cancelled')
+      .sort((a: Task, b: Task) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())[0];
+
+    if (!lastFailedTask) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ No failed task found to retry.\n\nStart a new task by sending a message.',
+      });
+      return;
+    }
+
+    // Re-submit the task by sending the original prompt as a new message
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `🔄 Retrying task...\n\nOriginal prompt: "${lastFailedTask.title}"`,
+    });
+
+    // Create a synthetic message with the original prompt
+    const retryMessage: IncomingMessage = {
+      ...message,
+      text: lastFailedTask.title,
+    };
+
+    // Route as a regular task message
+    await this.routeMessage(adapter, retryMessage, sessionId);
+  }
+
+  /**
+   * Handle /history command - show recent task history
+   */
+  private async handleHistoryCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    let session = this.sessionRepo.findById(sessionId);
+
+    // Auto-assign temp workspace if none selected
+    if (!session?.workspaceId) {
+      const tempWorkspace = this.getOrCreateTempWorkspace();
+      this.sessionRepo.update(sessionId, { workspaceId: tempWorkspace.id });
+      session = this.sessionRepo.findById(sessionId);
+    }
+
+    const tasks = this.taskRepo.findByWorkspace(session!.workspaceId!);
+    const recentTasks = tasks
+      .sort((a: Task, b: Task) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
+      .slice(0, 10);
+
+    if (recentTasks.length === 0) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '📋 No task history found.\n\nStart a new task by sending a message.',
+      });
+      return;
+    }
+
+    const statusEmoji: Record<string, string> = {
+      completed: '✅',
+      running: '⏳',
+      pending: '⏸️',
+      error: '❌',
+      cancelled: '🚫',
+    };
+
+    const historyText = recentTasks
+      .map((t: Task, i: number) => {
+        const emoji = statusEmoji[t.status] || '❓';
+        const date = new Date(t.createdAt).toLocaleDateString();
+        const title = t.title.length > 40 ? t.title.substring(0, 40) + '...' : t.title;
+        return `${i + 1}. ${emoji} ${title}\n   ${date} • ${t.status}`;
+      })
+      .join('\n\n');
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `📋 *Recent Tasks*\n\n${historyText}`,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /skills command - list available skills
+   */
+  private async handleSkillsCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    _sessionId: string
+  ): Promise<void> {
+    try {
+      const skillLoader = getCustomSkillLoader();
+      await skillLoader.initialize();
+      const skills = skillLoader.listTaskSkills();
+
+      if (skills.length === 0) {
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: '📚 No skills available.\n\nSkills are stored in:\n`~/Library/Application Support/cowork-os/skills/`',
+          parseMode: 'markdown',
+        });
+        return;
+      }
+
+      // Group skills by category
+      const byCategory = new Map<string, typeof skills>();
+      for (const skill of skills) {
+        const category = skill.category || 'Uncategorized';
+        if (!byCategory.has(category)) {
+          byCategory.set(category, []);
+        }
+        byCategory.get(category)!.push(skill);
+      }
+
+      let text = '📚 *Available Skills*\n\n';
+      for (const [category, categorySkills] of byCategory) {
+        text += `*${category}*\n`;
+        for (const skill of categorySkills) {
+          const status = skill.enabled !== false ? '✅' : '❌';
+          text += `${skill.icon || '⚡'} ${skill.name} ${status}\n`;
+          text += `   \`/skill ${skill.id}\` to toggle\n`;
+        }
+        text += '\n';
+      }
+
+      text += '_Use `/skill <name>` to toggle a skill on/off_';
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text,
+        parseMode: 'markdown',
+      });
+    } catch (error) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Failed to load skills.',
+      });
+    }
+  }
+
+  /**
+   * Handle /skill command - toggle a skill on/off
+   */
+  private async handleSkillCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    _sessionId: string,
+    args: string[]
+  ): Promise<void> {
+    if (args.length === 0) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Please specify a skill ID.\n\nUsage: `/skill <id>`\n\nUse /skills to see available skills.',
+        parseMode: 'markdown',
+      });
+      return;
+    }
+
+    try {
+      const skillLoader = getCustomSkillLoader();
+      await skillLoader.initialize();
+      const skillId = args[0].toLowerCase();
+      const skill = skillLoader.getSkill(skillId);
+
+      if (!skill) {
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: `❌ Skill "${skillId}" not found.\n\nUse /skills to see available skills.`,
+        });
+        return;
+      }
+
+      // Toggle the enabled state
+      const newState = skill.enabled === false;
+      await skillLoader.updateSkill(skillId, { enabled: newState });
+
+      const statusText = newState ? '✅ enabled' : '❌ disabled';
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: `${skill.icon || '⚡'} *${skill.name}* is now ${statusText}`,
+        parseMode: 'markdown',
+      });
+    } catch (error) {
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text: '❌ Failed to toggle skill.',
+      });
+    }
+  }
+
+  /**
+   * Handle /providers command - list available LLM providers
+   */
+  private async handleProvidersCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage
+  ): Promise<void> {
+    const status = LLMProviderFactory.getConfigStatus();
+    const current = status.currentProvider;
+
+    const providerEmoji: Record<string, string> = {
+      anthropic: '🟠',
+      openai: '🟢',
+      gemini: '🔵',
+      bedrock: '🟡',
+      ollama: '⚪',
+      openrouter: '🟣',
+    };
+
+    // Build inline keyboard with provider buttons
+    const keyboard: InlineKeyboardButton[][] = [];
+    const row1: InlineKeyboardButton[] = [];
+    const row2: InlineKeyboardButton[] = [];
+
+    // Get configured providers for the keyboard
+    const providerOrder: LLMProviderType[] = ['anthropic', 'openai', 'gemini', 'bedrock', 'openrouter', 'ollama'];
+
+    for (let i = 0; i < providerOrder.length; i++) {
+      const provider = providerOrder[i];
+      const emoji = providerEmoji[provider] || '⚡';
+      const isCurrent = provider === current ? ' ✓' : '';
+      const providerInfo = status.providers.find(p => p.type === provider);
+      const name = providerInfo?.name || provider;
+
+      const button: InlineKeyboardButton = {
+        text: `${emoji} ${name}${isCurrent}`,
+        callbackData: `provider:${provider}`,
+      };
+
+      // Split into two rows
+      if (i < 3) {
+        row1.push(button);
+      } else {
+        row2.push(button);
+      }
+    }
+
+    keyboard.push(row1);
+    keyboard.push(row2);
+
+    const currentProviderInfo = status.providers.find(p => p.type === current);
+
+    // WhatsApp/iMessage don't support inline keyboards - use text-based selection
+    if (adapter.type === 'whatsapp' || adapter.type === 'imessage') {
+      let text = `🤖 *AI Providers*\n\nCurrent: *${currentProviderInfo?.name || current}*\n\n`;
+      providerOrder.forEach((provider, index) => {
+        const emoji = providerEmoji[provider] || '⚡';
+        const providerInfo = status.providers.find(p => p.type === provider);
+        const name = providerInfo?.name || provider;
+        const isCurrent = provider === current ? ' ✓' : '';
+        text += `${index + 1}. ${emoji} *${name}*${isCurrent}\n`;
+      });
+      text += '\n━━━━━━━━━━━━━━━\n';
+      text += 'Reply with number to switch.\nExample: `1` for Anthropic';
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text,
+        parseMode: 'markdown',
+        threadId: message.threadId,
+      });
+    } else {
+      let text = `🤖 *AI Providers*\n\nCurrent: ${currentProviderInfo?.name || current}\n\nTap to switch:`;
+
+      await adapter.sendMessage({
+        chatId: message.chatId,
+        text,
+        parseMode: 'markdown',
+        inlineKeyboard: keyboard,
+        threadId: message.threadId,
+      });
+    }
+  }
+
+  /**
+   * Handle /settings command - view current settings
+   */
+  private async handleSettingsCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const session = this.sessionRepo.findById(sessionId);
+    const workspace = session?.workspaceId
+      ? this.workspaceRepo.findById(session.workspaceId)
+      : null;
+
+    const provider = LLMProviderFactory.getSelectedProvider();
+    const model = LLMProviderFactory.getSelectedModel();
+    const settings = LLMProviderFactory.getSettings();
+
+    let text = '⚙️ *Current Settings*\n\n';
+
+    text += '*Workspace*\n';
+    text += workspace ? `📁 ${workspace.name}\n` : '❌ None selected\n';
+    text += '\n';
+
+    text += '*AI Configuration*\n';
+    text += `🤖 Provider: \`${provider}\`\n`;
+    text += `🧠 Model: \`${model}\`\n`;
+    text += '\n';
+
+    text += '*Session*\n';
+    text += `🔧 Shell commands: ${session?.shellEnabled ? '✅' : '❌'}\n`;
+    text += `📝 Debug mode: ${session?.debugMode ? '✅' : '❌'}\n`;
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /debug command - toggle debug mode
+   */
+  private async handleDebugCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const session = this.sessionRepo.findById(sessionId);
+    const currentDebug = session?.debugMode || false;
+    const newDebug = !currentDebug;
+
+    this.sessionRepo.update(sessionId, { debugMode: newDebug });
+
+    const statusText = newDebug ? '✅ enabled' : '❌ disabled';
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: `🐛 Debug mode is now ${statusText}`,
+    });
+  }
+
+  /**
+   * Handle /version command - show version info
+   */
+  private async handleVersionCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage
+  ): Promise<void> {
+    const version = app.getVersion();
+    const electronVersion = process.versions.electron;
+    const nodeVersion = process.versions.node;
+    const platform = process.platform;
+    const arch = process.arch;
+
+    const text = `📦 *CoWork OS*
+
+Version: \`${version}\`
+Platform: \`${platform}\` (${arch})
+Electron: \`${electronVersion}\`
+Node.js: \`${nodeVersion}\`
+
+🔗 [GitHub](https://github.com/CoWork-OS/cowork-os)`;
+
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text,
+      parseMode: 'markdown',
+    });
+  }
+
+  /**
+   * Handle /start command with smart onboarding
+   */
+  private async handleStartCommand(
+    adapter: ChannelAdapter,
+    message: IncomingMessage,
+    sessionId: string
+  ): Promise<void> {
+    const session = this.sessionRepo.findById(sessionId);
+    const workspaces = this.workspaceRepo.findAll();
+
+    // WhatsApp/iMessage-optimized welcome flow (no inline keyboards)
+    if (adapter.type === 'whatsapp' || adapter.type === 'imessage') {
+      if (session?.workspaceId) {
+        const workspace = this.workspaceRepo.findById(session.workspaceId);
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: `👋 *Welcome back!*\n\nWorkspace: *${workspace?.name || 'Unknown'}*\n\nJust send me what you'd like me to do.\n\nType /help for commands.`,
+          parseMode: 'markdown',
+        });
+      } else if (workspaces.length === 0) {
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: `👋 *Welcome to CoWork!*\n\nI'm your AI coding assistant.\n\nFirst, add a workspace:\n\`/addworkspace /path/to/project\`\n\nOr add one from the desktop app.`,
+          parseMode: 'markdown',
+        });
+      } else if (workspaces.length === 1) {
+        // Auto-select the only workspace
+        const workspace = workspaces[0];
+        this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text: `👋 *Welcome to CoWork!*\n\n✅ Workspace: *${workspace.name}*\n\nJust tell me what you'd like me to do!\n\nExamples:\n• "Add dark mode support"\n• "Fix the login bug"\n• "Create a new API endpoint"`,
+          parseMode: 'markdown',
+        });
+      } else {
+        // Multiple workspaces - show selection
+        let text = `👋 *Welcome to CoWork!*\n\nSelect a workspace to start:\n\n`;
+        workspaces.forEach((ws, index) => {
+          text += `${index + 1}. *${ws.name}*\n`;
+        });
+        text += `\nReply with a number (e.g., \`1\`)`;
+
+        await adapter.sendMessage({
+          chatId: message.chatId,
+          text,
+          parseMode: 'markdown',
+        });
+      }
+      return;
+    }
+
+    // Standard welcome for Telegram/Discord
+    await adapter.sendMessage({
+      chatId: message.chatId,
+      text: this.config.welcomeMessage!,
+    });
+
+    // Show workspaces if none selected
+    if (!session?.workspaceId && workspaces.length > 0) {
+      await this.handleWorkspacesCommand(adapter, message);
+    }
+  }
+
+  /**
+   * Get help text - channel-specific for better UX
+   */
+  private getHelpText(channelType?: ChannelType): string {
+    // Compact help for WhatsApp (mobile-friendly)
+    if (channelType === 'whatsapp') {
+      return `📚 *Commands*
+
+*Basics*
+/workspaces - Select workspace
+/status - Current status
+/newtask - Fresh start
+
+*Tasks*
+/cancel - Stop task
+/approve or /yes - Approve action
+/deny or /no - Reject action
+
+*Settings*
+/shell on|off - Shell access
+/models - Change AI model
+
+━━━━━━━━━━━━━━━
+💡 Just send your task directly!
+Example: "Add a login form"`;
+    }
+
+    // Full help for other channels
+    return `📚 *Available Commands*
+
+*Core*
+/start - Start the bot
+/help - Show this help message
+/status - Check bot status and workspace
+/version - Show version information
+
+*Workspaces*
+/workspaces - List available workspaces
+/workspace <name> - Select a workspace
+/addworkspace <path> - Add a new workspace
+/removeworkspace <name> - Remove a workspace
+
+*Tasks*
+/newtask - Start a fresh task/conversation
+/cancel - Cancel current task
+/retry - Retry the last failed task
+/history - Show recent task history
+/approve - Approve pending action (or /yes, /y)
+/deny - Reject pending action (or /no, /n)
+/queue - View/clear task queue
+
+*Models*
+/providers - List available AI providers
+/provider <name> - Show or change provider
+/models - List available AI models
+/model <name> - Show or change model
+
+*Skills*
+/skills - List available skills
+/skill <name> - Toggle a skill on/off
+
+*Settings*
+/settings - View current settings
+/shell - Enable/disable shell commands
+/debug - Toggle debug mode
+
+💬 *Quick Start*
+1. \`/workspaces\` → \`/workspace <name>\`
+2. \`/shell on\` (if needed)
+3. Send your task message
+4. \`/newtask\` to start fresh`;
+  }
+
+  /**
+   * Handle callback query from inline keyboard button press
+   */
+  private async handleCallbackQuery(adapter: ChannelAdapter, query: CallbackQuery): Promise<void> {
+    const { data, chatId } = query;
+
+    // Parse callback data (format: action:param)
+    const [action, ...params] = data.split(':');
+    const param = params.join(':');
+
+    try {
+      // Get or create session for this chat
+      const channel = this.channelRepo.findByType(adapter.type);
+      if (!channel) {
+        console.error(`No channel configuration found for ${adapter.type}`);
+        return;
+      }
+
+      // Find existing session or create one
+      let session = this.sessionRepo.findByChatId(channel.id, chatId);
+      if (!session) {
+        // Create a minimal session for handling callback
+        session = this.sessionRepo.create({
+          channelId: channel.id,
+          chatId,
+          state: 'idle',
+        });
+      }
+
+      // Answer the callback to remove loading indicator
+      if (adapter.answerCallbackQuery) {
+        await adapter.answerCallbackQuery(query.id);
+      }
+
+      switch (action) {
+        case 'workspace':
+          await this.handleWorkspaceCallback(adapter, query, session.id, param);
+          break;
+
+        case 'provider':
+          await this.handleProviderCallback(adapter, query, param);
+          break;
+
+        case 'model':
+          await this.handleModelCallback(adapter, query, param);
+          break;
+
+        case 'approve':
+          await this.handleApprovalCallback(adapter, query, session.id, true);
+          break;
+
+        case 'deny':
+          await this.handleApprovalCallback(adapter, query, session.id, false);
+          break;
+
+        default:
+          console.log(`Unknown callback action: ${action}`);
+      }
+    } catch (error) {
+      console.error('Error handling callback query:', error);
+    }
+  }
+
+  /**
+   * Handle workspace selection callback
+   */
+  private async handleWorkspaceCallback(
+    adapter: ChannelAdapter,
+    query: CallbackQuery,
+    sessionId: string,
+    workspaceId: string
+  ): Promise<void> {
+    const workspace = this.workspaceRepo.findById(workspaceId);
+    if (!workspace) {
+      await adapter.sendMessage({
+        chatId: query.chatId,
+        text: '❌ Workspace not found.',
+      });
+      return;
+    }
+
+    // Update session workspace
+    this.sessionManager.setSessionWorkspace(sessionId, workspace.id);
+
+    // Update the original message with the selection
+    if (adapter.editMessageWithKeyboard) {
+      await adapter.editMessageWithKeyboard(
+        query.chatId,
+        query.messageId,
+        `✅ Workspace selected: *${workspace.name}*\n\`${workspace.path}\`\n\nYou can now send messages to create tasks.`
+      );
+    } else {
+      await adapter.sendMessage({
+        chatId: query.chatId,
+        text: `✅ Workspace set to: *${workspace.name}*\n\`${workspace.path}\``,
+        parseMode: 'markdown',
+      });
+    }
+  }
+
+  /**
+   * Handle provider selection callback
+   */
+  private async handleProviderCallback(
+    adapter: ChannelAdapter,
+    query: CallbackQuery,
+    providerType: string
+  ): Promise<void> {
+    const settings = LLMProviderFactory.loadSettings();
+    const status = LLMProviderFactory.getConfigStatus();
+
+    // Update provider
+    const newSettings: LLMSettings = {
+      ...settings,
+      providerType: providerType as LLMProviderType,
+    };
+
+    LLMProviderFactory.saveSettings(newSettings);
+    LLMProviderFactory.clearCache();
+
+    const providerInfo = status.providers.find(p => p.type === providerType);
+
+    // Update the original message
+    if (adapter.editMessageWithKeyboard) {
+      await adapter.editMessageWithKeyboard(
+        query.chatId,
+        query.messageId,
+        `✅ Provider changed to: *${providerInfo?.name || providerType}*\n\nUse /models to see available models.`
+      );
+    } else {
+      await adapter.sendMessage({
+        chatId: query.chatId,
+        text: `✅ Provider changed to: *${providerInfo?.name || providerType}*`,
+        parseMode: 'markdown',
+      });
+    }
+  }
+
+  /**
+   * Handle model selection callback
+   */
+  private async handleModelCallback(
+    adapter: ChannelAdapter,
+    query: CallbackQuery,
+    modelKey: string
+  ): Promise<void> {
+    const settings = LLMProviderFactory.loadSettings();
+    const status = LLMProviderFactory.getConfigStatus();
+    const providerType = status.currentProvider;
+
+    // Save to the appropriate provider-specific setting
+    let newSettings: LLMSettings = { ...settings };
+    let displayName = modelKey;
+
+    switch (providerType) {
+      case 'openai':
+        newSettings.openai = { ...settings.openai, model: modelKey };
+        break;
+      case 'gemini':
+        newSettings.gemini = { ...settings.gemini, model: modelKey };
+        break;
+      case 'openrouter':
+        newSettings.openrouter = { ...settings.openrouter, model: modelKey };
+        break;
+      case 'ollama':
+        newSettings.ollama = { ...settings.ollama, model: modelKey };
+        break;
+      default:
+        newSettings.modelKey = modelKey as ModelKey;
+        const modelInfo = status.models.find(m => m.key === modelKey);
+        displayName = modelInfo?.displayName || modelKey;
+    }
+
+    LLMProviderFactory.saveSettings(newSettings);
+    LLMProviderFactory.clearCache();
+
+    // Update the original message
+    if (adapter.editMessageWithKeyboard) {
+      await adapter.editMessageWithKeyboard(
+        query.chatId,
+        query.messageId,
+        `✅ Model changed to: *${displayName}*`
+      );
+    } else {
+      await adapter.sendMessage({
+        chatId: query.chatId,
+        text: `✅ Model changed to: *${displayName}*`,
+        parseMode: 'markdown',
+      });
+    }
+  }
+
+  /**
+   * Handle approval/deny callback from inline buttons
+   */
+  private async handleApprovalCallback(
+    adapter: ChannelAdapter,
+    query: CallbackQuery,
+    sessionId: string,
+    approved: boolean
+  ): Promise<void> {
+    // Find pending approval for this session
+    const approvalEntry = Array.from(this.pendingApprovals.entries())
+      .find(([, data]) => data.sessionId === sessionId);
+
+    if (!approvalEntry) {
+      if (adapter.editMessageWithKeyboard) {
+        await adapter.editMessageWithKeyboard(
+          query.chatId,
+          query.messageId,
+          '❌ No pending approval request (may have expired).'
+        );
+      }
+      return;
+    }
+
+    const [approvalId] = approvalEntry;
+    this.pendingApprovals.delete(approvalId);
+
+    try {
+      await this.agentDaemon?.respondToApproval(approvalId, approved);
+
+      const statusText = approved ? '✅ Approved! Executing...' : '🛑 Denied. Action cancelled.';
+      if (adapter.editMessageWithKeyboard) {
+        await adapter.editMessageWithKeyboard(
+          query.chatId,
+          query.messageId,
+          statusText
+        );
+      } else {
+        await adapter.sendMessage({
+          chatId: query.chatId,
+          text: statusText,
+        });
+      }
+    } catch (error) {
+      console.error('Error responding to approval:', error);
+      await adapter.sendMessage({
+        chatId: query.chatId,
+        text: '❌ Failed to process response.',
+      });
+    }
+  }
+
+  /**
+   * Emit an event to all handlers
+   */
+  private emitEvent(event: GatewayEvent): void {
+    for (const handler of this.eventHandlers) {
+      try {
+        handler(event);
+      } catch (error) {
+        console.error('Error in event handler:', error);
+      }
+    }
+  }
+}