rails_console_ai 0.20.0 → 0.22.0

data/lib/rails_console_ai/executor.rb

@@ -100,8 +100,13 @@ module RailsConsoleAi
       @last_safety_exception = nil
       captured_output = StringIO.new
       old_stdout = $stdout
-      # Tee output: capture it and also print to the real stdout
-      $stdout = TeeIO.new(old_stdout, captured_output)
+      # When a channel is present it handles display (with truncation), so capture only.
+      # Without a channel, tee so output appears live on the terminal.
+      $stdout = if @channel
+                  captured_output
+                else
+                  TeeIO.new(old_stdout, captured_output)
+                end
 
       RailsConsoleAi::SafetyError.clear!
 
@@ -229,31 +234,6 @@ module RailsConsoleAi
             $stdout.puts colorize("Executing with safety guards disabled.", :red)
           end
           return execute_unsafe(code)
-        when 'e', 'edit'
-          edited = if @channel && @channel.supports_editing?
-                     @channel.edit_code(code)
-                   else
-                     open_in_editor(code)
-                   end
-          if edited && edited != code
-            $stdout.puts colorize("# Edited code:", :yellow)
-            $stdout.puts highlight_code(edited)
-            if @channel
-              edit_answer = @channel.confirm("Execute edited code? [y/N] ")
-            else
-              $stdout.print colorize("Execute edited code? [y/N] ", :yellow)
-              edit_answer = $stdin.gets.to_s.strip.downcase
-              echo_stdin(edit_answer)
-            end
-            if edit_answer == 'y'
-              return execute(edited)
-            else
-              $stdout.puts colorize("Cancelled.", :yellow)
-              return nil
-            end
-          else
-            return execute(code)
-          end
         when 'n', 'no', ''
           $stdout.puts colorize("Cancelled.", :yellow)
           @last_cancelled = true
@@ -366,9 +346,9 @@ module RailsConsoleAi
     def execute_prompt
       guards = RailsConsoleAi.configuration.safety_guards
       if !guards.empty? && guards.enabled? && danger_allowed?
-        "Execute? [y/N/edit/danger] "
+        "Execute? [y/N/danger] "
       else
-        "Execute? [y/N/edit] "
+        "Execute? [y/N] "
       end
     end
 

data/lib/rails_console_ai/providers/bedrock.rb

@@ -72,8 +72,8 @@ module RailsConsoleAi
           text: extract_text(response),
           input_tokens: usage&.input_tokens,
           output_tokens: usage&.output_tokens,
-          cache_read_input_tokens: usage.respond_to?(:cache_read_input_token_count) ? usage.cache_read_input_token_count : nil,
-          cache_write_input_tokens: usage.respond_to?(:cache_write_input_token_count) ? usage.cache_write_input_token_count : nil,
+          cache_read_input_tokens: usage.respond_to?(:cache_read_input_tokens) ? usage.cache_read_input_tokens : nil,
+          cache_write_input_tokens: usage.respond_to?(:cache_write_input_tokens) ? usage.cache_write_input_tokens : nil,
           tool_calls: tool_calls,
           stop_reason: stop
         )
@@ -121,6 +121,8 @@ module RailsConsoleAi
                     else
                       [{ text: msg[:content].to_s }]
                     end
+          # Bedrock rejects empty text blocks in content arrays
+          content.reject! { |block| block.is_a?(Hash) && block.key?(:text) && !block.key?(:tool_use) && !block.key?(:tool_result) && block[:text].to_s.empty? }
           { role: msg[:role].to_s, content: content }
         end
 
@@ -175,7 +177,9 @@ module RailsConsoleAi
 
         usage = response.usage
         if usage
-          $stderr.puts "\e[36m[debug] response: #{response.stop_reason} | in: #{usage.input_tokens} out: #{usage.output_tokens}\e[0m"
+          cache_r = usage.respond_to?(:cache_read_input_tokens) ? usage.cache_read_input_tokens : 'N/A'
+          cache_w = usage.respond_to?(:cache_write_input_tokens) ? usage.cache_write_input_tokens : 'N/A'
+          $stderr.puts "\e[36m[debug] response: #{response.stop_reason} | in: #{usage.input_tokens} out: #{usage.output_tokens} | cache_r: #{cache_r} cache_w: #{cache_w}\e[0m"
         end
       end
     end

data/lib/rails_console_ai/safety_guards.rb

@@ -113,7 +113,16 @@ module RailsConsoleAi
       @installed_bypass_specs ||= Set.new
       return if @installed_bypass_specs.include?(spec)
 
-      class_name, method_name = spec.split('#')
+      if spec.include?('.')
+        class_name, method_name = spec.split('.')
+        class_method = true
+      else
+        class_name, method_name = spec.split('#')
+        class_method = false
+      end
+
+      return unless method_name && !method_name.empty?
+
       klass = Object.const_get(class_name) rescue return
       method_sym = method_name.to_sym
 
@@ -126,7 +135,12 @@ module RailsConsoleAi
           end
         end
       end
-      klass.prepend(bypass_mod)
+
+      if class_method
+        klass.singleton_class.prepend(bypass_mod)
+      else
+        klass.prepend(bypass_mod)
+      end
       @installed_bypass_specs << spec
     end
 

data/lib/rails_console_ai/session_logger.rb

@@ -19,11 +19,12 @@ module RailsConsoleAi
           console_output: attrs[:console_output],
           executed:      attrs[:executed] || false,
           provider:      RailsConsoleAi.configuration.provider.to_s,
-          model:         RailsConsoleAi.configuration.resolved_model,
+          model:         attrs[:model] || RailsConsoleAi.configuration.resolved_model,
           duration_ms:   attrs[:duration_ms],
           created_at:    Time.respond_to?(:current) ? Time.current : Time.now
         }
         create_attrs[:slack_thread_ts] = attrs[:slack_thread_ts] if attrs[:slack_thread_ts]
+        create_attrs[:slack_channel_name] = attrs[:slack_channel_name] if attrs[:slack_channel_name]
         record = session_class.create!(create_attrs)
         record.id
       rescue => e

data/lib/rails_console_ai/slack_bot.rb

@@ -25,8 +25,10 @@ module RailsConsoleAi
       raise ConfigurationError, "slack_allowed_usernames must be configured (e.g. ['alice'] or 'ALL')" unless RailsConsoleAi.configuration.slack_allowed_usernames
 
       @bot_user_id = nil
-      @sessions = {}       # thread_ts → { channel:, engine:, thread: }
+      @sessions = {}       # thread_ts → { channel:, engine:, thread:, owner_user_id: }
       @user_cache = {}     # slack user_id → display_name
+      @channel_cache = {}  # channel_id → channel name
+      @processed_ts = {}   # ts → Time — dedup app_mention vs message events
       @mutex = Mutex.new
     end
 
@@ -282,33 +284,70 @@ module RailsConsoleAi
     def handle_event(msg)
       event = msg.dig(:payload, :event)
       return unless event
-      return unless event[:type] == "message"
+      return unless event[:type] == "message" || event[:type] == "app_mention"
 
       # Ignore bot messages, subtypes (edits/deletes), own messages
       return if event[:bot_id]
       return if event[:user] == @bot_user_id
       return if event[:subtype]
 
-      text = unescape_slack(event[:text])
+      raw_text = event[:text]
+      text = unescape_slack(raw_text)
       return unless text && !text.strip.empty?
 
       channel_id = event[:channel]
-      return unless watched_channel?(channel_id)
-
       thread_ts = event[:thread_ts] || event[:ts]
       user_id = event[:user]
+      is_dm = event[:channel_type] == "im"
+      mentioned = event[:type] == "app_mention" || mentions_bot?(raw_text)
+
+      # --- Channel gating (DMs skip this entirely) ---
+      unless is_dm
+        # Dedup: Slack fires both message and app_mention for @mentions
+        return if mentioned && dedup_event?(event[:ts])
+
+        # Strip bot mention from text
+        text = strip_bot_mention(text).strip
+        return if text.empty?
+
+        session = @mutex.synchronize { @sessions[thread_ts] }
+        if session
+          # Enforce session ownership
+          unless session[:owner_user_id] == user_id
+            # Non-owner: tell unrecognized users, silently ignore recognized non-owners
+            chk_name = resolve_user_name(user_id)
+            chk_list = Array(RailsConsoleAi.configuration.slack_allowed_usernames).map(&:to_s).map(&:downcase)
+            unless chk_list.include?('all') || chk_list.include?(chk_name.to_s.downcase)
+              puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{chk_name} << (ignored — not in allowed usernames)"
+              post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{chk_name}). Ask an admin to add you to the allowed usernames list.")
+            end
+            return
+          end
+          # Owner must @mention unless bot asked a question (waiting_for_reply?)
+          return unless mentioned || waiting_for_reply?(session[:channel])
+          # Log thread messages since last mention
+          thread_msgs = fetch_thread_messages(channel_id, thread_ts, since_ts: session[:last_seen_ts], exclude_ts: event[:ts])
+          log_thread_messages(thread_msgs, channel_id, thread_ts)
+          session[:last_seen_ts] = event[:ts]
+        else
+          # No existing session: only respond if @mentioned
+          return unless mentioned
+        end
+      end
+
+      # --- Common processing (DMs and channels) ---
       user_name = resolve_user_name(user_id)
 
       allowed_list = Array(RailsConsoleAi.configuration.slack_allowed_usernames).map(&:to_s).map(&:downcase)
       unless allowed_list.include?('all') || allowed_list.include?(user_name.to_s.downcase)
-        puts "[#{channel_id}/#{thread_ts}] @#{user_name} << (ignored — not in allowed usernames)"
+        puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name} << (ignored — not in allowed usernames)"
         post_message(channel: channel_id, thread_ts: thread_ts, text: "Sorry, I don't recognize your username (@#{user_name}). Ask an admin to add you to the allowed usernames list.")
         return
       end
 
-      puts "[#{channel_id}/#{thread_ts}] @#{user_name} << #{text.strip}"
+      puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name} << #{text.strip}"
 
-      session = @mutex.synchronize { @sessions[thread_ts] }
+      session ||= @mutex.synchronize { @sessions[thread_ts] }
 
       command = text.strip.downcase
       if command == 'cancel' || command == 'stop'
@@ -333,6 +372,12 @@ module RailsConsoleAi
         return
       end
 
+      # Bang commands (!name, !usage, etc.) — handle before LLM
+      if text.strip.start_with?('!')
+        handle_bang_command(session, channel_id, thread_ts, text.strip, user_name, user_id)
+        return
+      end
+
       # Quick greeting — no need to hit the LLM
       if !session && GREETINGS.include?(command)
         post_message(channel: channel_id, thread_ts: thread_ts, text: ":wave: Hey @#{user_name}! What would you like to look into today?")
@@ -342,21 +387,32 @@ module RailsConsoleAi
       # Direct code execution: code blocks or "> User.count" run code without LLM
       raw_code = extract_direct_code(text.strip)
       if raw_code
-        handle_direct_code(session, channel_id, thread_ts, raw_code, user_name)
+        handle_direct_code(session, channel_id, thread_ts, raw_code, user_name, user_id)
         return
       end
 
       if session
         handle_thread_reply(session, text.strip)
       else
-        # New thread, or existing thread after bot restart — start a fresh session
-        start_session(channel_id, thread_ts, text.strip, user_name)
+        # Fetch thread context if joining a mid-conversation thread
+        thread_context = nil
+        if !is_dm && event[:thread_ts]
+          thread_msgs = fetch_thread_messages(channel_id, thread_ts, exclude_ts: event[:ts])
+          log_thread_messages(thread_msgs, channel_id, thread_ts)
+          thread_context = build_thread_context(thread_msgs)
+        end
+        start_session(channel_id, thread_ts, text.strip, user_name, user_id: user_id, thread_context: thread_context)
+        # Track last seen message for subsequent mentions
+        if !is_dm
+          new_session = @mutex.synchronize { @sessions[thread_ts] }
+          new_session[:last_seen_ts] = event[:ts] if new_session
+        end
       end
     rescue => e
       RailsConsoleAi.logger.error("SlackBot event handling error: #{e.class}: #{e.message}")
     end
 
-    def start_session(channel_id, thread_ts, text, user_name)
+    def start_session(channel_id, thread_ts, text, user_name, user_id: nil, thread_context: nil)
       channel = Channel::Slack.new(
         slack_bot: self,
         channel_id: channel_id,
@@ -368,18 +424,24 @@ module RailsConsoleAi
       engine = ConversationEngine.new(
         binding_context: sandbox_binding,
         channel: channel,
-        slack_thread_ts: thread_ts
+        slack_thread_ts: thread_ts,
+        slack_channel_name: resolve_channel_name(channel_id)
       )
 
       # Try to restore conversation history from a previous session (e.g. after bot restart)
       restored = restore_from_db(engine, thread_ts)
 
-      session = { channel: channel, engine: engine, thread: nil }
+      # Prepend thread context only when joining a thread fresh (no DB session to restore)
+      if !restored && thread_context
+        text = "#{thread_context}\n\n#{text}"
+      end
+
+      session = { channel: channel, engine: engine, thread: nil, owner_user_id: user_id }
       @mutex.synchronize { @sessions[thread_ts] = session }
 
       session[:thread] = Thread.new do
         Thread.current.report_on_exception = false
-        Thread.current[:log_prefix] = "[#{channel_id}/#{thread_ts}] @#{user_name}"
+        Thread.current[:log_prefix] = "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name}"
         begin
           channel.display_dim("_session: #{channel_id}/#{thread_ts}_")
           if restored
@@ -434,10 +496,10 @@ module RailsConsoleAi
       end
     end
 
-    def handle_direct_code(session, channel_id, thread_ts, raw_code, user_name)
+    def handle_direct_code(session, channel_id, thread_ts, raw_code, user_name, user_id)
       # Ensure a session exists for this thread
       unless session
-        start_direct_session(channel_id, thread_ts, user_name)
+        start_direct_session(channel_id, thread_ts, user_name, user_id)
         session = @mutex.synchronize { @sessions[thread_ts] }
       end
 
@@ -467,7 +529,7 @@ module RailsConsoleAi
       end
     end
 
-    def start_direct_session(channel_id, thread_ts, user_name)
+    def start_direct_session(channel_id, thread_ts, user_name, user_id)
       channel = Channel::Slack.new(
         slack_bot: self,
         channel_id: channel_id,
@@ -479,13 +541,14 @@ module RailsConsoleAi
       engine = ConversationEngine.new(
         binding_context: sandbox_binding,
         channel: channel,
-        slack_thread_ts: thread_ts
+        slack_thread_ts: thread_ts,
+        slack_channel_name: resolve_channel_name(channel_id)
       )
 
       restore_from_db(engine, thread_ts)
       engine.init_interactive unless engine.instance_variable_get(:@interactive_start)
 
-      session = { channel: channel, engine: engine, thread: nil }
+      session = { channel: channel, engine: engine, thread: nil, owner_user_id: user_id }
       @mutex.synchronize { @sessions[thread_ts] = session }
     end
 
@@ -493,7 +556,7 @@ module RailsConsoleAi
       if session
         session[:channel].cancel!
         session[:channel].display("Stopped.")
-        puts "[#{channel_id}/#{thread_ts}] cancel requested"
+        puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} cancel requested"
 
         # Record stop in conversation history so restored sessions know
         # the previous topic was abandoned by the user
@@ -507,11 +570,189 @@ module RailsConsoleAi
         end
       else
         post_message(channel: channel_id, thread_ts: thread_ts, text: "No active session to stop.")
-        puts "[#{channel_id}/#{thread_ts}] cancel: no session"
+        puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} cancel: no session"
       end
       @mutex.synchronize { @sessions.delete(thread_ts) }
     end
 
+    def handle_bang_command(session, channel_id, thread_ts, text, user_name, user_id)
+      parts = text.sub(/\A!/, '').split(/\s+/, 2)
+      cmd = parts[0].to_s.downcase
+      arg = parts[1].to_s.strip
+
+      # !name requires an active session (or creates one)
+      # Other commands require an existing session
+      unless session
+        if cmd == 'name' && !arg.empty?
+          # Start a session so we can name it
+          start_direct_session(channel_id, thread_ts, user_name, user_id)
+          session = @mutex.synchronize { @sessions[thread_ts] }
+        else
+          post_message(channel: channel_id, thread_ts: thread_ts,
+            text: "No active session in this thread. Start a conversation first.")
+          return
+        end
+      end
+
+      engine = session[:engine]
+
+      case cmd
+      when 'name'
+        handle_bang_name(engine, channel_id, thread_ts, arg)
+      when 'usage'
+        summary = bang_usage(engine)
+        post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
+      when 'cost'
+        summary = bang_cost(engine)
+        post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
+      when 'compact'
+        session[:thread] = Thread.new do
+          Thread.current.report_on_exception = false
+          begin
+            before = engine.history.length
+            engine.compact_history
+            after = engine.history.length
+            if after < before
+              post_message(channel: channel_id, thread_ts: thread_ts,
+                text: "Compacted: #{before} messages → #{after} summary message")
+            end
+          rescue => e
+            post_message(channel: channel_id, thread_ts: thread_ts,
+              text: "Compact failed: #{e.message}")
+          ensure
+            ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+          end
+        end
+      when 'model'
+        summary = bang_model(engine)
+        post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
+      when 'think'
+        model = engine.upgrade_to_thinking_model
+        post_message(channel: channel_id, thread_ts: thread_ts,
+          text: "Switched to thinking model: `#{model}`")
+      when 'unthink'
+        model = engine.downgrade_from_thinking_model
+        post_message(channel: channel_id, thread_ts: thread_ts,
+          text: "Switched to default model: `#{model}`")
+      when 'context'
+        summary = bang_context(engine)
+        post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
+      when 'retry'
+        session[:thread] = Thread.new do
+          Thread.current.report_on_exception = false
+          Thread.current[:log_prefix] = session[:channel].instance_variable_get(:@log_prefix)
+          begin
+            engine.retry_last_code
+            engine.send(:log_interactive_turn)
+          rescue => e
+            post_message(channel: channel_id, thread_ts: thread_ts,
+              text: "Retry failed: #{e.message}")
+          ensure
+            ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+          end
+        end
+      else
+        commands = %w[name usage cost model compact think unthink context retry].map { |c| "`!#{c}`" }
+        post_message(channel: channel_id, thread_ts: thread_ts,
+          text: "Unknown command `!#{cmd}`. Available: #{commands.join(', ')}")
+      end
+    end
+
+    def handle_bang_name(engine, channel_id, thread_ts, arg)
+      name = arg.gsub(/\A['"]|['"]\z/, '')
+      if name.empty?
+        current = engine.session_name
+        if current
+          post_message(channel: channel_id, thread_ts: thread_ts,
+            text: "Session name: *#{current}*\nResume in console with: `ai_resume \"#{current}\"`")
+        else
+          post_message(channel: channel_id, thread_ts: thread_ts,
+            text: "Usage: `!name <label>` — e.g. `!name salesforce_debug`")
+        end
+      else
+        engine.set_session_name(name)
+        post_message(channel: channel_id, thread_ts: thread_ts,
+          text: "Session named: *#{name}*\nResume in console with: `ai_resume \"#{name}\"`")
+      end
+    end
+
+    def bang_model(engine = nil)
+      config = RailsConsoleAi.configuration
+      model = engine ? engine.effective_model : config.resolved_model
+      thinking = config.resolved_thinking_model
+      pricing = Configuration::PRICING[model]
+
+      lines = ["*Model info:*"]
+      lines << "  Provider: `#{config.provider}`"
+      lines << "  Model: `#{model}`"
+      lines << "  Thinking model: `#{thinking}`"
+      lines << "  Max tokens: #{config.resolved_max_tokens}"
+      if pricing
+        lines << "  Pricing: $#{pricing[:input] * 1_000_000}/M in, $#{pricing[:output] * 1_000_000}/M out"
+        if pricing[:cache_read]
+          lines << "  Cache: $#{pricing[:cache_read] * 1_000_000}/M read, $#{pricing[:cache_write] * 1_000_000}/M write"
+        end
+      end
+      lines << "  Region: `#{config.bedrock_region}`" if config.provider == :bedrock
+      lines.join("\n")
+    end
+
+    def bang_usage(engine)
+      input = engine.total_input_tokens
+      output = engine.total_output_tokens
+      total = input + output
+      return "No usage yet." if total == 0
+      "Session totals — in: #{input} | out: #{output} | total: #{total}"
+    end
+
+    def bang_cost(engine)
+      token_usage = engine.instance_variable_get(:@token_usage)
+      return "No usage yet." if token_usage.empty?
+
+      lines = ["*Cost estimate:*"]
+      total_cost = 0.0
+
+      token_usage.each do |model, usage|
+        pricing = Configuration::PRICING[model]
+        pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
+        input_str = "in: #{usage[:input]}"
+        output_str = "out: #{usage[:output]}"
+
+        if pricing
+          cost = (usage[:input] * pricing[:input]) + (usage[:output] * pricing[:output])
+          cache_read = usage[:cache_read] || 0
+          cache_write = usage[:cache_write] || 0
+          if (cache_read > 0 || cache_write > 0) && pricing[:cache_read]
+            cost -= cache_read * pricing[:input]
+            cost += cache_read * pricing[:cache_read]
+            cost += cache_write * (pricing[:cache_write] - pricing[:input])
+          end
+          total_cost += cost
+          cache_str = ""
+          cache_str = "  cache r: #{cache_read} w: #{cache_write}" if cache_read > 0 || cache_write > 0
+          lines << "  `#{model}`: #{input_str}  #{output_str}#{cache_str}  ~$#{'%.2f' % cost}"
+        else
+          lines << "  `#{model}`: #{input_str}  #{output_str}  (pricing unknown)"
+        end
+      end
+
+      lines << "*Total: ~$#{'%.2f' % total_cost}*"
+      lines.join("\n")
+    end
+
+    def bang_context(engine)
+      history = engine.history
+      return "No conversation history yet." if history.empty?
+
+      msg_count = history.length
+      chars = history.sum { |m| m[:content].to_s.length }
+      user_msgs = history.count { |m| m[:role].to_s == 'user' }
+      asst_msgs = history.count { |m| m[:role].to_s == 'assistant' }
+      name_str = engine.session_name ? " (*#{engine.session_name}*)" : ""
+
+      "Context#{name_str}: #{msg_count} messages (#{user_msgs} user, #{asst_msgs} assistant), ~#{chars} chars"
+    end
+
     def count_bot_messages(channel_id, thread_ts)
       result = slack_get("conversations.replies", channel: channel_id, ts: thread_ts, limit: 200)
       return 0 unless result["ok"]
@@ -523,18 +764,18 @@ module RailsConsoleAi
     def clear_bot_messages(channel_id, thread_ts)
       result = slack_get("conversations.replies", channel: channel_id, ts: thread_ts, limit: 200)
       unless result["ok"]
-        puts "[#{channel_id}/#{thread_ts}] clear: failed to fetch replies: #{result["error"]}"
+        puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} clear: failed to fetch replies: #{result["error"]}"
         return
       end
 
       bot_messages = (result["messages"] || []).select { |m| m["user"] == @bot_user_id }
       bot_messages.each do |m|
-        puts "[#{channel_id}/#{thread_ts}] clearing #{channel_id.length} / #{m["ts"]}"
+        puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} clearing #{channel_id.length} / #{m["ts"]}"
         slack_api("chat.delete", channel: channel_id, ts: m["ts"])
       end
-      puts "[#{channel_id}/#{thread_ts}] cleared #{bot_messages.length} bot messages"
+      puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} cleared #{bot_messages.length} bot messages"
     rescue => e
-      puts "[#{channel_id}/#{thread_ts}] clear failed: #{e.message}"
+      puts "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} clear failed: #{e.message}"
     end
 
     def slack_get(method, **params)
@@ -619,6 +860,102 @@ module RailsConsoleAi
       @user_cache[user_id] = user_id
     end
 
+    def resolve_channel_name(channel_id)
+      return @channel_cache[channel_id] if @channel_cache.key?(channel_id)
+
+      result = slack_get("conversations.info", channel: channel_id)
+      if result["ok"]
+        name = result.dig("channel", "name")
+        @channel_cache[channel_id] = name
+      else
+        puts "WARNING: conversations.info failed for #{channel_id}: #{result["error"]} — add channels:read scope to your Slack app for channel names in logs"
+        @channel_cache[channel_id] = nil
+      end
+    rescue => e
+      RailsConsoleAi.logger.warn("Failed to resolve channel name for #{channel_id}: #{e.message}")
+      @channel_cache[channel_id] = nil
+    end
+
+    def channel_log_tag(channel_id)
+      name = resolve_channel_name(channel_id)
+      name ? " (#{name})" : ""
+    end
+
+    # --- @mention helpers ---
+
+    def mentions_bot?(raw_text)
+      raw_text&.include?("<@#{@bot_user_id}>")
+    end
+
+    def strip_bot_mention(text)
+      text.gsub(/<@#{@bot_user_id}>\s*/, '')
+    end
+
+    # Dedup: returns true if this ts was already processed (within 60s window)
+    def dedup_event?(ts)
+      now = Time.now
+      @mutex.synchronize do
+        @processed_ts.delete_if { |_, t| now - t > 60 }
+        if @processed_ts.key?(ts)
+          true
+        else
+          @processed_ts[ts] = now
+          false
+        end
+      end
+    end
+
+    # Fetch raw messages from a thread. Returns an array of Slack message hashes.
+    def fetch_thread_messages(channel_id, thread_ts, since_ts: nil, exclude_ts: nil)
+      params = { channel: channel_id, ts: thread_ts, limit: 200 }
+      params[:oldest] = since_ts if since_ts
+      result = slack_get("conversations.replies", **params)
+      return [] unless result["ok"]
+
+      messages = result["messages"] || []
+      messages = messages.reject { |m| m["ts"] == exclude_ts }
+      messages
+    rescue => e
+      RailsConsoleAi.logger.warn("SlackBot: failed to fetch thread messages: #{e.message}")
+      []
+    end
+
+    # Log thread messages to stdout.
+    def log_thread_messages(messages, channel_id, thread_ts)
+      return if messages.empty?
+      tag = channel_log_tag(channel_id)
+      messages.each do |m|
+        name = m["user"] ? resolve_user_name(m["user"]) : (m["username"] || "bot")
+        text = unescape_slack(m["text"] || "")
+        text = strip_bot_mention(text).strip
+        next if text.empty?
+        puts "[#{channel_id}/#{thread_ts}]#{tag} (thread) @#{name}: #{text}"
+      end
+    end
+
+    # Build a context string from thread messages to prepend to the user's first message.
+    # Returns a formatted string, or nil if no messages.
+    def build_thread_context(messages)
+      return nil if messages.empty?
+
+      lines = messages.filter_map do |m|
+        text = unescape_slack(m["text"] || "")
+        text = strip_bot_mention(text).strip
+        next if text.empty?
+        name = if m["user"]
+                 resolve_user_name(m["user"])
+               else
+                 m["username"] || "bot"
+               end
+        "@#{name}: #{text}"
+      end
+      return nil if lines.empty?
+
+      "[You were tagged in an ongoing Slack thread. Here is the conversation so far:]\n\n" \
+        "#{lines.join("\n")}\n\n" \
+        "[End of thread context]"
+    end
+
     def log_startup
       channel_info = if @channel_ids && !@channel_ids.empty?
                        "channels: #{@channel_ids.join(', ')}"