console_agent 0.8.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdcfb3c48b2f8421b2187980a453b80324e6dec40ab80e8e55aa1a938355c79c
-  data.tar.gz: 12fec02740fde7a87bb81e26dd6857263c96f9ebe5a8402040c72279e882e31f
+  metadata.gz: dc46d0592feb84b4d85481d1535dccbe417a4445593828424c12a84d96fcbc9c
+  data.tar.gz: 10fe29dc81cc425a498c6e7d6c6b82aaa586ec674c081ba3f7b5b1143b68df18
 SHA512:
-  metadata.gz: 7af9a3c4fdbdf71abb7452d8e6747ba2b22c64cd08d123b761c5ca7ebb870c3ba9a01e458defe0308dcbf9435ec71879f7f3562503defdfd54e2026d3069679d
-  data.tar.gz: c84e401d6b6f5c6c7840b5d701d3a0e653ba3ea46651141ae5101b2c93bdca35487566786a87e284dbba97f902c5dad597a00b8dc9fce6e1c01885b01e99a48d
+  metadata.gz: 86760d6c3b7c4920fc2c01741be308fc3d3f133e264c8dc37cab6b1ab90e9b920a410d57c86d8f96e743396d6919735d7fad62ee584667c8ea177c4825a12d05
+  data.tar.gz: 6446b9b2af4803ccd860fd109484ef37de87850517ad117eb52892974a65a017c1b03188dfc1eb7f24aad3859749ce4f6d282220c8d5d78238e67cfdb7438def

data/CHANGELOG.md

@@ -0,0 +1,73 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.10.0]
+
+- Add `/expand` command to view previous results
+- Exclude previous output from context; add tool for LLM to retrieve it on demand
+- Show summarized info per LLM call in `/debug`
+
+## [0.9.0]
+
+- Add `/system` and `/context` commands to inspect what is being sent
+- Omit huge output from tool results
+- Don't cancel code execution on incorrect prompt answers
+- Preserve code blocks when compacting; require manual `/compact`
+- Fix authentication when neither method was applied
+- Remove prompt to upgrade model on excessive tool calls
+
+## [0.8.0]
+
+- Add authentication function support so host apps can avoid using basic auth
+- Add `/think` and `/cost` commands with Sonnet vs Opus support
+- Gracefully handle token limit exceeded errors
+
+## [0.7.0]
+
+- Include binding variables and their classes in the Rails console context
+- Add `ai_setup` command
+- Add `/compact` mechanism for conversation management
+- Catch errors and attempt to auto-fix them
+
+## [0.6.0]
+
+- Add core memory (`console_agent.md`) that persists across sessions in the system prompt
+- Add `ai_init` command to seed core memory
+- Allow reading partial files
+- Fix rspec hanging issues
+
+## [0.5.0]
+
+- Auto-accept single-step plans
+- Support `>` shorthand to run code directly
+- Add `script/release` for releases
+
+## [0.4.0]
+
+- Fix resuming sessions repeatedly
+- Fix terminal flashing/loading in production (kubectl)
+- Better escaping during thinking output
+
+## [0.3.0]
+
+- Add plan mechanism with "auto" execution mode
+- Add session logging to DB with `/console_agent` admin UI
+- List and resume past sessions with pagination
+- Add shift-tab for auto-execute mode
+- Add usage display and debug toggle
+- Store sessions incrementally; improved code segment display
+
+## [0.2.0]
+
+- Add memory system with individual file storage
+- Add `ask_user` tool
+- Add registry cache
+- Fix REPL up-key and ctrl-a navigation
+- Show tool usage and model processing info
+- Add token count information and debug ability
+- Use tools-based approach instead of sending everything at once
+
+## [0.1.0]
+
+- Initial implementation

data/README.md

@@ -79,7 +79,10 @@ end
 | `/usage` | Show token stats |
 | `/cost` | Show per-model cost breakdown |
 | `/think` | Upgrade to thinking model (Opus) for the rest of the session |
-| `/debug` | Toggle raw API output |
+| `/debug` | Toggle debug summaries (context stats, cost per call) |
+| `/expand <id>` | Show full omitted output |
+| `/context` | Show conversation history as sent to the LLM |
+| `/system` | Show the system prompt |
 | `/name <label>` | Name the session for easy resume |
 
 Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
@@ -96,6 +99,8 @@ Say "think harder" in any query to auto-upgrade to the thinking model for that s
 - **App guide** — `ai_init` generates a guide injected into every system prompt
 - **Sessions** — name, list, and resume interactive conversations (`ai_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
 
 ## Configuration
 

data/app/controllers/console_agent/application_controller.rb

@@ -13,7 +13,10 @@ module ConsoleAgent
         username = ConsoleAgent.configuration.admin_username
         password = ConsoleAgent.configuration.admin_password
 
-        return unless username && password
+        unless username && password
+          head :unauthorized
+          return
+        end
 
         authenticate_or_request_with_http_basic('ConsoleAgent Admin') do |u, p|
           ActiveSupport::SecurityUtils.secure_compare(u, username) &

data/lib/console_agent/executor.rb

@@ -48,6 +48,10 @@ module ConsoleAgent
 
     def initialize(binding_context)
       @binding_context = binding_context
+      @omitted_outputs = {}
+      @omitted_counter = 0
+      @output_store = {}
+      @output_counter = 0
     end
 
     def extract_code(response)
@@ -84,7 +88,7 @@ module ConsoleAgent
       result = binding_context.eval(code, "(console_agent)", 1)
 
       $stdout = old_stdout
-      $stdout.puts colorize("=> #{result.inspect}", :green)
+      display_result(result)
 
       @last_output = captured_output.string
       result
@@ -107,6 +111,20 @@ module ConsoleAgent
       @last_output
     end
 
+    def expand_output(id)
+      @omitted_outputs[id]
+    end
+
+    def store_output(content)
+      @output_counter += 1
+      @output_store[@output_counter] = content
+      @output_counter
+    end
+
+    def recall_output(id)
+      @output_store[id]
+    end
+
     def last_answer
       @last_answer
     end
@@ -126,35 +144,72 @@ module ConsoleAgent
       @last_answer = answer
       echo_stdin(answer)
 
-      case answer
-      when 'y', 'yes'
-        execute(code)
-      when 'e', 'edit'
-        edited = open_in_editor(code)
-        if edited && edited != code
-          $stdout.puts colorize("# Edited code:", :yellow)
-          $stdout.puts highlight_code(edited)
-          $stdout.print colorize("Execute edited code? [y/N] ", :yellow)
-          edit_answer = $stdin.gets.to_s.strip.downcase
-          echo_stdin(edit_answer)
-          if edit_answer == 'y'
-            execute(edited)
+      loop do
+        case answer
+        when 'y', 'yes', 'a'
+          return execute(code)
+        when 'e', 'edit'
+          edited = open_in_editor(code)
+          if edited && edited != code
+            $stdout.puts colorize("# Edited code:", :yellow)
+            $stdout.puts highlight_code(edited)
+            $stdout.print colorize("Execute edited code? [y/N] ", :yellow)
+            edit_answer = $stdin.gets.to_s.strip.downcase
+            echo_stdin(edit_answer)
+            if edit_answer == 'y'
+              return execute(edited)
+            else
+              $stdout.puts colorize("Cancelled.", :yellow)
+              return nil
+            end
           else
-            $stdout.puts colorize("Cancelled.", :yellow)
-            nil
+            return execute(code)
           end
+        when 'n', 'no', ''
+          $stdout.puts colorize("Cancelled.", :yellow)
+          @last_cancelled = true
+          return nil
         else
-          execute(code)
+          $stdout.print colorize("Execute? [y/N/edit] ", :yellow)
+          @on_prompt&.call
+          answer = $stdin.gets.to_s.strip.downcase
+          @last_answer = answer
+          echo_stdin(answer)
         end
-      else
-        $stdout.puts colorize("Cancelled.", :yellow)
-        @last_cancelled = true
-        nil
       end
     end
 
     private
 
+    MAX_DISPLAY_LINES = 10
+    MAX_DISPLAY_CHARS = 2000
+
+    def display_result(result)
+      full = "=> #{result.inspect}"
+      lines = full.lines
+      total_lines = lines.length
+      total_chars = full.length
+
+      if total_lines <= MAX_DISPLAY_LINES && total_chars <= MAX_DISPLAY_CHARS
+        $stdout.puts colorize(full, :green)
+      else
+        # Truncate by lines first, then by chars
+        truncated = lines.first(MAX_DISPLAY_LINES).join
+        truncated = truncated[0, MAX_DISPLAY_CHARS] if truncated.length > MAX_DISPLAY_CHARS
+        $stdout.puts colorize(truncated, :green)
+
+        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] = full
+        $stdout.puts colorize("  (omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
+      end
+    end
+
     # Write stdin input to the capture IO only (avoids double-echo on terminal)
     def echo_stdin(text)
       $stdout.secondary.write("#{text}\n") if $stdout.respond_to?(:secondary)

data/lib/console_agent/providers/base.rb

@@ -41,24 +41,27 @@ module ConsoleAgent
       def debug_request(url, body)
         return unless config.debug
 
-        $stderr.puts "\e[33m--- ConsoleAgent DEBUG: REQUEST ---\e[0m"
-        $stderr.puts "\e[33mURL: #{url}\e[0m"
-        parsed = body.is_a?(String) ? JSON.parse(body) : body
-        $stderr.puts "\e[33m#{JSON.pretty_generate(parsed)}\e[0m"
-        $stderr.puts "\e[33m--- END REQUEST ---\e[0m"
-      rescue => e
-        $stderr.puts "\e[33m[debug] #{body}\e[0m"
+        parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+        if parsed
+          # Support both symbol and string keys
+          model = parsed[:model] || parsed['model']
+          msgs = parsed[:messages] || parsed['messages']
+          sys = parsed[:system] || parsed['system']
+          tools = parsed[:tools] || parsed['tools']
+          $stderr.puts "\e[33m[debug] POST #{url} | model: #{model} | #{msgs&.length || 0} msgs | system: #{sys.to_s.length} chars | #{tools&.length || 0} tools\e[0m"
+        else
+          $stderr.puts "\e[33m[debug] POST #{url}\e[0m"
+        end
       end
 
       def debug_response(body)
         return unless config.debug
 
-        $stderr.puts "\e[36m--- ConsoleAgent DEBUG: RESPONSE ---\e[0m"
-        parsed = body.is_a?(String) ? JSON.parse(body) : body
-        $stderr.puts "\e[36m#{JSON.pretty_generate(parsed)}\e[0m"
-        $stderr.puts "\e[36m--- END RESPONSE ---\e[0m"
-      rescue => e
-        $stderr.puts "\e[36m[debug] #{body}\e[0m"
+        parsed = body.is_a?(String) ? (JSON.parse(body) rescue nil) : body
+        if parsed && parsed['usage']
+          u = parsed['usage']
+          $stderr.puts "\e[36m[debug] response: #{parsed['stop_reason']} | in: #{u['input_tokens']} out: #{u['output_tokens']}\e[0m"
+        end
       end
 
       def parse_response(response)

data/lib/console_agent/repl.rb

@@ -241,6 +241,11 @@ module ConsoleAgent
         break if input.downcase == 'exit' || input.downcase == 'quit'
         next if input.empty?
 
+        if input == '?' || input == '/'
+          display_help
+          next
+        end
+
         if input == '/auto'
           ConsoleAgent.configuration.auto_execute = !ConsoleAgent.configuration.auto_execute
           mode = ConsoleAgent.configuration.auto_execute ? 'ON' : 'OFF'
@@ -265,11 +270,32 @@ module ConsoleAgent
           next
         end
 
+        if input == '/system'
+          @interactive_old_stdout.puts "\e[2m#{context}\e[0m"
+          next
+        end
+
+        if input == '/context'
+          display_conversation
+          next
+        end
+
         if input == '/cost'
           display_cost_summary
           next
         end
 
+        if input.start_with?('/expand')
+          expand_id = input.sub('/expand', '').strip.to_i
+          full_output = @executor.expand_output(expand_id)
+          if full_output
+            @interactive_old_stdout.puts full_output
+          else
+            @interactive_old_stdout.puts "\e[33mNo omitted output with id #{expand_id}\e[0m"
+          end
+          next
+        end
+
         if input == '/think'
           upgrade_to_thinking_model
           next
@@ -311,7 +337,8 @@ module ConsoleAgent
 
           context_msg = "User directly executed code: `#{raw_code}`"
           context_msg += "\n#{result_str}" unless output_parts.empty?
-          @history << { role: :user, content: context_msg }
+          output_id = output_parts.empty? ? nil : @executor.store_output(result_str)
+          @history << { role: :user, content: context_msg, output_id: output_id }
 
           @interactive_query ||= input
           @last_interactive_code = raw_code
@@ -384,18 +411,11 @@ module ConsoleAgent
         result, tool_messages = send_query(nil, conversation: @history)
       rescue Providers::ProviderError => e
         if e.message.include?("prompt is too long") && @history.length >= 6
-          $stdout.puts "\e[33m  Context limit reached. Auto-compacting history...\e[0m"
-          compact_history
-          begin
-            result, tool_messages = send_query(nil, conversation: @history)
-          rescue Providers::ProviderError => e2
-            $stderr.puts "\e[31m  Still too large after compaction: #{e2.message}\e[0m"
-            return :error
-          end
+          $stdout.puts "\e[33m  Context limit reached. Run /compact to reduce context size, then try again.\e[0m"
         else
           $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
-          return :error
         end
+        return :error
       rescue Interrupt
         $stdout.puts "\n\e[33m  Aborted.\e[0m"
         return :interrupted
@@ -451,7 +471,8 @@ module ConsoleAgent
         unless output_parts.empty?
           result_str = output_parts.join("\n\n")
           result_str = result_str[0..1000] + '...' if result_str.length > 1000
-          @history << { role: :user, content: "Code was executed. #{result_str}" }
+          output_id = @executor.store_output(result_str)
+          @history << { role: :user, content: "Code was executed. #{result_str}", output_id: output_id }
         end
 
         :success
@@ -539,6 +560,10 @@ module ConsoleAgent
       prompt.strip
     end
 
+    # Number of most recent execution outputs to keep in full in the conversation.
+    # Older outputs are replaced with a short reference the LLM can recall via tool.
+    RECENT_OUTPUTS_TO_KEEP = 2
+
     def send_query(query, conversation: nil)
       ConsoleAgent.configuration.validate!
 
@@ -548,6 +573,8 @@ module ConsoleAgent
                    [{ role: :user, content: query }]
                  end
 
+      messages = trim_old_outputs(messages) if conversation
+
       send_query_with_tools(messages)
     end
 
@@ -564,18 +591,8 @@ module ConsoleAgent
       last_tool_names = []
 
       exhausted = false
-      thinking_suggested = false
 
       max_rounds.times do |round|
-        if round == 5 && !thinking_suggested && !on_thinking_model?
-          thinking_suggested = true
-          thinking_name = ConsoleAgent.configuration.resolved_thinking_model
-          $stdout.puts "\e[33m  This query is using many tool rounds. Switch to thinking model (#{thinking_name})? [y/N]\e[0m"
-          answer = Readline.readline("  ", false).to_s.strip.downcase
-          if answer == 'y'
-            upgrade_to_thinking_model
-          end
-        end
         if round == 0
           $stdout.puts "\e[2m  Thinking...\e[0m"
         else
@@ -588,26 +605,24 @@ module ConsoleAgent
           $stdout.puts "\e[2m  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}\e[0m"
         end
 
+        if ConsoleAgent.configuration.debug
+          debug_pre_call(round, messages, active_system_prompt, tools, total_input, total_output)
+        end
+
         begin
           result = with_escape_monitoring do
             provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
           end
         rescue Providers::ProviderError => e
-          if e.message.include?("prompt is too long") && messages.length >= 6
-            $stdout.puts "\e[33m  Context limit hit mid-session. Compacting messages...\e[0m"
-            messages = compact_messages(messages)
-            unless @_retried_compact
-              @_retried_compact = true
-              retry
-            end
-          end
           raise
-        ensure
-          @_retried_compact = nil
         end
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
 
+        if ConsoleAgent.configuration.debug
+          debug_post_call(round, result, @total_input_tokens + total_input, @total_output_tokens + total_output)
+        end
+
         break unless result.tool_use?
 
         # Buffer thinking text for display before next LLM call
@@ -636,10 +651,14 @@ module ConsoleAgent
           end
 
           if ConsoleAgent.configuration.debug
-            $stderr.puts "\e[35m[debug tool result] #{tool_result}\e[0m"
+            $stderr.puts "\e[35m[debug] tool result (#{tool_result.to_s.length} chars)\e[0m"
           end
 
           tool_msg = provider.format_tool_result(tc[:id], tool_result)
+          # Store large tool results so they can be trimmed from older conversation turns
+          if tool_result.to_s.length > 200
+            tool_msg[:output_id] = @executor.store_output(tool_result.to_s)
+          end
           messages << tool_msg
           new_messages << tool_msg
         end
@@ -724,6 +743,89 @@ module ConsoleAgent
       status
     end
 
+    def debug_pre_call(round, messages, system_prompt, tools, total_input, total_output)
+      d = "\e[35m"
+      r = "\e[0m"
+
+      # Count message types
+      user_msgs = 0
+      assistant_msgs = 0
+      tool_result_msgs = 0
+      tool_use_msgs = 0
+      output_msgs = 0
+      omitted_msgs = 0
+      total_content_chars = system_prompt.to_s.length
+
+      messages.each do |msg|
+        content_str = msg[:content].is_a?(Array) ? msg[:content].to_s : msg[:content].to_s
+        total_content_chars += content_str.length
+
+        role = msg[:role].to_s
+        if role == 'tool'
+          tool_result_msgs += 1
+        elsif msg[:content].is_a?(Array)
+          # Anthropic format — check for tool_result or tool_use blocks
+          msg[:content].each do |block|
+            next unless block.is_a?(Hash)
+            if block['type'] == 'tool_result'
+              tool_result_msgs += 1
+              omitted_msgs += 1 if block['content'].to_s.include?('Output omitted')
+            elsif block['type'] == 'tool_use'
+              tool_use_msgs += 1
+            end
+          end
+        elsif role == 'user'
+          user_msgs += 1
+          if content_str.include?('Code was executed') || content_str.include?('directly executed code')
+            output_msgs += 1
+            omitted_msgs += 1 if content_str.include?('Output omitted')
+          end
+        elsif role == 'assistant'
+          assistant_msgs += 1
+        end
+      end
+
+      tool_count = tools.respond_to?(:definitions) ? tools.definitions.length : 0
+
+      $stderr.puts "#{d}[debug] ── LLM call ##{round + 1} ──#{r}"
+      $stderr.puts "#{d}[debug]   system prompt: #{format_tokens(system_prompt.to_s.length)} chars#{r}"
+      $stderr.puts "#{d}[debug]   messages: #{messages.length} (#{user_msgs} user, #{assistant_msgs} assistant, #{tool_result_msgs} tool results, #{tool_use_msgs} tool calls)#{r}"
+      $stderr.puts "#{d}[debug]   execution outputs: #{output_msgs} (#{omitted_msgs} omitted)#{r}" if output_msgs > 0 || omitted_msgs > 0
+      $stderr.puts "#{d}[debug]   tools provided: #{tool_count}#{r}"
+      $stderr.puts "#{d}[debug]   est. content size: #{format_tokens(total_content_chars)} chars#{r}"
+      if total_input > 0 || total_output > 0
+        $stderr.puts "#{d}[debug]   tokens so far: in: #{format_tokens(total_input)} | out: #{format_tokens(total_output)}#{r}"
+      end
+    end
+
+    def debug_post_call(round, result, total_input, total_output)
+      d = "\e[35m"
+      r = "\e[0m"
+
+      input_t = result.input_tokens || 0
+      output_t = result.output_tokens || 0
+      model = ConsoleAgent.configuration.resolved_model
+      pricing = Configuration::PRICING[model]
+
+      parts = ["in: #{format_tokens(input_t)}", "out: #{format_tokens(output_t)}"]
+
+      if pricing
+        cost = (input_t * pricing[:input]) + (output_t * pricing[:output])
+        session_cost = (total_input * pricing[:input]) + (total_output * pricing[:output])
+        parts << "~$#{'%.4f' % cost}"
+        $stderr.puts "#{d}[debug]   ← response: #{parts.join(' | ')}  (session: ~$#{'%.4f' % session_cost})#{r}"
+      else
+        $stderr.puts "#{d}[debug]   ← response: #{parts.join(' | ')}#{r}"
+      end
+
+      if result.tool_use?
+        tool_names = result.tool_calls.map { |tc| tc[:name] }
+        $stderr.puts "#{d}[debug]   tool calls: #{tool_names.join(', ')}#{r}"
+      else
+        $stderr.puts "#{d}[debug]   stop reason: #{result.stop_reason}#{r}"
+      end
+    end
+
     def format_tokens(count)
       if count >= 1_000_000
         "#{(count / 1_000_000.0).round(1)}M"
@@ -987,13 +1089,58 @@ module ConsoleAgent
       config.resolved_model == config.resolved_thinking_model
     end
 
+    # Replace older execution outputs with short references.
+    # Keeps the last RECENT_OUTPUTS_TO_KEEP outputs in full.
+    def trim_old_outputs(messages)
+      # Find indices of messages with output_id (execution outputs and tool results)
+      output_indices = messages.each_with_index
+                               .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
+
+      # Indices to trim (all except the most recent N)
+      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)
+        end
+      end
+    end
+
+    # Replace the content of a message with a short reference to the stored output.
+    # Handles both regular messages and tool result messages (Anthropic/OpenAI formats).
+    def trim_message(msg)
+      ref = "[Output omitted — use recall_output tool with id #{msg[:output_id]} to retrieve]"
+
+      if msg[:content].is_a?(Array)
+        # Anthropic tool_result format: [{ 'type' => 'tool_result', 'tool_use_id' => '...', 'content' => '...' }]
+        trimmed_content = msg[:content].map do |block|
+          if block.is_a?(Hash) && block['type'] == 'tool_result'
+            block.merge('content' => ref)
+          else
+            block
+          end
+        end
+        { role: msg[:role], content: trimmed_content }
+      elsif msg[:role].to_s == 'tool'
+        # OpenAI tool result format
+        msg.except(:output_id).merge(content: ref)
+      else
+        # Regular user message (code execution result)
+        first_line = msg[:content].to_s.lines.first&.strip || msg[:content]
+        { role: msg[:role], content: "#{first_line}\n#{ref}" }
+      end
+    end
+
     def warn_if_history_large
       chars = @history.sum { |m| m[:content].to_s.length }
 
-      if chars > 120_000 && @history.length >= 6
-        $stdout.puts "\e[33m  Context growing large (~#{format_tokens(chars)} chars). Auto-compacting...\e[0m"
-        compact_history
-      elsif chars > 50_000 && !@compact_warned
+      if chars > 50_000 && !@compact_warned
         @compact_warned = true
         $stdout.puts "\e[33m  Conversation is getting large (~#{format_tokens(chars)} chars). Consider running /compact to reduce context size.\e[0m"
       end
@@ -1008,6 +1155,9 @@ module ConsoleAgent
       before_chars = @history.sum { |m| m[:content].to_s.length }
       before_count = @history.length
 
+      # Extract successfully executed code before summarizing
+      executed_code = extract_executed_code(@history)
+
       $stdout.puts "\e[2m  Compacting #{before_count} messages (~#{format_tokens(before_chars)} chars)...\e[0m"
 
       system_prompt = <<~PROMPT
@@ -1018,8 +1168,8 @@ module ConsoleAgent
         - Key findings and data discovered (include specific values, IDs, record counts)
         - Current state: what worked, what failed, where things stand
         - Important variable names, model names, or table names referenced
-        - Any code that was executed and its results
 
+        Do NOT include code that was executed — that will be preserved separately.
         Be concise but preserve all information that would be needed to continue the conversation naturally.
         Do NOT include any preamble — just output the summary directly.
       PROMPT
@@ -1037,32 +1187,130 @@ module ConsoleAgent
           return
         end
 
-        @history = [{ role: :user, content: "CONVERSATION SUMMARY (compacted):\n#{summary}" }]
+        content = "CONVERSATION SUMMARY (compacted):\n#{summary}"
+        unless executed_code.empty?
+          content += "\n\nCODE EXECUTED THIS SESSION (preserved for continuation):\n#{executed_code}"
+        end
+
+        @history = [{ role: :user, content: content }]
         @compact_warned = false
 
         after_chars = @history.first[:content].length
         $stdout.puts "\e[36m  Compacted: #{before_count} messages -> 1 summary (~#{format_tokens(before_chars)} -> ~#{format_tokens(after_chars)} chars)\e[0m"
         summary.each_line { |line| $stdout.puts "\e[2m  #{line.rstrip}\e[0m" }
+        if !executed_code.empty?
+          $stdout.puts "\e[2m  (preserved #{executed_code.scan(/```ruby/).length} executed code block(s))\e[0m"
+        end
         display_usage(result)
       rescue => e
         $stdout.puts "\e[31m  Compaction failed: #{e.message}\e[0m"
       end
     end
 
-    def compact_messages(messages)
-      return messages if messages.length < 6
+    # Extracts code blocks that were successfully executed from conversation history.
+    # Looks for:
+    # 1. Assistant messages with ```ruby blocks followed by "Code was executed." user messages
+    # 2. execute_plan tool calls followed by results without ERROR
+    # Skips code that failed or was declined.
+    def extract_executed_code(history)
+      code_blocks = []
+      history.each_cons(2) do |msg, next_msg|
+        # Pattern 1: Assistant ```ruby blocks with successful execution
+        if msg[:role].to_s == 'assistant' && next_msg[:role].to_s == 'user'
+          content = msg[:content].to_s
+          next_content = next_msg[:content].to_s
+
+          if next_content.start_with?('Code was executed.')
+            content.scan(/```ruby\s*\n(.*?)```/m).each do |match|
+              code = match[0].strip
+              next if code.empty?
+              result_summary = next_content[0..200].gsub("\n", "\n# ")
+              code_blocks << "```ruby\n#{code}\n```\n# #{result_summary}"
+            end
+          end
+        end
+
+        # Pattern 2: execute_plan tool calls in provider-formatted messages
+        if msg[:role].to_s == 'assistant' && msg[:content].is_a?(Array)
+          msg[:content].each do |block|
+            next unless block.is_a?(Hash) && block['type'] == 'tool_use' && block['name'] == 'execute_plan'
+            input = block['input'] || {}
+            steps = input['steps'] || []
+
+            # Find the matching tool_result in subsequent messages
+            tool_id = block['id']
+            result_msg = find_tool_result(history, tool_id)
+            next unless result_msg
+
+            result_text = result_msg.to_s
+            # Extract only steps that succeeded (no ERROR in their result)
+            steps.each_with_index do |step, i|
+              step_num = i + 1
+              # Check if this specific step had an error
+              step_section = result_text[/Step #{step_num}\b.*?(?=Step #{step_num + 1}\b|\z)/m] || ''
+              next if step_section.include?('ERROR:')
+              next if step_section.include?('User declined')
+
+              code = step['code'].to_s.strip
+              next if code.empty?
+              desc = step['description'] || "Step #{step_num}"
+              code_blocks << "```ruby\n# #{desc}\n#{code}\n```"
+            end
+          end
+        end
+      end
+      code_blocks.join("\n\n")
+    end
 
-      to_summarize = messages[0...-4]
-      to_keep = messages[-4..]
+    def find_tool_result(history, tool_id)
+      history.each do |msg|
+        next unless msg[:content].is_a?(Array)
+        msg[:content].each do |block|
+          next unless block.is_a?(Hash)
+          if block['type'] == 'tool_result' && block['tool_use_id'] == tool_id
+            return block['content']
+          end
+          # OpenAI format
+          if msg[:role].to_s == 'tool' && msg[:tool_call_id] == tool_id
+            return msg[:content]
+          end
+        end
+      end
+      nil
+    end
 
-      history_text = to_summarize.map { |m| "#{m[:role]}: #{m[:content].to_s[0..500]}" }.join("\n\n")
+    def display_conversation
+      if @history.empty?
+        @interactive_old_stdout.puts "\e[2m  (no conversation history yet)\e[0m"
+        return
+      end
 
-      summary_result = provider.chat(
-        [{ role: :user, content: "Summarize this conversation context concisely, preserving key facts, IDs, and findings:\n\n#{history_text}" }],
-        system_prompt: "You are a conversation summarizer. Be concise but preserve all actionable information."
-      )
+      trimmed = trim_old_outputs(@history)
+      @interactive_old_stdout.puts "\e[36m  Conversation (#{trimmed.length} messages, as sent to LLM):\e[0m"
+      trimmed.each_with_index do |msg, i|
+        role = msg[:role].to_s
+        content = msg[:content].to_s
+        label = role == 'user' ? "\e[33m[user]\e[0m" : "\e[36m[assistant]\e[0m"
+        @interactive_old_stdout.puts "#{label} #{content}"
+        @interactive_old_stdout.puts if i < trimmed.length - 1
+      end
+    end
 
-      [{ role: :user, content: "CONTEXT SUMMARY:\n#{summary_result.text}" }] + to_keep
+    def display_help
+      auto = ConsoleAgent.configuration.auto_execute ? 'ON' : 'OFF'
+      @interactive_old_stdout.puts "\e[36m  Commands:\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /auto        Toggle auto-execute (currently #{auto}) (Shift-Tab)\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /think       Switch to thinking model\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /compact     Summarize conversation to reduce context\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /usage       Show session token totals\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /cost        Show cost estimate by model\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /name <lbl>  Name this session for easy resume\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /context     Show conversation history sent to the LLM\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /system      Show the system prompt\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /expand <id> Show full omitted output\e[0m"
+      @interactive_old_stdout.puts "\e[2m    /debug       Toggle debug summaries (context stats, cost per call)\e[0m"
+      @interactive_old_stdout.puts "\e[2m    > code       Execute Ruby directly (skip LLM)\e[0m"
+      @interactive_old_stdout.puts "\e[2m    exit/quit    Leave interactive mode\e[0m"
     end
 
     def display_exit_info

data/lib/console_agent/tools/registry.rb

@@ -170,6 +170,24 @@ module ConsoleAgent
           handler: ->(args) { code.search_code(args['query'], args['directory']) }
         )
 
+        if @executor
+          register(
+            name: 'recall_output',
+            description: 'Retrieve a previous code execution output that was omitted from the conversation to save context. Use the output id shown in the "[Output omitted]" placeholder.',
+            parameters: {
+              'type' => 'object',
+              'properties' => {
+                'id' => { 'type' => 'integer', 'description' => 'The output id to retrieve' }
+              },
+              'required' => ['id']
+            },
+            handler: ->(args) {
+              result = @executor.recall_output(args['id'].to_i)
+              result || "No output found with id #{args['id']}"
+            }
+          )
+        end
+
         unless @mode == :init
           register(
             name: 'ask_user',

data/lib/console_agent/version.rb

@@ -1,3 +1,3 @@
 module ConsoleAgent
-  VERSION = '0.8.0'.freeze
+  VERSION = '0.10.0'.freeze
 end

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

@@ -35,7 +35,7 @@ ConsoleAgent.configure do |config|
   # config.connection_class = Sharding::CentralizedModel
 
   # Admin UI credentials (mount ConsoleAgent::Engine => '/console_agent' in routes.rb)
-  # When nil, no authentication is required (convenient for development)
+  # When nil, all requests are denied. Set credentials or use config.authenticate.
   # config.admin_username = 'admin'
   # config.admin_password = 'changeme'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: console_agent
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Cortfr
@@ -86,6 +86,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE
 - README.md
 - app/controllers/console_agent/application_controller.rb