rails_console_ai 0.20.0 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee0daa4b9926c6df19c9e2946f019b5d17dd3bd64d4e8998e92d86ed16dff8e1
-  data.tar.gz: f336fe3abf34a513a5de12b138d69f4941e3cd65eeecaa8b548658d3da8b846e
+  metadata.gz: dba28b6d7543df66792877bddc51336f105c441a06b089de34ab0c7f89ca8f26
+  data.tar.gz: 4a54272fafd704abd003f06f2ab065d11f47b7c9a42b2f7c99c55b07b8712f8a
 SHA512:
-  metadata.gz: 35d266cac783a3e43a6712380085215b7ba7503874b4f7a97ce6fac30875bded29e658d52dc4d1196bcb2e907e555255538ec6563e190212ea0bbcc6c02179d4
-  data.tar.gz: 64e365d8d18a9a559bf9c8ec5b982f7ecff03d1faed9d731bc3734b6493cdeb7cab3055de5ae56da3e5d5112ccfb7b6ecf47b652a7a570c8fdb8401e0eddcf40
+  metadata.gz: 27c8413cc63c84c94d0fad464c3f3d6cd0b376a744122a2358b5899e0382f82e696a3e188647db952235986ee2a973c85b73065939a898cd7229955a61c377cf
+  data.tar.gz: d7e3041e7e37dd2ed304537bdfb02693647d3d32a9f1b6888718d9e38fcafe0c1b92000606c970716cd5074e7424b81e37d894d099b93ac6155268703ad54738

data/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.22.0]
+
+- Fix blank content block handling in Bedrock provider
+- Fix `recall_output` to expand in place and restore preview after LLM responds, preventing context bloat
+- Remove safety guard bypass from prompt
+- Fix issue where LLM couldn't recall multiple outputs at once
+
+## [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/context_builder.rb

@@ -82,9 +82,6 @@ module RailsConsoleAi
           (e.g. `api = SalesforceApi.new(step1)`).
         - If the user asks you to provide code for them to run later (not execute now), put it
           in a ```ruby code block in your text response.
-        - Use `RailsConsoleAi.configuration.safety_guards.without_guards { }` to wrap any
-          operation that should bypass safety guards (e.g. calling a known-safe admin method).
-
         You have skills — predefined procedures for specific operations. When a user's request
         matches a skill, call activate_skill first to load the recipe and enable its guard
         bypasses, then follow the recipe.

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
@@ -239,11 +242,16 @@ module RailsConsoleAi
       output_parts << "Return value: #{exec_result.inspect}" if exec_result
 
       result_str = output_parts.join("\n\n")
-      result_str = result_str[0..1000] + '...' if result_str.length > 1000
 
       context_msg = "User directly executed code: `#{raw_code}`"
-      context_msg += "\n#{result_str}" unless output_parts.empty?
-      output_id = output_parts.empty? ? nil : @executor.store_output(result_str)
+      if result_str.length > LARGE_OUTPUT_THRESHOLD
+        output_id = @executor.store_output(result_str)
+        preview = result_str[0, LARGE_OUTPUT_PREVIEW_CHARS]
+        context_msg += "\n#{preview}\n\n[Output truncated at #{LARGE_OUTPUT_PREVIEW_CHARS} of #{result_str.length} chars — use recall_output tool with id #{output_id} to retrieve the full output]"
+      elsif !output_parts.empty?
+        output_id = @executor.store_output(result_str)
+        context_msg += "\n#{result_str}"
+      end
       @history << { role: :user, content: context_msg, output_id: output_id }
 
       @interactive_query ||= "> #{raw_code}"
@@ -295,7 +303,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)
@@ -312,13 +319,18 @@ module RailsConsoleAi
           output_parts << "Return value: #{exec_result.inspect}" if exec_result
           unless output_parts.empty?
             result_str = output_parts.join("\n\n")
-            result_str = result_str[0..1000] + '...' if result_str.length > 1000
             output_id = @executor.store_output(result_str)
-            @history << { role: :user, content: "Code was executed (safety override). #{result_str}", output_id: output_id }
+            context_msg = "Code was executed (safety override). "
+            if result_str.length > LARGE_OUTPUT_THRESHOLD
+              context_msg += result_str[0, LARGE_OUTPUT_PREVIEW_CHARS]
+              context_msg += "\n\n[Output truncated at #{LARGE_OUTPUT_PREVIEW_CHARS} of #{result_str.length} chars — use recall_output tool with id #{output_id} to retrieve the full output]"
+            else
+              context_msg += result_str
+            end
+            @history << { role: :user, content: context_msg, output_id: output_id }
           end
           :success
         else
-          @history << { role: :user, content: "User declined to execute with safe mode disabled." }
           :cancelled
         end
       elsif @executor.last_error
@@ -335,9 +347,15 @@ module RailsConsoleAi
 
         unless output_parts.empty?
           result_str = output_parts.join("\n\n")
-          result_str = result_str[0..1000] + '...' if result_str.length > 1000
           output_id = @executor.store_output(result_str)
-          @history << { role: :user, content: "Code was executed. #{result_str}", output_id: output_id }
+          context_msg = "Code was executed. "
+          if result_str.length > LARGE_OUTPUT_THRESHOLD
+            context_msg += result_str[0, LARGE_OUTPUT_PREVIEW_CHARS]
+            context_msg += "\n\n[Output truncated at #{LARGE_OUTPUT_PREVIEW_CHARS} of #{result_str.length} chars — use recall_output tool with id #{output_id} to retrieve the full output]"
+          else
+            context_msg += result_str
+          end
+          @history << { role: :user, content: context_msg, output_id: output_id }
         end
 
         :success
@@ -417,16 +435,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 +560,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 +598,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
@@ -591,6 +632,8 @@ module RailsConsoleAi
 
           This session has safety guards that block side effects (database writes, HTTP mutations, etc.).
           If an operation is blocked, the user will be prompted to allow it or disable guards.
+          Do NOT attempt to bypass or work around safety guards in your code — just write the
+          operation normally and let the safety system handle it.
         PROMPT
       end
     end
@@ -619,7 +662,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 +787,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
@@ -767,6 +822,28 @@ module RailsConsoleAi
         last_tool_names = result.tool_calls.map { |tc| tc[:name] }
         result.tool_calls.each do |tc|
           break if @channel.cancelled?
+
+          # Intercept recall_output/recall_outputs: expand in place instead of adding large messages
+          if tc[:name] == 'recall_output' || tc[:name] == 'recall_outputs'
+            ids = if tc[:name] == 'recall_outputs'
+                    Array(tc[:arguments]['ids']).map(&:to_i)
+                  else
+                    [tc[:arguments]['id'].to_i]
+                  end
+            @channel.display_tool_call("#{tc[:name]}(#{ids.join(', ')})")
+            expanded = expand_outputs_in_place(messages, ids)
+            tool_result = if expanded.any?
+                            "Expanded #{expanded.length} output(s) in conversation. The full content is now visible in the original message(s) above."
+                          else
+                            "No matching outputs found with id(s) #{ids.join(', ')}."
+                          end
+            @channel.display_dim("     #{tool_result}")
+            tool_msg = provider.format_tool_result(tc[:id], tool_result)
+            messages << tool_msg
+            new_messages << tool_msg
+            next
+          end
+
           if tc[:name] == 'ask_user' || tc[:name] == 'execute_plan'
             # Display any pending LLM text before prompting the user
             if last_thinking
@@ -790,16 +867,32 @@ 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
 
+      # Re-truncate any outputs that were expanded for the LLM — the LLM has
+      # seen them and responded, so collapse back to save context on future calls.
+      re_truncate_expanded(messages)
+
       if exhausted
         $stdout.puts "\e[33m  Hit tool round limit (#{max_rounds}). Forcing final answer. Increase with: RailsConsoleAi.configure { |c| c.max_tool_rounds = 200 }\e[0m"
         messages << { role: :user, content: "You've used all available tool rounds. Please provide your best answer now based on what you've learned so far." }
@@ -821,7 +914,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 +958,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 +990,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 +1117,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
 
@@ -1059,16 +1155,14 @@ module RailsConsoleAi
                                .select { |m, _| m[:output_id] }
                                .map { |_, i| i }
 
-      if output_indices.length <= RECENT_OUTPUTS_TO_KEEP
-        return messages.map { |m| m.except(:output_id) }
-      end
+      return messages if output_indices.length <= RECENT_OUTPUTS_TO_KEEP
 
       trim_indices = output_indices[0..-(RECENT_OUTPUTS_TO_KEEP + 1)]
       messages.each_with_index.map do |msg, i|
         if trim_indices.include?(i)
           trim_message(msg)
         else
-          msg.except(:output_id)
+          msg
         end
       end
     end
@@ -1084,12 +1178,52 @@ module RailsConsoleAi
             block
           end
         end
-        { role: msg[:role], content: trimmed_content }
+        msg.merge(content: trimmed_content)
       elsif msg[:role].to_s == 'tool'
-        msg.except(:output_id).merge(content: ref)
+        msg.merge(content: ref)
       else
         first_line = msg[:content].to_s.lines.first&.strip || msg[:content]
-        { role: msg[:role], content: "#{first_line}\n#{ref}" }
+        msg.merge(content: "#{first_line}\n#{ref}")
+      end
+    end
+
+    def expand_outputs_in_place(messages, ids)
+      expanded = []
+      messages.each do |msg|
+        next unless msg[:output_id] && ids.include?(msg[:output_id])
+        full_output = @executor.recall_output(msg[:output_id])
+        next unless full_output
+        # Save original content so re_truncate_expanded can restore it
+        msg[:pre_expand_content] = msg[:content]
+        # Replace content with full output (handle Anthropic, OpenAI, and user message formats)
+        if msg[:content].is_a?(Array)
+          msg[:content] = msg[:content].map do |block|
+            if block.is_a?(Hash) && block['type'] == 'tool_result'
+              block.merge('content' => full_output)
+            else
+              block
+            end
+          end
+        elsif msg[:role].to_s == 'tool'
+          msg[:content] = full_output
+        else
+          # User messages (e.g., direct execution) — preserve first line, replace rest
+          first_line = msg[:content].to_s.lines.first&.chomp || ''
+          msg[:content] = "#{first_line}\n#{full_output}"
+        end
+        msg[:expanded] = true
+        expanded << msg[:output_id]
+      end
+      expanded
+    end
+
+    # Restore messages that were temporarily expanded back to their original
+    # (preview/truncated) content. Called after the LLM has seen the expanded
+    # content and responded.
+    def re_truncate_expanded(messages)
+      messages.each do |msg|
+        next unless msg.delete(:expanded)
+        msg[:content] = msg.delete(:pre_expand_content)
       end
     end