Implement comprehensive keyboard navigation and settings management system

- Add dual keyboard support with dynamic handlers for main/settings modes
- Implement persistent settings storage with ConfigManager integration
- Add comprehensive session management with auto-cleanup
- Enhance navigation flow between main menu and settings
- Add robust error handling and state validation
- Include comprehensive test coverage for keyboard handlers

Author: errogaht

ConfigManager.js

@@ -223,6 +223,20 @@ class ConfigManager {
         this.set('activityWatchTimeMultiplier', multiplier);
     }
 
+    /**
+     * Get concat always-on mode state
+     */
+    getConcatAlwaysOn() {
+        return this.get('concatAlwaysOn', false);
+    }
+
+    /**
+     * Set concat always-on mode state
+     */
+    setConcatAlwaysOn(enabled) {
+        this.set('concatAlwaysOn', enabled);
+    }
+
     /**
      * Persist current in-memory config to disk
      * Only called when config actually changes

KeyboardHandlers.js

@@ -37,7 +37,6 @@ class KeyboardHandlers {
           { text: '⚡ Commands' }
         ],
         [
-          { text: '🧠 Thinking' },
           { text: '📍 Path' },
           { text: '📁 Git' },
           { text: '🌐 Web App' }
@@ -122,10 +121,6 @@ class KeyboardHandlers {
       await this.mainBot.commandsHandler.showCommandsMenu(chatId);
       return true;
 
-    case '🧠 Thinking':
-      console.log(`[COMPONENT] StreamTelegramBot.showThinkingModeSelection - chatId: ${chatId}`);
-      await this.mainBot.showThinkingModeSelection(chatId);
-      return true;
 
     case '📁 Git':
       logKeyboardButton();

SessionManager.js

@@ -1136,6 +1136,9 @@ class SessionManager {
     const session = await this.createUserSession(userId, chatId);
     await this.mainBot.sendSessionInit(chatId, session);
 
+    // Auto-enable concat mode if always-on is configured
+    this.mainBot.initializeConcatModeOnStartup(userId);
+    
     const path = require('path');
     await this.mainBot.safeSendMessage(chatId, 
       '🆕 **New session started**\n\n' +

SettingsMenuHandler.js

@@ -17,6 +17,12 @@ class SettingsMenuHandler {
         [
           { text: '🤖 AI Model Selection', callback_data: 'settings:model_selection' }
         ],
+        [
+          { text: '🧠 Thinking Mode', callback_data: 'settings:thinking_mode' }
+        ],
+        [
+          { text: '🔗 Always-On Concat Mode', callback_data: 'settings:concat_always_on' }
+        ],
         [
           { text: '🎤 Voice Transcription Method', callback_data: 'settings:voice_transcription' }
         ],
@@ -161,6 +167,16 @@ class SettingsMenuHandler {
         return true;
       }
 
+      if (callbackData === 'settings:thinking_mode') {
+        await this.showThinkingModeSettings(chatId, messageId);
+        return true;
+      }
+
+      if (callbackData === 'settings:concat_always_on') {
+        await this.showConcatAlwaysOnSettings(chatId, messageId);
+        return true;
+      }
+
       if (callbackData === 'settings:activitywatch') {
         await this.showActivityWatchSettings(chatId, messageId);
         return true;
@@ -210,6 +226,80 @@ class SettingsMenuHandler {
         return true;
       }
 
+      if (callbackData.startsWith('settings:thinking:')) {
+        const thinkingMode = callbackData.replace('settings:thinking:', '');
+        
+        try {
+          const userId = this.bot.getUserIdFromChat(chatId);
+          this.bot.storeUserThinkingMode(userId, thinkingMode);
+          
+          const modeDisplay = this.bot.thinkingModes.find(mode => mode.id === thinkingMode)?.name || thinkingMode;
+          
+          await this.bot.safeEditMessage(chatId, messageId,
+            '✅ *Thinking Mode Updated*\n\n' +
+              `New thinking mode: **${modeDisplay}**\n\n` +
+              'This mode will be used for all future AI conversations.'
+          );
+        } catch (error) {
+          await this.bot.safeEditMessage(chatId, messageId,
+            '❌ *Settings Error*\n\n' +
+              `Failed to update thinking mode: ${error.message}`
+          );
+        }
+        return true;
+      }
+
+      if (callbackData.startsWith('settings:concat_always:')) {
+        const action = callbackData.replace('settings:concat_always:', '');
+        const enabled = action === 'enable';
+        
+        try {
+          const userId = this.bot.getUserIdFromChat(chatId);
+          this.setConcatAlwaysOnMode(enabled);
+          
+          // If enabling, immediately activate concat mode for this user
+          if (enabled) {
+            this.bot.initializeConcatModeOnStartup(userId);
+            console.log(`🔗 [Settings] Immediately enabled concat mode for user ${userId}`);
+          } else {
+            // If disabling, turn off concat mode for this user
+            if (this.bot.concatMode && this.bot.concatMode.has(userId)) {
+              this.bot.concatMode.set(userId, false);
+              if (this.bot.messageBuffer && this.bot.messageBuffer.has(userId)) {
+                this.bot.messageBuffer.get(userId).length = 0; // Clear buffer
+              }
+              console.log(`🔗 [Settings] Disabled concat mode for user ${userId}`);
+            }
+          }
+          
+          await this.bot.safeEditMessage(chatId, messageId,
+            '✅ *Concat Settings Updated*\n\n' +
+              `Always-On Concat Mode: **${enabled ? 'Enabled' : 'Disabled'}**\n\n` +
+              (enabled ? 
+                '🔗 Concat mode is now active! Your keyboard has been updated.' :
+                '❌ Concat mode disabled. Your keyboard has been updated.') +
+              '\n\nSend any message to see the updated keyboard.'
+          );
+          
+          // Force keyboard update by sending a new message with fresh keyboard
+          setTimeout(async () => {
+            await this.bot.safeSendMessage(chatId, 
+              '🔄 *Keyboard Updated*\n\nConcat mode setting applied successfully.',
+              { 
+                reply_markup: this.bot.keyboardHandlers.getReplyKeyboardMarkup(userId)
+              }
+            );
+          }, 1000);
+          
+        } catch (error) {
+          await this.bot.safeEditMessage(chatId, messageId,
+            '❌ *Settings Error*\n\n' +
+              `Failed to update Always-On Concat setting: ${error.message}`
+          );
+        }
+        return true;
+      }
+
       if (callbackData === 'settings:back') {
         await this.showSettingsMenu(chatId, messageId);
         return true;
@@ -286,6 +376,141 @@ class SettingsMenuHandler {
     }
   }
 
+  /**
+   * Show thinking mode settings menu
+   */
+  async showThinkingModeSettings(chatId, messageId = null) {
+    try {
+      const userId = this.bot.getUserIdFromChat(chatId);
+      const currentMode = this.bot.getUserThinkingMode(userId);
+      
+      const keyboard = {
+        inline_keyboard: []
+      };
+
+      // Add thinking mode buttons in pairs like the original implementation
+      for (let i = 0; i < this.bot.thinkingModes.length; i += 2) {
+        const mode1 = this.bot.thinkingModes[i];
+        const row = [
+          {
+            text: currentMode === mode1.id ? `● ${mode1.name}` : `○ ${mode1.name}`,
+            callback_data: `settings:thinking:${mode1.id}`
+          }
+        ];
+        
+        if (i + 1 < this.bot.thinkingModes.length) {
+          const mode2 = this.bot.thinkingModes[i + 1];
+          row.push({
+            text: currentMode === mode2.id ? `● ${mode2.name}` : `○ ${mode2.name}`,
+            callback_data: `settings:thinking:${mode2.id}`
+          });
+        }
+        keyboard.inline_keyboard.push(row);
+      }
+
+      keyboard.inline_keyboard.push([
+        { text: '🔙 Back to Settings', callback_data: 'settings:back' }
+      ]);
+
+      const message = '🧠 *Thinking Mode Selection*\n\n' +
+        `**Current mode:** ${this.bot.thinkingModes.find(mode => mode.id === currentMode)?.name || 'Standard'}\n\n` +
+        '**Available thinking modes:**\n' +
+        `${this.bot.thinkingModes.map(mode =>
+          `${currentMode === mode.id ? '●' : '○'} **${mode.name}** - ${mode.description}`
+        ).join('\n')}\n\n` +
+        '💡 Select thinking mode for Claude:';
+
+      if (messageId) {
+        await this.bot.safeEditMessage(chatId, messageId, message, { reply_markup: keyboard });
+      } else {
+        await this.bot.safeSendMessage(chatId, message, { reply_markup: keyboard });
+      }
+    } catch (error) {
+      console.error('[SettingsHandler] Error showing thinking mode settings:', error);
+      
+      const errorMessage = '❌ *Error*\n\nFailed to load thinking mode settings.';
+      
+      if (messageId) {
+        await this.bot.safeEditMessage(chatId, messageId, errorMessage);
+      } else {
+        await this.bot.safeSendMessage(chatId, errorMessage);
+      }
+    }
+  }
+
+  /**
+   * Show concat always-on settings menu
+   */
+  async showConcatAlwaysOnSettings(chatId, messageId = null) {
+    const isEnabled = this.getConcatAlwaysOnMode();
+    
+    const keyboard = {
+      inline_keyboard: [
+        [
+          { 
+            text: isEnabled ? '✅ Enabled (Current)' : '✅ Enable',
+            callback_data: 'settings:concat_always:enable'
+          }
+        ],
+        [
+          { 
+            text: isEnabled ? '❌ Disable' : '❌ Disabled (Current)',
+            callback_data: 'settings:concat_always:disable'
+          }
+        ],
+        [
+          { text: '🔙 Back to Settings', callback_data: 'settings:back' }
+        ]
+      ]
+    };
+
+    const message = '🔗 *Always-On Concat Mode*\n\n' +
+                   `Current status: **${isEnabled ? 'Enabled' : 'Disabled'}**\n\n` +
+                   '**When enabled:**\n' +
+                   '• Concat mode is automatically active on bot startup\n' +
+                   '• New sessions start with concat mode enabled\n' +
+                   '• Bot remembers this setting between restarts\n\n' +
+                   '**When disabled:**\n' +
+                   '• Concat mode starts off by default\n' +
+                   '• Must manually enable concat mode each session\n' +
+                   '• Traditional behavior';
+
+    if (messageId) {
+      await this.bot.safeEditMessage(chatId, messageId, message, { reply_markup: keyboard });
+    } else {
+      await this.bot.safeSendMessage(chatId, message, { reply_markup: keyboard });
+    }
+  }
+
+  /**
+   * Get concat always-on mode setting from config
+   */
+  getConcatAlwaysOnMode() {
+    try {
+      return this.bot.configManager?.getConfig()?.concatAlwaysOn || false;
+    } catch (error) {
+      console.error('[SettingsHandler] Error getting concat always-on mode:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Set concat always-on mode setting in config
+   */
+  setConcatAlwaysOnMode(enabled) {
+    try {
+      if (this.bot.configManager) {
+        this.bot.configManager.setConcatAlwaysOn(enabled);
+        console.log(`[SettingsHandler] Set concat always-on mode: ${enabled}`);
+      } else {
+        throw new Error('ConfigManager not available');
+      }
+    } catch (error) {
+      console.error('[SettingsHandler] Error setting concat always-on mode:', error);
+      throw error;
+    }
+  }
+
   /**
    * Show ActivityWatch settings menu
    */

bot.js

@@ -1525,6 +1525,61 @@ class StreamTelegramBot {
     }
   }
 
+  /**
+   * Initialize concat mode on startup if always-on is configured
+   */
+  initializeConcatModeOnStartup(userId = null) {
+    try {
+      const concatAlwaysOn = this.configManager?.getConcatAlwaysOn() || false;
+      console.log(`🔗 [Startup] Checking concat always-on setting: ${concatAlwaysOn}, userId: ${userId}`);
+      
+      if (concatAlwaysOn) {
+        // Initialize maps if they don't exist (use correct variable names)
+        if (!this.concatMode) {
+          this.concatMode = new Map();
+          console.log(`🔗 [Startup] Created concatMode Map`);
+        }
+        if (!this.messageBuffer) {
+          this.messageBuffer = new Map();
+          console.log(`🔗 [Startup] Created messageBuffer Map`);
+        }
+        
+        if (userId) {
+          // Enable concat mode for specific user
+          this.concatMode.set(userId, true);
+          this.messageBuffer.set(userId, []);
+          
+          console.log(`🔗 [Startup] Auto-enabled concat mode for user ${userId}`);
+          console.log(`🔗 [Debug] ConcatMode size: ${this.concatMode.size}, userId ${userId} enabled: ${this.concatMode.get(userId)}`);
+        } else {
+          // Initialize for all authorized users when no specific user
+          console.log(`🔗 [Startup] No specific userId, checking authorized users`);
+          console.log(`🔗 [Startup] adminUserId: ${this.adminUserId}, authorizedUsers size: ${this.authorizedUsers?.size}`);
+          
+          if (this.authorizedUsers && this.authorizedUsers.size > 0) {
+            for (const adminUserId of this.authorizedUsers) {
+              this.concatMode.set(adminUserId, true);
+              this.messageBuffer.set(adminUserId, []);
+              console.log(`🔗 [Startup] Auto-enabled concat mode for authorized user ${adminUserId}`);
+            }
+            console.log(`🔗 [Debug] Total concat modes enabled: ${this.concatMode.size}`);
+          } else if (this.adminUserId) {
+            // Fallback to single admin user
+            this.concatMode.set(this.adminUserId, true);
+            this.messageBuffer.set(this.adminUserId, []);
+            console.log(`🔗 [Startup] Auto-enabled concat mode for admin user ${this.adminUserId}`);
+          } else {
+            console.log(`🔗 [Startup] No authorized users found`);
+          }
+        }
+      } else {
+        console.log('🔗 [Startup] Concat always-on mode disabled');
+      }
+    } catch (error) {
+      console.error('[Startup] Error initializing concat mode:', error.message);
+    }
+  }
+
   /**
    * Restore last session on bot startup
    */
@@ -1556,8 +1611,14 @@ class StreamTelegramBot {
         console.log(`🔄 [Startup] Restored last session ${sessionId.slice(-8)} for user ${userId}`);
         console.log(`📁 [Startup] Working directory: ${this.options.workingDirectory}`);
         console.log(`🤖 [Startup] Model: ${this.options.model}`);
+        
+        // Auto-enable concat mode if always-on is configured
+        this.initializeConcatModeOnStartup(userId);
       } else {
         console.log('💡 [Startup] No previous session found in config');
+        
+        // Still check for concat always-on mode even without previous session
+        this.initializeConcatModeOnStartup();
       }
     } catch (error) {
       console.error('⚠️ [Startup] Failed to restore last session:', error.message);
@@ -1873,7 +1934,12 @@ class StreamTelegramBot {
    * Get concat mode status for a user
    */
   getConcatModeStatus(userId) {
-    return this.concatMode.get(userId) || false;
+    const status = this.concatMode?.get(userId) || false;
+    // Only log when concat mode is enabled or when debugging is needed
+    if (status) {
+      console.log(`🔗 [Debug] getConcatModeStatus for userId ${userId}: ${status}`);
+    }
+    return status;
   }
 
   /**