rails_console_ai 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee0daa4b9926c6df19c9e2946f019b5d17dd3bd64d4e8998e92d86ed16dff8e1
-  data.tar.gz: f336fe3abf34a513a5de12b138d69f4941e3cd65eeecaa8b548658d3da8b846e
+  metadata.gz: 8faec693c3d3c83dafcaa65437081d5ba8e235f04527a28182104c4ecba5b80d
+  data.tar.gz: 171445a3ddc0c50093b1688260545df1558548a29cb81a6d3262d15d8ec4cf3c
 SHA512:
-  metadata.gz: 35d266cac783a3e43a6712380085215b7ba7503874b4f7a97ce6fac30875bded29e658d52dc4d1196bcb2e907e555255538ec6563e190212ea0bbcc6c02179d4
-  data.tar.gz: 64e365d8d18a9a559bf9c8ec5b982f7ecff03d1faed9d731bc3734b6493cdeb7cab3055de5ae56da3e5d5112ccfb7b6ecf47b652a7a570c8fdb8401e0eddcf40
+  metadata.gz: 1d0689ebfc82073deb58f8bd03fce39503541d63f042f531322bfc11ef0d6cf65f69fa9ae59c8b89a8a549ea9b4b7893e8505da83887ec4cbc5c1a064ffa5d99
+  data.tar.gz: e8f635c26035fcf73f2ccda5bd3d403a2ec33ef806c701c28f67ee8888a8189625a2569f45c369f7b29189fda3b162f03067be26590afbe5428be9da15487552

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.21.0]
+
+- Add Slack @mention support and channel name tracking
+- Stop looping after user cancels execution
+- Remove edit feature from executor
+- Include more info in tool call log line
+- Support class methods in `bypass_guards_for_methods`
+- Rename setup tasks to `ai_db_setup` and `ai_db_migrate`
+- Fix effective model resolution in multi-threaded Slack bot
+- Fix cost tracking with prompt caching through Bedrock
+- Add `/unthink` command
+- Make `!think` / `/think` thread-safe for Slack
+- Fix truncating console output
+- Reduce cost by deferring large output until LLM requests it
+- Add `!name`, `!model`, and `/model` commands to Slack and console
+
 ## [0.20.0]
 
 - Add per-user system prompt seeding

data/README.md

@@ -12,7 +12,7 @@ irb> ai "find the 5 most recent orders over $100"
 
   Order.where("total > ?", 100).order(created_at: :desc).limit(5)
 
-Execute? [y/N/edit/danger] y
+Execute? [y/N/danger] y
 => [#<Order id: 4821, ...>, ...]
 ```
 
@@ -62,7 +62,8 @@ end
 | `ai!` | Enter interactive mode (multi-turn conversation) |
 | `ai? "query"` | Explain only, no execution |
 | `ai_init` | Generate app guide for better AI context |
-| `ai_setup` | Install session logging table |
+| `ai_db_setup` | Install session logging table + run migrations |
+| `ai_db_migrate` | Run pending session table migrations |
 | `ai_sessions` | List recent sessions |
 | `ai_resume` | Resume a session by name or ID |
 | `ai_memories` | Show stored memories |
@@ -100,7 +101,7 @@ Say "think harder" in any query to auto-upgrade to the thinking model for that s
 - **Skills** — predefined procedures with guard bypasses that the AI activates on demand
 - **Memories** — AI saves what it learns about your app across sessions
 - **App guide** — `ai_init` generates a guide injected into every system prompt
-- **Sessions** — name, list, and resume interactive conversations (`ai_setup` to enable)
+- **Sessions** — name, list, and resume interactive conversations (`ai_db_setup` to enable)
 - **History compaction** — `/compact` summarizes long conversations to reduce cost and latency
 - **Output trimming** — older execution outputs are automatically replaced with references; the LLM can recall them on demand via `recall_output`, and you can `/expand <id>` to see them
 - **Debug mode** — `/debug` shows context breakdown, token counts, and per-call cost estimates before and after each LLM call
@@ -213,7 +214,7 @@ Skills and global `bypass_guards_for_methods` coexist — use config-level bypas
 ### Toggling Safe Mode
 
 - **`/danger`** in interactive mode toggles all guards off/on for the session
-- **`d`** at the `Execute? [y/N/edit/danger]` prompt disables guards for that single execution
+- **`d`** at the `Execute? [y/N/danger]` prompt disables guards for that single execution
 - When a guard blocks an operation, the user is prompted: `Re-run with safe mode disabled? [y/N]`
 
 ## LLM Providers
@@ -296,7 +297,7 @@ Timeout is automatically raised to 300s minimum for local models to account for
 RailsConsoleAi.configure do |config|
   config.provider = :anthropic       # :anthropic, :openai, :bedrock, :local
   config.auto_execute = false         # true to skip confirmations
-  config.session_logging = true       # requires ai_setup
+  config.session_logging = true       # requires ai_db_setup
   config.temperature = 0.2
   config.timeout = 30                 # HTTP timeout in seconds
   config.max_tool_rounds = 200        # safety cap on tool-use loops
@@ -363,11 +364,14 @@ Run RailsConsoleAi as a Slack bot. Each Slack thread becomes an independent AI s
 3. **Bot Token Scopes** — OAuth & Permissions → Bot Token Scopes, add:
    - `chat:write`
    - `channels:history` (public channels)
+   - `channels:read` (channel names in logs, optional)
    - `groups:history` (private channels, optional)
+   - `groups:read` (private channel names in logs, optional)
    - `im:history` (direct messages)
    - `users:read`
 
 4. **Event Subscriptions** — Event Subscriptions → toggle ON, then under "Subscribe to bot events" add:
+   - `app_mention` (respond when @mentioned in any channel)
    - `message.channels` (public channels)
    - `message.groups` (private channels, optional)
    - `message.im` (direct messages)
@@ -399,7 +403,12 @@ end
 bundle exec rake rails_console_ai:slack
 ```
 
-This starts a long-running process (run it separately from your web server). Each new message creates a session; threaded replies continue the conversation. The bot auto-executes code with safety guards always enabled — there is no `/danger` equivalent in Slack.
+This starts a long-running process (run it separately from your web server). The bot auto-executes code with safety guards always enabled — there is no `/danger` equivalent in Slack.
+
+**@mention behavior:**
+- **DMs** — the bot responds to all messages, no @mention needed.
+- **Channels** — the bot only responds when @mentioned. @mention it in any channel message or thread to start a session. The person who first @mentions the bot owns the session — only they can continue the conversation, and they must @mention the bot on each message. Exception: when the bot asks a question, the owner can reply without @mentioning.
+- **Joining threads** — when @mentioned mid-thread, the bot reads the thread history for context so it understands what's already been discussed.
 
 ## Requirements
 

data/app/views/rails_console_ai/sessions/index.html.erb

@@ -13,6 +13,7 @@
       <tr>
         <th>Time</th>
         <th>User</th>
+        <th>Channel</th>
         <th>Name</th>
         <th style="max-width: 400px;">Query</th>
         <th>Mode</th>
@@ -26,6 +27,7 @@
         <tr>
           <td class="mono"><%= session.created_at.strftime('%Y-%m-%d %H:%M') %></td>
           <td><%= session.user_name %></td>
+          <td><%= session.try(:slack_channel_name).presence || '-' %></td>
           <td><%= session.name.present? ? session.name : '-' %></td>
           <td class="query-cell"><a href="<%= rails_console_ai.session_path(session) %>" title="<%= h session.query.truncate(200) %>"><%= truncate(session.query.gsub(/\s+/, ' ').strip, length: 80) %></a></td>
           <td><span class="badge badge-<%= session.mode %>"><%= session.mode %></span></td>

data/app/views/rails_console_ai/sessions/show.html.erb

@@ -30,6 +30,12 @@
       <label>User</label>
       <span><%= @session.user_name || '-' %></span>
     </div>
+    <% if @session.try(:slack_channel_name).present? %>
+      <div class="meta-item">
+        <label>Channel</label>
+        <span><%= @session.slack_channel_name %></span>
+      </div>
+    <% end %>
     <div class="meta-item">
       <label>Provider / Model</label>
       <span><%= @session.provider %> / <%= @session.model %></span>

data/lib/rails_console_ai/channel/console.rb

@@ -37,6 +37,33 @@ module RailsConsoleAi
         $stdout.puts
       end
 
+      def display_result_output(output)
+        text = output.to_s
+        return if text.strip.empty?
+
+        lines = text.lines
+        total_lines = lines.length
+        total_chars = text.length
+
+        if total_lines <= MAX_DISPLAY_LINES && total_chars <= MAX_DISPLAY_CHARS
+          $stdout.print text
+        else
+          truncated = lines.first(MAX_DISPLAY_LINES).join
+          truncated = truncated[0, MAX_DISPLAY_CHARS] if truncated.length > MAX_DISPLAY_CHARS
+          $stdout.print truncated
+
+          omitted_lines = [total_lines - MAX_DISPLAY_LINES, 0].max
+          omitted_chars = [total_chars - truncated.length, 0].max
+          parts = []
+          parts << "#{omitted_lines} lines" if omitted_lines > 0
+          parts << "#{omitted_chars} chars" if omitted_chars > 0
+
+          @omitted_counter += 1
+          @omitted_outputs[@omitted_counter] = text
+          $stdout.puts colorize("  (output truncated, omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
+        end
+      end
+
       def display_result(result)
         full = "=> #{result.inspect}"
         lines = full.lines
@@ -255,8 +282,12 @@ module RailsConsoleAi
           @engine.display_conversation
         when '/cost'
           @engine.display_cost_summary
+        when '/model'
+          display_model_info
         when '/think'
           @engine.upgrade_to_thinking_model
+        when '/unthink'
+          @engine.downgrade_from_thinking_model
         when /\A\/expand/
           expand_id = input.sub('/expand', '').strip.to_i
           full_output = expand_output(expand_id)
@@ -320,6 +351,27 @@ module RailsConsoleAi
         end
       end
 
+      def display_model_info
+        config = RailsConsoleAi.configuration
+        model = @engine.effective_model
+        thinking = config.resolved_thinking_model
+        pricing = Configuration::PRICING[model]
+
+        @real_stdout.puts "\e[36m  Model info:\e[0m"
+        @real_stdout.puts "\e[2m    Provider:        #{config.provider}\e[0m"
+        @real_stdout.puts "\e[2m    Model:           #{model}\e[0m"
+        @real_stdout.puts "\e[2m    Thinking model:  #{thinking}\e[0m"
+        @real_stdout.puts "\e[2m    Max tokens:      #{config.resolved_max_tokens}\e[0m"
+        if pricing
+          @real_stdout.puts "\e[2m    Pricing:         $#{pricing[:input] * 1_000_000}/M in, $#{pricing[:output] * 1_000_000}/M out\e[0m"
+          if pricing[:cache_read]
+            @real_stdout.puts "\e[2m    Cache pricing:   $#{pricing[:cache_read] * 1_000_000}/M read, $#{pricing[:cache_write] * 1_000_000}/M write\e[0m"
+          end
+        end
+        @real_stdout.puts "\e[2m    Bedrock region:  #{config.bedrock_region}\e[0m" if config.provider == :bedrock
+        @real_stdout.puts "\e[2m    Local URL:       #{config.local_url}\e[0m" if config.provider == :local
+      end
+
       def handle_name_command(input)
         name = input.sub('/name', '').strip.gsub(/\A(['"])(.*)\1\z/, '\2')
         if name.empty?
@@ -344,7 +396,9 @@ module RailsConsoleAi
           @real_stdout.puts "\e[2m    /danger      Toggle safe mode (currently #{safe_status})\e[0m"
           @real_stdout.puts "\e[2m    /safe        Show safety guard status\e[0m"
         end
+        @real_stdout.puts "\e[2m    /model       Show provider, model, and pricing info\e[0m"
         @real_stdout.puts "\e[2m    /think       Switch to thinking model\e[0m"
+        @real_stdout.puts "\e[2m    /unthink     Switch back to default model\e[0m"
         @real_stdout.puts "\e[2m    /compact     Summarize conversation to reduce context\e[0m"
         @real_stdout.puts "\e[2m    /usage       Show session token totals\e[0m"
         @real_stdout.puts "\e[2m    /cost        Show cost estimate by model\e[0m"

data/lib/rails_console_ai/console_methods.rb

@@ -130,10 +130,14 @@ module RailsConsoleAi
       nil
     end
 
-    def ai_setup
+    def ai_db_setup
       RailsConsoleAi.setup!
     end
 
+    def ai_db_migrate
+      RailsConsoleAi.migrate!
+    end
+
     def ai_init
       require 'rails_console_ai/context_builder'
       require 'rails_console_ai/providers/base'
@@ -157,7 +161,8 @@ module RailsConsoleAi
         $stderr.puts "\e[33m  ai_sessions  - list recent sessions\e[0m"
         $stderr.puts "\e[33m  ai_resume    - resume a session by name or id\e[0m"
         $stderr.puts "\e[33m  ai_name      - name a session: ai_name 42, \"my_label\"\e[0m"
-        $stderr.puts "\e[33m  ai_setup     - install session logging table\e[0m"
+        $stderr.puts "\e[33m  ai_db_setup  - install session logging table + run migrations\e[0m"
+        $stderr.puts "\e[33m  ai_db_migrate- run pending session table migrations\e[0m"
         $stderr.puts "\e[33m  ai_status    - show current configuration\e[0m"
         $stderr.puts "\e[33m  ai_memories  - show recent memories (ai_memories(n) for last n)\e[0m"
         return nil

data/lib/rails_console_ai/conversation_engine.rb

@@ -4,11 +4,14 @@ module RailsConsoleAi
                 :interactive_session_id, :session_name
 
     RECENT_OUTPUTS_TO_KEEP = 2
+    LARGE_OUTPUT_THRESHOLD = 10_000      # chars — truncate tool results larger than this immediately
+    LARGE_OUTPUT_PREVIEW_CHARS = 8_000   # chars — how much of the output the LLM sees upfront
 
-    def initialize(binding_context:, channel:, slack_thread_ts: nil)
+    def initialize(binding_context:, channel:, slack_thread_ts: nil, slack_channel_name: nil)
       @binding_context = binding_context
       @channel = channel
       @slack_thread_ts = slack_thread_ts
+      @slack_channel_name = slack_channel_name
       @executor = Executor.new(binding_context, channel: channel)
       @provider = nil
       @context_builder = nil
@@ -295,7 +298,6 @@ module RailsConsoleAi
       end
 
       if @executor.last_cancelled?
-        @history << { role: :user, content: "User declined to execute the code." }
         :cancelled
       elsif @executor.last_safety_error
         exec_result = @executor.offer_danger_retry(code)
@@ -318,7 +320,6 @@ module RailsConsoleAi
           end
           :success
         else
-          @history << { role: :user, content: "User declined to execute with safe mode disabled." }
           :cancelled
         end
       elsif @executor.last_error
@@ -417,16 +418,36 @@ module RailsConsoleAi
 
     def upgrade_to_thinking_model
       config = RailsConsoleAi.configuration
-      current = config.resolved_model
+      current = effective_model
       thinking = config.resolved_thinking_model
 
       if current == thinking
         $stdout.puts "\e[36m  Already using thinking model (#{current}).\e[0m"
       else
-        config.model = thinking
+        @model_override = thinking
         @provider = nil
         $stdout.puts "\e[36m  Switched to thinking model: #{thinking}\e[0m"
       end
+      effective_model
+    end
+
+    def downgrade_from_thinking_model
+      config = RailsConsoleAi.configuration
+      default = config.resolved_model
+      current = effective_model
+
+      if current == default && @model_override.nil?
+        $stdout.puts "\e[36m  Already using default model (#{current}).\e[0m"
+      else
+        @model_override = nil
+        @provider = nil
+        $stdout.puts "\e[36m  Switched back to default model: #{default}\e[0m"
+      end
+      effective_model
+    end
+
+    def effective_model
+      @model_override || RailsConsoleAi.configuration.resolved_model
     end
 
     def compact_history
@@ -522,6 +543,8 @@ module RailsConsoleAi
           name:  @session_name
         )
         log_attrs[:slack_thread_ts] = @slack_thread_ts if @slack_thread_ts
+        log_attrs[:slack_channel_name] = @slack_channel_name if @slack_channel_name
+        log_attrs[:model] = effective_model
         if @channel.user_identity
           log_attrs[:user_name] = @channel.mode == 'slack' ? "slack:#{@channel.user_identity}" : @channel.user_identity
         end
@@ -558,6 +581,7 @@ module RailsConsoleAi
           start_time: @interactive_start
         }
         log_attrs[:slack_thread_ts] = @slack_thread_ts if @slack_thread_ts
+        log_attrs[:slack_channel_name] = @slack_channel_name if @slack_channel_name
         if @channel.user_identity
           log_attrs[:user_name] = @channel.mode == 'slack' ? "slack:#{@channel.user_identity}" : @channel.user_identity
         end
@@ -619,7 +643,15 @@ module RailsConsoleAi
     end
 
     def provider
-      @provider ||= Providers.build
+      @provider ||= begin
+        if @model_override
+          config = RailsConsoleAi.configuration.dup
+          config.model = @model_override
+          Providers.build(config)
+        else
+          Providers.build
+        end
+      end
     end
 
     def context_builder
@@ -736,6 +768,10 @@ module RailsConsoleAi
           @channel.display_dim("  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}")
         end
 
+        # Trim old tool outputs between rounds to prevent context explosion.
+        # The LLM can still retrieve omitted outputs via recall_output.
+        messages = trim_old_outputs(messages) if round > 0
+
         if RailsConsoleAi.configuration.debug
           debug_pre_call(round, messages, active_system_prompt, tools, total_input, total_output)
         end
@@ -790,13 +826,25 @@ module RailsConsoleAi
           end
 
           tool_msg = provider.format_tool_result(tc[:id], tool_result)
-          if tool_result.to_s.length > 200
-            tool_msg[:output_id] = @executor.store_output(tool_result.to_s)
+          full_text = tool_result.to_s
+          if full_text.length > LARGE_OUTPUT_THRESHOLD
+            output_id = @executor.store_output(full_text)
+            tool_msg[:output_id] = output_id
+            truncated = full_text[0, LARGE_OUTPUT_PREVIEW_CHARS]
+            truncated += "\n\n[Output truncated at #{LARGE_OUTPUT_PREVIEW_CHARS} of #{full_text.length} chars — use recall_output tool with id #{output_id} to retrieve the full output]"
+            tool_msg = provider.format_tool_result(tc[:id], truncated)
+            tool_msg[:output_id] = output_id
+          elsif full_text.length > 200
+            tool_msg[:output_id] = @executor.store_output(full_text)
           end
           messages << tool_msg
           new_messages << tool_msg
         end
 
+        # If the user declined execution, don't call the LLM again —
+        # just return to the prompt so they can correct their request.
+        break if @executor.last_cancelled?
+
         exhausted = true if round == max_rounds - 1
       end
 
@@ -821,7 +869,7 @@ module RailsConsoleAi
       @total_input_tokens += result.input_tokens || 0
       @total_output_tokens += result.output_tokens || 0
 
-      model = RailsConsoleAi.configuration.resolved_model
+      model = effective_model
       @token_usage[model][:input] += result.input_tokens || 0
       @token_usage[model][:output] += result.output_tokens || 0
       @token_usage[model][:cache_read] = (@token_usage[model][:cache_read] || 0) + (result.cache_read_input_tokens || 0)
@@ -865,7 +913,8 @@ module RailsConsoleAi
         attrs.merge(
           input_tokens: @total_input_tokens,
           output_tokens: @total_output_tokens,
-          duration_ms: duration_ms
+          duration_ms: duration_ms,
+          model: effective_model
         )
       )
     end
@@ -896,6 +945,8 @@ module RailsConsoleAi
       when 'save_memory'     then "(\"#{args['name']}\")"
       when 'delete_memory'   then "(\"#{args['name']}\")"
       when 'recall_memories' then args['query'] ? "(\"#{args['query']}\")" : ''
+      when 'activate_skill' then "(\"#{args['name']}\")"
+      when 'recall_output'   then "(#{args['id']})"
       when 'execute_plan'
         steps = args['steps']
         steps ? "(#{steps.length} steps)" : ''
@@ -1021,7 +1072,7 @@ module RailsConsoleAi
 
       input_t = result.input_tokens || 0
       output_t = result.output_tokens || 0
-      model = RailsConsoleAi.configuration.resolved_model
+      model = effective_model
       pricing = Configuration::PRICING[model]
       pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
 

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
         )
@@ -175,7 +175,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(', ')}"

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.20.0'.freeze
+  VERSION = '0.21.0'.freeze
 end

data/lib/rails_console_ai.rb

@@ -93,10 +93,7 @@ module RailsConsoleAi
       conn = session_connection
       table = 'rails_console_ai_sessions'
 
-      if conn.table_exists?(table)
-        $stdout.puts "\e[32mRailsConsoleAi: #{table} already exists — checking for pending migrations.\e[0m"
-        migrate!
-      else
+      unless conn.table_exists?(table)
         conn.create_table(table) do |t|
           t.text    :query,         null: false
           t.text    :conversation,  null: false
@@ -112,6 +109,8 @@ module RailsConsoleAi
           t.string  :provider,      limit: 50
           t.string  :model,         limit: 100
           t.string  :name,          limit: 255
+          t.string  :slack_thread_ts, limit: 255
+          t.string  :slack_channel_name, limit: 255
           t.integer :duration_ms
           t.datetime :created_at,   null: false
         end
@@ -119,9 +118,12 @@ module RailsConsoleAi
         conn.add_index(table, :created_at)
         conn.add_index(table, :user_name)
         conn.add_index(table, :name)
+        conn.add_index(table, :slack_thread_ts)
 
         $stdout.puts "\e[32mRailsConsoleAi: created #{table} table.\e[0m"
       end
+
+      migrate!
     rescue => e
       $stderr.puts "\e[31mRailsConsoleAi setup failed: #{e.class}: #{e.message}\e[0m"
     end
@@ -149,6 +151,11 @@ module RailsConsoleAi
         migrations << 'slack_thread_ts'
       end
 
+      unless conn.column_exists?(table, :slack_channel_name)
+        conn.add_column(table, :slack_channel_name, :string, limit: 255)
+        migrations << 'slack_channel_name'
+      end
+
       if migrations.empty?
         $stdout.puts "\e[32mRailsConsoleAi: #{table} is up to date.\e[0m"
       else

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Cortfr