rails_console_ai 0.23.0 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f97d0243924a105c21ebd4a86049bef4fdda6ed76d738c1c2850244f8cb6e0e
-  data.tar.gz: 930e70d14ae27b0d87999b4625f299390bc928646e73417aef2fc5f7f46aaf5f
+  metadata.gz: 89e0f9e402a40af4755fe61d2029f10a90c487c1d957e007032dcdd1f54a1c82
+  data.tar.gz: 7e68825010aed2bd0f7a07cdcd68a39d54edec2616913ab14c9a10aa972e6d4f
 SHA512:
-  metadata.gz: 17d56e01106acbeee8e1299c39e2fbcc3c0f3150922b977652f8857139d8ad7c481c13d080216f492833e22287df616eb4967a6d46162d39b618ac51e74bbeb4
-  data.tar.gz: 259216bdd4cf23d0b6c8634fad2d48d520eac0b4600d16697cdf176e55a3677a5a7975304697be2f36817bf04aaa0f7317459a7e9d79da591cfe49879398cca3
+  metadata.gz: f0efcfa92b22f8cd4df14a643904aba9c0e3c05ac7873de6a303f72fd6cdd4df5c457cf1fdcafb120a02784c7247663e48141500f69214ac5bbfafa945ec9ce0
+  data.tar.gz: 2aed178645529500d0b1d72772e19307d4b42de2a0db586f928a46df2a6503d78f3693cde4222006ad0e4227ea840b4bd510a6ef5631e9395466cf9035db679a

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.25.0]
+
+- Expand truncation limits
+- Allow any user on allow list to interact with Slack bot in a thread
+- Handle ctrl-c better in console
+- Fix stdout capture in Slack sessions
+- Improve Slack bot logging
+- Fix thread safety issues in Slack bot
+
+## [0.24.0]
+
+- Refactor thinking text display and include in Slack with more technical detail
+- Add `a` command to trigger auto-accept mode
+- Include code output in Slack server logs
+- Fix Bedrock issue after declining code execution
+- Fix `allow_code_execution` configuration
+
 ## [0.23.0]
 
 - Add `save_skill` tool

data/lib/generators/rails_console_ai/templates/initializer.rb

@@ -86,7 +86,7 @@ RailsConsoleAi.configure do |config|
   # config.channels = {
   #   'slack' => {
   #     'allowed_usernames' => ['alice', 'bob'],                          # who can use the bot (or 'ALL')
-  #     'allow_code_execution' => ['alice'],                              # who can run code (nil = everyone)
+  #     'allow_code_execution' => ['alice'],                              # who can run code directly via ``` (nil = everyone)
   #     'pinned_memory_tags' => ['sharding'],
   #     'bypass_guards_for_methods' => ['ChangeApproval#approve_by!']
   #   },

data/lib/rails_console_ai/channel/base.rb

@@ -2,7 +2,8 @@ module RailsConsoleAi
   module Channel
     class Base
       def display(text);            raise NotImplementedError; end
-      def display_dim(text);        raise NotImplementedError; end
+      def display_thinking(text);    raise NotImplementedError; end
+      def display_status(text);      raise NotImplementedError; end
       def display_warning(text);    raise NotImplementedError; end
       def display_error(text);      raise NotImplementedError; end
       def display_code(code);       raise NotImplementedError; end

data/lib/rails_console_ai/channel/console.rb

@@ -14,7 +14,11 @@ module RailsConsoleAi
         $stdout.puts colorize(text, :cyan)
       end
 
-      def display_dim(text)
+      def display_thinking(text)
+        $stdout.puts "\e[2m#{text}\e[0m"
+      end
+
+      def display_status(text)
         $stdout.puts "\e[2m#{text}\e[0m"
       end
 
@@ -123,8 +127,8 @@ module RailsConsoleAi
 
       # --- Omitted output tracking (shared with Executor) ---
 
-      MAX_DISPLAY_LINES = 10
-      MAX_DISPLAY_CHARS = 2000
+      MAX_DISPLAY_LINES = 20
+      MAX_DISPLAY_CHARS = 4000
 
       def init_omitted_tracking
         @omitted_outputs = {}
@@ -226,7 +230,16 @@ module RailsConsoleAi
           @interactive_console_capture.write("ai> #{input}\n")
           @engine.log_interactive_turn
 
-          status = @engine.send_and_execute
+          expected_stdout = $stdout
+          begin
+            status = @engine.send_and_execute
+          rescue Interrupt
+            $stdout = expected_stdout
+            $stdout.puts "\n\e[33m  Cancelled.\e[0m"
+            @engine.pop_last_message
+            @engine.log_interactive_turn
+            next
+          end
           if status == :interrupted
             @engine.pop_last_message
             @engine.log_interactive_turn
@@ -409,6 +422,7 @@ module RailsConsoleAi
         @real_stdout.puts "\e[2m    /debug       Toggle debug summaries (context stats, cost per call)\e[0m"
         @real_stdout.puts "\e[2m    /retry       Re-execute the last code block\e[0m"
         @real_stdout.puts "\e[2m    > code       Execute Ruby directly (skip LLM)\e[0m"
+        @real_stdout.puts "\e[2m    Ctrl-C       Cancel the current operation\e[0m"
         @real_stdout.puts "\e[2m    exit/quit    Leave interactive mode\e[0m"
       end
 

data/lib/rails_console_ai/channel/slack.rb

@@ -28,23 +28,21 @@ module RailsConsoleAi
         post(strip_ansi(text))
       end
 
-      def display_dim(text)
-        raw = strip_ansi(text)
-        stripped = raw.strip
+      def display_thinking(text)
+        stripped = strip_ansi(text).strip
+        return if stripped.empty?
+        post(stripped)
+      end
+
+      def display_status(text)
+        stripped = strip_ansi(text).strip
+        return if stripped.empty?
 
         if stripped =~ /\AThinking\.\.\.|\AAttempting to fix|\ACancelled|\A_session:/
           post(stripped)
-        elsif stripped =~ /\ACalling LLM/
-          # Technical LLM round status — suppress in Slack
-          @output_log.write("#{stripped}\n")
-          STDOUT.puts "#{@log_prefix} (dim) #{stripped}"
-        elsif raw =~ /\A {2,4}\S/ && stripped.length > 10
-          # LLM thinking text (2-space indent from conversation engine) — show as status
-          post(stripped)
         else
-          # Tool result previews (5+ space indent) and other technical noise — log only
           @output_log.write("#{stripped}\n")
-          STDOUT.puts "#{@log_prefix} (dim) #{stripped}"
+          log_prefixed("(status)", stripped)
         end
       end
 
@@ -58,7 +56,7 @@ module RailsConsoleAi
 
       def display_tool_call(text)
         @output_log.write("-> #{text}\n")
-        STDOUT.puts "#{@log_prefix} -> #{text}"
+        log_prefixed("->", text)
       end
 
       def display_code(code)
@@ -112,9 +110,9 @@ module RailsConsoleAi
 
       def system_instructions
         <<~INSTRUCTIONS.strip
-          ## Response Formatting (Slack Channel)
+          ## Slack Channel
 
-          You are responding to non-technical users in Slack. Follow these rules:
+          You are responding in a Slack thread.
 
           ## Code Execution
           - ALWAYS use the `execute_code` tool to run Ruby code. Do NOT put code in markdown
@@ -132,11 +130,8 @@ module RailsConsoleAi
             123  John Smith        john@example.com
             456  Jane Doe          jane@example.com
             ```
-          - Use `puts` with formatted output instead of returning arrays or hashes
-          - Summarize findings in plain, simple language
-          - Do NOT show technical details like SQL queries, token counts, or class names
-          - Keep explanations simple and jargon-free
-          - Never return raw Ruby objects — always present data in a human-readable way
+          - Use `puts` with formatted output instead of returning arrays or hashes.
+          - Never return raw Ruby objects — always present data in a human-readable way.
           - The output of `puts` in your code is automatically shown to the user. Do NOT
             repeat or re-display data that your code already printed via `puts`.
             Just add a brief summary after (e.g. "10 events found" or "Let me know if you need more detail").
@@ -166,7 +161,7 @@ module RailsConsoleAi
       def post(text)
         return if text.nil? || text.strip.empty?
         @output_log.write("#{text}\n")
-        STDOUT.puts "#{@log_prefix} >> #{text}"
+        log_prefixed(">>", text)
         @slack_bot.send(:post_message,
           channel: @channel_id,
           thread_ts: @thread_ts,
@@ -176,6 +171,10 @@ module RailsConsoleAi
         RailsConsoleAi.logger.error("Slack post failed: #{e.message}")
       end
 
+      def log_prefixed(tag, text)
+        text.each_line { |line| STDOUT.puts "#{@log_prefix} #{tag} #{line.rstrip}" }
+      end
+
       def strip_ansi(text)
         text.to_s.gsub(ANSI_REGEX, '')
       end

data/lib/rails_console_ai/configuration.rb

@@ -135,7 +135,7 @@ module RailsConsoleAi
       end
 
       if allow
-        Array(allow).each { |key| safety_guards.allow(guard_name, key) }
+        Array(allow).each { |key| safety_guards.allow_global(guard_name, key) }
       end
     end
 

data/lib/rails_console_ai/context_builder.rb

@@ -97,7 +97,8 @@ module RailsConsoleAi
         - Give ONE concise answer. Do not offer multiple alternatives or variations.
         - For multi-step tasks, use execute_plan to break the work into small, clear steps.
         - For simple queries, use the execute_code tool.
-        - Include a brief one-line explanation before or after executing code.
+        - Before calling tools, briefly state what you're about to do (e.g., "Let me check the
+          user's migration status." or "I'll look up the table structure."). Keep it to one sentence.
         - Use the app's actual model names, associations, and schema.
         - Prefer ActiveRecord query interface over raw SQL.
         - For destructive operations, add a comment warning.

data/lib/rails_console_ai/conversation_engine.rb

@@ -3,8 +3,8 @@ module RailsConsoleAi
     attr_reader :history, :total_input_tokens, :total_output_tokens,
                 :interactive_session_id, :session_name
 
-    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
+    LARGE_OUTPUT_THRESHOLD = 20_000      # chars — truncate tool results larger than this immediately
+    LARGE_OUTPUT_PREVIEW_CHARS = 16_000  # chars — how much of the output the LLM sees upfront
     LOOP_WARN_THRESHOLD = 3              # same tool+args repeated → inject warning
     LOOP_BREAK_THRESHOLD = 5             # same tool+args repeated → break loop
 
@@ -49,7 +49,7 @@ module RailsConsoleAi
           conversation << { role: :assistant, content: @_last_result_text }
           conversation << { role: :user, content: error_msg }
 
-          @channel.display_dim("  Ran into an issue, trying a different approach...")
+          @channel.display_status("  Ran into an issue, trying a different approach...")
           exec_result, code, executed = one_shot_round(conversation)
         end
 
@@ -114,7 +114,7 @@ module RailsConsoleAi
 
       status = send_and_execute
       if status == :error
-        @channel.display_dim("  Ran into an issue, trying a different approach...")
+        @channel.display_status("  Ran into an issue, trying a different approach...")
         send_and_execute
       end
     end
@@ -232,7 +232,7 @@ module RailsConsoleAi
         @channel.display_warning("No code to retry.")
         return
       end
-      @channel.display_dim("  Retrying last code...")
+      @channel.display_status("  Retrying last code...")
       execute_direct(code)
     end
 
@@ -790,19 +790,19 @@ module RailsConsoleAi
 
       max_rounds.times do |round|
         if @channel.cancelled?
-          @channel.display_dim("  Cancelled.")
+          @channel.display_status("  Cancelled.")
           break
         end
 
         if round == 0
-          @channel.display_dim("  Thinking...")
+          @channel.display_status("  Thinking...")
         else
           if last_thinking
             last_thinking.split("\n").each do |line|
-              @channel.display_dim("  #{line}")
+              @channel.display_thinking("  #{line}")
             end
           end
-          @channel.display_dim("  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}")
+          @channel.display_status("  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}")
         end
 
         # Trim large tool outputs between rounds to prevent context explosion.
@@ -856,7 +856,7 @@ module RailsConsoleAi
                           else
                             "No matching outputs found with id(s) #{ids.join(', ')}."
                           end
-            @channel.display_dim("     #{tool_result}")
+            @channel.display_status("     #{tool_result}")
             tool_msg = provider.format_tool_result(tc[:id], tool_result)
             messages << tool_msg
             new_messages << tool_msg
@@ -865,7 +865,7 @@ module RailsConsoleAi
 
           # Display any pending LLM text before executing the tool
           if last_thinking
-            last_thinking.split("\n").each { |line| @channel.display_dim("  #{line}") }
+            last_thinking.split("\n").each { |line| @channel.display_thinking("  #{line}") }
             last_thinking = nil
           end
 
@@ -879,7 +879,7 @@ module RailsConsoleAi
 
             preview = compact_tool_result(tc[:name], tool_result)
             cached_tag = tools.last_cached? ? " (cached)" : ""
-            @channel.display_dim("     #{preview}#{cached_tag}")
+            @channel.display_status("     #{preview}#{cached_tag}")
           end
 
           if RailsConsoleAi.configuration.debug
@@ -908,10 +908,10 @@ module RailsConsoleAi
           tool_call_counts[key] += 1
 
           if tool_call_counts[key] >= LOOP_BREAK_THRESHOLD
-            @channel.display_dim("  Loop detected: #{tc[:name]} called #{tool_call_counts[key]} times with same args — stopping.")
+            @channel.display_status("  Loop detected: #{tc[:name]} called #{tool_call_counts[key]} times with same args — stopping.")
             exhausted = true
           elsif tool_call_counts[key] >= LOOP_WARN_THRESHOLD
-            @channel.display_dim("  Warning: #{tc[:name]} called #{tool_call_counts[key]} times with same args — consider a different approach.")
+            @channel.display_status("  Warning: #{tc[:name]} called #{tool_call_counts[key]} times with same args — consider a different approach.")
             messages << { role: :user, content: "You are repeating the same tool call (#{tc[:name]}) with the same arguments. This is not making progress. Try a different approach or provide your answer now." }
           end
         end
@@ -1095,6 +1095,12 @@ module RailsConsoleAi
         else
           truncate(result, 80)
         end
+      when 'execute_code'
+        lines = result.split("\n").reject { |l| l.strip.empty? }
+        output_lines = lines.select { |l| !l.start_with?('Output:') && !l.start_with?('Return value:') }
+        summary = output_lines.first(2).map { |l| l.strip }.join('; ')
+        summary = truncate(summary, 70) if summary.length > 70
+        "#{output_lines.length} lines: #{summary}"
       when 'execute_plan'
         steps_done = result.scan(/^Step \d+/).length
         steps_done > 0 ? "#{steps_done} steps executed" : truncate(result, 80)

data/lib/rails_console_ai/executor.rb

@@ -100,13 +100,18 @@ module RailsConsoleAi
       @last_safety_exception = nil
       captured_output = StringIO.new
       old_stdout = $stdout
-      # 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
+      # Three capture strategies:
+      # 1. Slack mode (PrefixedIO active): thread-local capture to avoid cross-thread pollution
+      # 2. Console mode (channel present): capture-only, channel.display_result_output shows it after
+      # 3. No channel (tests/one-shot): TeeIO so output appears live AND is captured
+      use_thread_local = defined?(RailsConsoleAi::PrefixedIO) && $stdout.is_a?(RailsConsoleAi::PrefixedIO)
+      if use_thread_local
+        Thread.current[:capture_io] = captured_output
+      elsif @channel
+        $stdout = captured_output
+      else
+        $stdout = TeeIO.new(old_stdout, captured_output)
+      end
 
       RailsConsoleAi::SafetyError.clear!
 
@@ -114,7 +119,7 @@ module RailsConsoleAi
         binding_context.eval(code, "(rails_console_ai)", 1)
       end
 
-      $stdout = old_stdout
+      restore_stdout(use_thread_local, old_stdout)
 
       # Check if a SafetyError was raised but swallowed by a rescue inside the eval'd code
       if (swallowed = RailsConsoleAi::SafetyError.last_raised)
@@ -136,8 +141,12 @@ module RailsConsoleAi
 
       @last_output = captured_output.string
       result
+    rescue Interrupt
+      restore_stdout(use_thread_local, old_stdout)
+      @last_output = captured_output&.string
+      raise
     rescue RailsConsoleAi::SafetyError => e
-      $stdout = old_stdout if old_stdout
+      restore_stdout(use_thread_local, old_stdout)
       RailsConsoleAi::SafetyError.clear!
       @last_error = "SafetyError: #{e.message}"
       @last_safety_error = true
@@ -146,13 +155,13 @@ module RailsConsoleAi
       @last_output = captured_output&.string
       nil
     rescue SyntaxError => e
-      $stdout = old_stdout if old_stdout
+      restore_stdout(use_thread_local, old_stdout)
       @last_error = "SyntaxError: #{e.message}"
       log_execution_error(@last_error)
       @last_output = nil
       nil
     rescue => e
-      $stdout = old_stdout if old_stdout
+      restore_stdout(use_thread_local, old_stdout)
       # Check if a SafetyError is wrapped (e.g. ActiveRecord::StatementInvalid wrapping our error)
       if safety_error?(e)
         safety_exc = extract_safety_exception(e)
@@ -216,7 +225,20 @@ module RailsConsoleAi
 
       loop do
         case answer
-        when 'y', 'yes', 'a'
+        when 'a', 'auto'
+          RailsConsoleAi.configuration.auto_execute = true
+          if @channel
+            @channel.display_status("Auto-execute: ON")
+          else
+            $stdout.puts colorize("Auto-execute: ON", :cyan)
+          end
+          result = execute(code)
+          if @last_safety_error
+            return nil unless danger_allowed?
+            return offer_danger_retry(code)
+          end
+          return result
+        when 'y', 'yes'
           result = execute(code)
           if @last_safety_error
             return nil unless danger_allowed?
@@ -320,6 +342,14 @@ module RailsConsoleAi
 
     private
 
+    def restore_stdout(use_thread_local, old_stdout)
+      if use_thread_local
+        Thread.current[:capture_io] = nil
+      else
+        $stdout = old_stdout if old_stdout
+      end
+    end
+
     def danger_allowed?
       @channel.nil? || @channel.supports_danger?
     end
@@ -355,9 +385,9 @@ module RailsConsoleAi
     def execute_prompt
       guards = RailsConsoleAi.configuration.safety_guards
       if !guards.empty? && guards.enabled? && danger_allowed?
-        "Execute? [y/N/danger] "
+        "Execute? [y/N/a/danger] "
       else
-        "Execute? [y/N] "
+        "Execute? [y/N/a] "
       end
     end
 

data/lib/rails_console_ai/prefixed_io.rb

@@ -5,6 +5,9 @@ module RailsConsoleAi
     end
 
     def write(str)
+      if (capture = Thread.current[:capture_io])
+        return capture.write(str)
+      end
       prefix = Thread.current[:log_prefix]
       if prefix && str.is_a?(String) && !str.strip.empty?
         prefixed = str.gsub(/^(?=.)/, "#{prefix} ")
@@ -15,6 +18,9 @@ module RailsConsoleAi
     end
 
     def puts(*args)
+      if (capture = Thread.current[:capture_io])
+        return capture.puts(*args)
+      end
       prefix = Thread.current[:log_prefix]
       if prefix
         args = [""] if args.empty?
@@ -32,6 +38,9 @@ module RailsConsoleAi
     end
 
     def print(*args)
+      if (capture = Thread.current[:capture_io])
+        return capture.print(*args)
+      end
       @io.print(*args)
     end
 

data/lib/rails_console_ai/providers/bedrock.rb

@@ -121,10 +121,10 @@ 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? }
+          # Bedrock rejects empty or whitespace-only 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.strip.empty? }
           # Bedrock also rejects messages with completely empty content arrays
-          content << { text: ' ' } if content.empty?
+          content << { text: '.' } if content.empty?
           { role: msg[:role].to_s, content: content }
         end
 

data/lib/rails_console_ai/safety_guards.rb

@@ -41,15 +41,15 @@ module RailsConsoleAi
     end
 
     def enabled?
-      @enabled
+      @enabled && !Thread.current[:rails_console_ai_guards_disabled]
     end
 
     def enable!
-      @enabled = true
+      Thread.current[:rails_console_ai_guards_disabled] = nil
     end
 
     def disable!
-      @enabled = false
+      Thread.current[:rails_console_ai_guards_disabled] = true
     end
 
     def empty?
@@ -60,33 +60,52 @@ module RailsConsoleAi
       @guards.keys
     end
 
-    def allow(guard_name, key)
+    # Add a permanent (config-time) allowlist entry visible to all threads.
+    def allow_global(guard_name, key)
       guard_name = guard_name.to_sym
       @allowlist[guard_name] ||= []
       @allowlist[guard_name] << key unless @allowlist[guard_name].include?(key)
     end
 
-    def allowed?(guard_name, key)
-      entries = @allowlist[guard_name.to_sym]
-      return false unless entries
+    # Add a thread-local allowlist entry (runtime "allow for this session").
+    def allow(guard_name, key)
+      thread_list = Thread.current[:rails_console_ai_allowlist] ||= {}
+      guard_name = guard_name.to_sym
+      thread_list[guard_name] ||= []
+      thread_list[guard_name] << key unless thread_list[guard_name].include?(key)
+    end
 
-      entries.any? do |entry|
-        case entry
-        when Regexp then key.match?(entry)
-        else entry.to_s == key.to_s
+    def allowed?(guard_name, key)
+      guard_name = guard_name.to_sym
+      match = ->(entries) {
+        entries&.any? do |entry|
+          case entry
+          when Regexp then key.match?(entry)
+          else entry.to_s == key.to_s
+          end
         end
-      end
+      }
+      # Check global (config-time) allowlist
+      return true if match.call(@allowlist[guard_name])
+      # Check thread-local (runtime session) allowlist
+      thread_list = Thread.current[:rails_console_ai_allowlist]
+      return true if thread_list && match.call(thread_list[guard_name])
+      false
     end
 
     def allowlist
-      @allowlist
+      thread_list = Thread.current[:rails_console_ai_allowlist]
+      return @allowlist unless thread_list
+      merged = @allowlist.dup
+      thread_list.each { |k, v| merged[k] = (merged[k] || []) + v }
+      merged
     end
 
     # Compose all guards around a block of code.
     # Each guard is an around-block: guard.call { inner }
     # Result: guard_1 { guard_2 { guard_3 { yield } } }
     def wrap(channel_mode: nil, additional_bypass_methods: nil, &block)
-      return yield unless @enabled && !@guards.empty?
+      return yield unless enabled? && !@guards.empty?
 
       install_skills_once!
       bypass_set = resolve_bypass_methods(channel_mode)

data/lib/rails_console_ai/slack_bot.rb

@@ -281,6 +281,19 @@ module RailsConsoleAi
       slack_api("chat.postMessage", channel: channel, thread_ts: thread_ts, text: text)
     end
 
+    # Cancel any in-progress thread on this session before spawning a new one.
+    # Prevents concurrent engine access when users send messages faster than
+    # the LLM can respond.
+    def replace_session_thread(session, &block)
+      old_thread = session[:thread]
+      if old_thread&.alive?
+        session[:channel].cancel!
+        old_thread.join(5) # wait up to 5s for graceful shutdown
+        session[:channel].instance_variable_set(:@cancelled, false)
+      end
+      session[:thread] = Thread.new(&block)
+    end
+
     # --- Event handling ---
 
     def handle_event(msg)
@@ -314,17 +327,14 @@ module RailsConsoleAi
 
         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)
-            unless RailsConsoleAi.configuration.username_allowed?('slack', 'allowed_usernames', chk_name)
-              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
+          # Any allowed user can interact with an existing session
+          chk_name = resolve_user_name(user_id)
+          unless RailsConsoleAi.configuration.username_allowed?('slack', 'allowed_usernames', chk_name)
+            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.")
             return
           end
-          # Owner must @mention unless bot asked a question (waiting_for_reply?)
+          # 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])
@@ -443,10 +453,10 @@ module RailsConsoleAi
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name}"
         begin
-          channel.display_dim("_session: #{channel_id}/#{thread_ts}_")
+          channel.display_status("_session: #{channel_id}/#{thread_ts}_")
           if restored
             puts "Restored session for thread #{thread_ts} (#{engine.history.length} messages)"
-            channel.display_dim("_(session restored — continuing from previous conversation)_")
+            channel.display_status("_(session restored — continuing from previous conversation)_")
           end
           engine.process_message(text)
         rescue => e
@@ -482,7 +492,7 @@ module RailsConsoleAi
       end
 
       # Otherwise treat as a new message in the conversation
-      session[:thread] = Thread.new do
+      replace_session_thread(session) do
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = channel.instance_variable_get(:@log_prefix)
         begin
@@ -514,7 +524,7 @@ module RailsConsoleAi
       channel = session[:channel]
       engine = session[:engine]
 
-      session[:thread] = Thread.new do
+      replace_session_thread(session) do
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = channel.instance_variable_get(:@log_prefix)
         begin
@@ -614,7 +624,7 @@ module RailsConsoleAi
         summary = bang_cost(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
       when 'compact'
-        session[:thread] = Thread.new do
+        replace_session_thread(session) do
           Thread.current.report_on_exception = false
           begin
             before = engine.history.length
@@ -646,7 +656,7 @@ module RailsConsoleAi
         summary = bang_context(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
       when 'retry'
-        session[:thread] = Thread.new do
+        replace_session_thread(session) do
           Thread.current.report_on_exception = false
           Thread.current[:log_prefix] = session[:channel].instance_variable_get(:@log_prefix)
           begin

data/lib/rails_console_ai/tools/registry.rb

@@ -368,13 +368,6 @@ module RailsConsoleAi
       def register_execute_plan
         return unless @executor
 
-        # Check per-channel code execution permission
-        if @channel
-          unless RailsConsoleAi.configuration.username_allowed?(@channel.mode, 'allow_code_execution', @channel.user_identity)
-            return
-          end
-        end
-
         register(
           name: 'execute_code',
           description: 'Execute Ruby code in the Rails console and return the result. Use this for all code execution — simple queries, data lookups, reports, etc. The output of puts/print statements is automatically shown to the user. The return value is sent back to you so you can summarize the findings.',
@@ -419,12 +412,8 @@ module RailsConsoleAi
         # Show the code to the user
         @executor.display_code_block(code)
 
-        # Slack: execute directly, suppress display (output goes back to LLM as tool result).
-        # Console: show code and confirm before executing, display output directly.
-        exec_result = if @channel&.mode == 'slack'
-                        @executor.execute(code, display: false)
-                      elsif RailsConsoleAi.configuration.auto_execute
-                        @executor.execute(code, display: false)
+        exec_result = if @channel&.mode == 'slack' || RailsConsoleAi.configuration.auto_execute
+                        @executor.execute(code)
                       else
                         @executor.confirm_and_execute(code)
                       end

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.23.0'.freeze
+  VERSION = '0.25.0'.freeze
 end

metadata

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