console_agent 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1d37fc84ac3f2d29832d282e6db1fd394308de2b967843c3a0c9748560a7025
-  data.tar.gz: 28bd6c25529dbedfa12d2353a1648304517bab933f0a4f25e91285ccaaf08e10
+  metadata.gz: fdcfb3c48b2f8421b2187980a453b80324e6dec40ab80e8e55aa1a938355c79c
+  data.tar.gz: 12fec02740fde7a87bb81e26dd6857263c96f9ebe5a8402040c72279e882e31f
 SHA512:
-  metadata.gz: 6451c8b62eba1159e0233be04dabbc86bcb3b6f1dcbd6cd658c8d5517a27f1ad6a20884d30d87fabcbe75d8a51d12a6dfa2d4a59ed0adb648ce56d3b81765636
-  data.tar.gz: 3448b25930e4613a4599698d98ec1c5a2d84b113a3221d98239dc0f09351455be817882b308910bfd8bf01eab00d01670c11256624bb7cd7a30745538095c2ea
+  metadata.gz: 7af9a3c4fdbdf71abb7452d8e6747ba2b22c64cd08d123b761c5ca7ebb870c3ba9a01e458defe0308dcbf9435ec71879f7f3562503defdfd54e2026d3069679d
+  data.tar.gz: c84e401d6b6f5c6c7840b5d701d3a0e653ba3ea46651141ae5101b2c93bdca35487566786a87e284dbba97f902c5dad597a00b8dc9fce6e1c01885b01e99a48d

data/README.md

@@ -1,40 +1,6 @@
 # ConsoleAgent
 
-Claude Code, embedded in your Rails console.
-
-Ask questions in plain English. The AI explores your schema, models, and source code on its own, then writes and runs the Ruby code for you.
-
-## Install
-
-```ruby
-# Gemfile
-gem 'console_agent', group: :development
-```
-
-```bash
-bundle install
-rails generate console_agent:install
-```
-
-Set your API key in the generated initializer or as an env var (`ANTHROPIC_API_KEY`):
-
-```ruby
-# config/initializers/console_agent.rb
-ConsoleAgent.configure do |config|
-  config.api_key = 'sk-ant-...'
-end
-```
-
-To set up session logging (OPTIONAL), create the table from the console:
-
-```ruby
-ConsoleAgent.setup!
-# => ConsoleAgent: created console_agent_sessions table.
-```
-
-To reset the table (e.g. after upgrading), run `ConsoleAgent.teardown!` then `ConsoleAgent.setup!`.
-
-## Usage
+Claude Code for your Rails Console.
 
 ```
 irb> ai "find the 5 most recent orders over $100"
@@ -50,29 +16,10 @@ Execute? [y/N/edit] y
 => [#<Order id: 4821, ...>, ...]
 ```
 
-The AI calls tools behind the scenes to learn your app — schema, models, associations, source code — so it writes accurate queries without you providing any context.
-
-### Commands
-
-| Command | What it does |
-|---------|-------------|
-| `ai "query"` | One-shot: ask, review code, confirm |
-| `ai! "query"` | Interactive: ask and keep chatting |
-| `ai? "query"` | Explain only, never executes |
-| `ai_init` | Generate/update app guide for better context |
-
-### Multi-Step Plans
-
-For complex tasks, the AI builds a plan and executes it step by step:
+For complex tasks it builds multi-step plans, executing each step sequentially:
 
 ```
 ai> get the most recent salesforce token and count events via the API
-  Thinking...
-  -> describe_table("oauth2_tokens")
-     28 columns
-  -> read_file("lib/salesforce_api.rb")
-     202 lines
-
   Plan (2 steps):
   1. Find the most recent active Salesforce OAuth2 token
      token = Oauth2Token.where(provider: "salesforce", active: true)
@@ -82,179 +29,121 @@ ai> get the most recent salesforce token and count events via the API
      api.query("SELECT COUNT(Id) FROM Event")
 
   Accept plan? [y/N/a(uto)] a
-  Step 1/2: Find the most recent active Salesforce OAuth2 token
-  ...
-=> #<Oauth2Token id: 1, provider: "salesforce", ...>
-
-  Step 2/2: Query event count via SOQL
-  ...
-=> [{"expr0"=>42}]
 ```
 
-Each step's return value is available to later steps as `step1`, `step2`, etc.
+No context needed from you — it figures out your app on its own.
 
-Plan prompt options:
-- **y** — accept, then confirm each step one at a time
-- **a** — accept and auto-run all steps (stays in manual mode for future queries)
-- **N** — decline; you're asked what to change and the AI revises
-
-### Memories
-
-The AI remembers what it learns about your codebase across sessions:
+## Install
 
+```ruby
+# Gemfile
+gem 'console_agent', group: :development
 ```
-ai> how does sharding work?
-  -> read_file("config/initializers/sharding.rb")
-  -> save_memory("Sharding architecture")
-     Memory saved
 
-  This app uses database-per-shard. User.count returns the current shard only.
+```bash
+bundle install
+rails generate console_agent:install
 ```
 
-Next time, it already knows — no re-reading files, fewer tokens.
+Set your API key in the generated initializer or via env var (`ANTHROPIC_API_KEY`):
 
-### Application Guide
-
-Run `ai_init` to have the AI explore your app and generate a guide that gets loaded into every future conversation:
-
-```
-irb> ai_init
-  No existing guide. Exploring the app...
-  Thinking...
-  -> list_models
-     240 models
-  -> describe_model("User")
-     119 associations, 6 validations
-  -> describe_model("Account")
-     25 associations
-  -> search_code("Sharding", dir: "config")
-     Found 36 matches
-  ...
-  Guide saved to .console_agent/console_agent.md (3204 chars)
+```ruby
+# config/initializers/console_agent.rb
+ConsoleAgent.configure do |config|
+  config.api_key = 'sk-ant-...'
+end
 ```
 
-The guide is a markdown file covering your app's models, relationships, data architecture, and gotchas. Unlike memories (which require a tool call to recall), the guide is injected directly into the system prompt — so the AI starts every session already knowing your app.
+## Commands
 
-Run `ai_init` again anytime to update it.
+| Command | What it does |
+|---------|-------------|
+| `ai "query"` | Ask, review generated code, confirm execution |
+| `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_sessions` | List recent sessions |
+| `ai_resume` | Resume a session by name or ID |
+| `ai_memories` | Show stored memories |
+| `ai_status` | Show current configuration |
 
 ### Interactive Mode
 
-```
-irb> ai!
-ConsoleAgent interactive mode. Type 'exit' to leave.
-  Auto-execute: OFF (Shift-Tab or /auto to toggle) | > code to run directly | /usage | /name <label>
-
-ai> show me all tables
-  ...
-ai> count orders by status
-  ...
-ai> /auto
-  Auto-execute: ON
-ai> delete cancelled orders older than 90 days
-  ...
-ai> exit
-```
-
-Toggle `/auto` to skip confirmation prompts. `/debug` shows raw API traffic. `/usage` shows token stats.
-
-### Direct Code Execution
+`ai!` starts a conversation. Slash commands available inside:
 
-Prefix any input with `>` to run Ruby code directly — no LLM round-trip. The result is added to the conversation context, so the AI knows what happened:
-
-```
-ai> >User.count
-=> 8
-ai> how many users do I have?
-  Thinking...
-
-You have **8 users** in your database, as confirmed by the `User.count` you just ran.
-```
-
-Useful for quick checks, setting up variables, or giving the AI concrete data to work with.
-
-### Sessions
-
-Sessions are saved automatically when session logging is enabled. You can name, list, and resume them.
-
-```
-ai> /name sf_user_123_calendar
-  Session named: sf_user_123_calendar
-ai> exit
-Session #42 saved.
-  Resume with: ai_resume "sf_user_123_calendar"
-Left ConsoleAgent interactive mode.
-```
+| Command | What it does |
+|---------|-------------|
+| `/auto` | Toggle auto-execute (skip confirmations) |
+| `/compact` | Compress history into a summary (saves tokens) |
+| `/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 |
+| `/name <label>` | Name the session for easy resume |
 
-List recent sessions:
+Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
 
-```
-irb> ai_sessions
-[Sessions — showing 3]
+Say "think harder" in any query to auto-upgrade to the thinking model for that session. After 5+ tool rounds, you'll also be prompted to switch.
 
-  #42 sf_user_123_calendar find user 123 with calendar issues
-     [interactive] 5m ago 2340 tokens
+## Features
 
-  #41 count all active users
-     [one_shot] 1h ago 850 tokens
+- **Tool use** — AI introspects your schema, models, files, and code to write accurate queries
+- **Multi-step plans** — complex tasks are broken into steps, executed sequentially with `step1`/`step2` references
+- **Two-tier models** — defaults to Sonnet for speed/cost; `/think` upgrades to Opus when you need it
+- **Cost tracking** — `/cost` shows per-model token usage and estimated spend
+- **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)
+- **History compaction** — `/compact` summarizes long conversations to reduce cost and latency
 
-  #40 debug_payments explain payment flow
-     [interactive] 2h ago 4100 tokens
+## Configuration
 
-Use ai_resume(id_or_name) to resume a session.
+```ruby
+ConsoleAgent.configure do |config|
+  config.provider = :anthropic       # or :openai
+  config.auto_execute = false         # true to skip confirmations
+  config.session_logging = true       # requires ai_setup
+  config.model = 'claude-sonnet-4-6'  # model used by /think (default)
+  config.thinking_model = 'claude-opus-4-6'  # model used by /think (default)
+end
 ```
 
-Resume a session by name or ID — previous output is replayed, then you continue where you left off:
-
-```
-irb> ai_resume "sf_user_123_calendar"
---- Replaying previous session output ---
-ai> find user 123 with calendar issues
-  ...previous output...
---- End of previous output ---
-
-ConsoleAgent interactive mode (sf_user_123_calendar). Type 'exit' to leave.
-ai> now check their calendar sync status
-  ...
-```
+The default model is `claude-sonnet-4-6` (Anthropic) or `gpt-5.3-codex` (OpenAI). The thinking model defaults to `claude-opus-4-6` and is activated via `/think` or by saying "think harder".
 
-Name or rename a session after the fact:
+## Web UI Authentication
 
-```
-irb> ai_name 41, "active_user_count"
-Session #41 named: active_user_count
-```
+The engine mounts a session viewer at `/console_agent`. By default it's open — you can protect it with basic auth or a custom authentication function.
 
-Filter sessions by search term:
+### Basic Auth
 
+```ruby
+ConsoleAgent.configure do |config|
+  config.admin_username = 'admin'
+  config.admin_password = ENV['CONSOLE_AGENT_PASSWORD']
+end
 ```
-irb> ai_sessions 20, search: "salesforce"
-```
-
-If you have an existing `console_agent_sessions` table, run `ConsoleAgent.migrate!` to add the `name` column.
 
-## Configuration
+### Custom Authentication
 
-All settings live in `config/initializers/console_agent.rb` and can be changed at runtime:
+For apps with their own auth system, pass a proc to `authenticate`. It runs in the controller context, so you have access to `session`, `request`, `redirect_to`, etc.
 
 ```ruby
 ConsoleAgent.configure do |config|
-  config.provider = :anthropic       # or :openai
-  config.auto_execute = false         # true to skip confirmations
-  config.max_tokens = 4096             # max tokens per LLM response
-  config.max_tool_rounds = 10         # max tool calls per query
-  config.session_logging = true       # log sessions to DB (run ConsoleAgent.setup!)
+  config.authenticate = proc {
+    user = User.find_by(id: session[:user_id])
+    unless user&.admin?
+      redirect_to '/login'
+    end
+  }
 end
 ```
 
-For the admin UI, mount the engine:
-
-```ruby
-mount ConsoleAgent::Engine => '/console_agent'
-```
+When `authenticate` is set, `admin_username` / `admin_password` are ignored.
 
 ## Requirements
 
-- Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0
+Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0
 
 ## License
 

data/app/controllers/console_agent/application_controller.rb

@@ -2,19 +2,23 @@ module ConsoleAgent
   class ApplicationController < ActionController::Base
     protect_from_forgery with: :exception
 
-    before_action :authenticate!
+    before_action :console_agent_authenticate!
 
     private
 
-    def authenticate!
-      username = ConsoleAgent.configuration.admin_username
-      password = ConsoleAgent.configuration.admin_password
+    def console_agent_authenticate!
+      if (auth = ConsoleAgent.configuration.authenticate)
+        instance_exec(&auth)
+      else
+        username = ConsoleAgent.configuration.admin_username
+        password = ConsoleAgent.configuration.admin_password
 
-      return unless username && password
+        return unless username && password
 
-      authenticate_or_request_with_http_basic('ConsoleAgent Admin') do |u, p|
-        ActiveSupport::SecurityUtils.secure_compare(u, username) &
-          ActiveSupport::SecurityUtils.secure_compare(p, password)
+        authenticate_or_request_with_http_basic('ConsoleAgent Admin') do |u, p|
+          ActiveSupport::SecurityUtils.secure_compare(u, username) &
+            ActiveSupport::SecurityUtils.secure_compare(p, password)
+        end
       end
     end
   end

data/lib/console_agent/configuration.rb

@@ -2,29 +2,44 @@ module ConsoleAgent
   class Configuration
     PROVIDERS = %i[anthropic openai].freeze
 
-    attr_accessor :provider, :api_key, :model, :max_tokens,
+    PRICING = {
+      'claude-sonnet-4-6' => { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000 },
+      'claude-opus-4-6'   => { input: 15.0 / 1_000_000, output: 75.0 / 1_000_000 },
+      'claude-haiku-4-5-20251001' => { input: 0.80 / 1_000_000, output: 4.0 / 1_000_000 },
+    }.freeze
+
+    DEFAULT_MAX_TOKENS = {
+      'claude-sonnet-4-6' => 16_000,
+      'claude-haiku-4-5-20251001' => 16_000,
+      'claude-opus-4-6'   => 4_096,
+    }.freeze
+
+    attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
                   :timeout, :debug, :max_tool_rounds,
                   :storage_adapter, :memories_enabled,
                   :session_logging, :connection_class,
-                  :admin_username, :admin_password
+                  :admin_username, :admin_password,
+                  :authenticate
 
     def initialize
       @provider     = :anthropic
       @api_key      = nil
       @model        = nil
-      @max_tokens   = 4096
+      @thinking_model = nil
+      @max_tokens   = nil
       @auto_execute = false
       @temperature  = 0.2
       @timeout      = 30
       @debug        = false
-      @max_tool_rounds = 100
+      @max_tool_rounds = 200
       @storage_adapter  = nil
       @memories_enabled = true
       @session_logging  = true
       @connection_class = nil
       @admin_username   = nil
       @admin_password   = nil
+      @authenticate     = nil
     end
 
     def resolved_api_key
@@ -41,6 +56,23 @@ module ConsoleAgent
     def resolved_model
       return @model if @model && !@model.empty?
 
+      case @provider
+      when :anthropic
+        'claude-sonnet-4-6'
+      when :openai
+        'gpt-5.3-codex'
+      end
+    end
+
+    def resolved_max_tokens
+      return @max_tokens if @max_tokens
+
+      DEFAULT_MAX_TOKENS.fetch(resolved_model, 4096)
+    end
+
+    def resolved_thinking_model
+      return @thinking_model if @thinking_model && !@thinking_model.empty?
+
       case @provider
       when :anthropic
         'claude-opus-4-6'

data/lib/console_agent/console_methods.rb

@@ -130,6 +130,10 @@ module ConsoleAgent
       nil
     end
 
+    def ai_setup
+      ConsoleAgent.setup!
+    end
+
     def ai_init
       require 'console_agent/context_builder'
       require 'console_agent/providers/base'
@@ -153,6 +157,7 @@ module ConsoleAgent
         $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_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
@@ -249,6 +254,14 @@ module ConsoleAgent
     end
 
     def __console_agent_binding
+      # Try Pry first (pry-rails replaces IRB but IRB may still be loaded)
+      if defined?(Pry)
+        pry_inst = ObjectSpace.each_object(Pry).find { |p|
+          p.respond_to?(:binding_stack) && !p.binding_stack.empty?
+        } rescue nil
+        return pry_inst.current_binding if pry_inst
+      end
+
       # Try IRB workspace binding
       if defined?(IRB) && IRB.respond_to?(:CurrentContext)
         ctx = IRB.CurrentContext rescue nil
@@ -257,14 +270,6 @@ module ConsoleAgent
         end
       end
 
-      # Try Pry binding
-      if defined?(Pry) && respond_to?(:pry_instance, true)
-        pry_inst = pry_instance rescue nil
-        if pry_inst && pry_inst.respond_to?(:current_binding)
-          return pry_inst.current_binding
-        end
-      end
-
       # Fallback
       TOPLEVEL_BINDING
     end

data/lib/console_agent/executor.rb

@@ -43,7 +43,7 @@ module ConsoleAgent
   class Executor
     CODE_REGEX = /```ruby\s*\n(.*?)```/m
 
-    attr_reader :binding_context
+    attr_reader :binding_context, :last_error
     attr_accessor :on_prompt
 
     def initialize(binding_context)
@@ -75,6 +75,7 @@ module ConsoleAgent
     def execute(code)
       return nil if code.nil? || code.strip.empty?
 
+      @last_error = nil
       captured_output = StringIO.new
       old_stdout = $stdout
       # Tee output: capture it and also print to the real stdout
@@ -89,12 +90,14 @@ module ConsoleAgent
       result
     rescue SyntaxError => e
       $stdout = old_stdout if old_stdout
-      $stderr.puts colorize("SyntaxError: #{e.message}", :red)
+      @last_error = "SyntaxError: #{e.message}"
+      $stderr.puts colorize(@last_error, :red)
       @last_output = nil
       nil
     rescue => e
       $stdout = old_stdout if old_stdout
-      $stderr.puts colorize("Error: #{e.class}: #{e.message}", :red)
+      @last_error = "#{e.class}: #{e.message}"
+      $stderr.puts colorize("Error: #{@last_error}", :red)
       e.backtrace.first(3).each { |line| $stderr.puts colorize("  #{line}", :red) }
       @last_output = captured_output&.string
       nil

data/lib/console_agent/providers/anthropic.rb

@@ -50,7 +50,7 @@ module ConsoleAgent
 
         body = {
           model: config.resolved_model,
-          max_tokens: config.max_tokens,
+          max_tokens: config.resolved_max_tokens,
           temperature: config.temperature,
           messages: format_messages(messages)
         }

data/lib/console_agent/providers/openai.rb

@@ -50,7 +50,7 @@ module ConsoleAgent
 
         body = {
           model: config.resolved_model,
-          max_tokens: config.max_tokens,
+          max_tokens: config.resolved_max_tokens,
           temperature: config.temperature,
           messages: formatted
         }

data/lib/console_agent/repl.rb

@@ -11,6 +11,7 @@ module ConsoleAgent
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @token_usage = Hash.new { |h, k| h[k] = { input: 0, output: 0 } }
       @input_history = []
     end
 
@@ -18,29 +19,25 @@ module ConsoleAgent
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
       exec_result = with_console_capture(console_capture) do
-        result, _ = send_query(query)
-        track_usage(result)
-        code = @executor.display_response(result.text)
-        display_usage(result)
-
-        exec_result = nil
-        executed = false
-        has_code = code && !code.strip.empty?
-
-        if has_code
-          exec_result = if ConsoleAgent.configuration.auto_execute
-                          @executor.execute(code)
-                        else
-                          @executor.confirm_and_execute(code)
-                        end
-          executed = !@executor.last_cancelled?
+        conversation = [{ role: :user, content: query }]
+        exec_result, code, executed = one_shot_round(conversation)
+
+        # Auto-retry once if execution errored
+        if executed && @executor.last_error
+          error_msg = "Code execution failed with error: #{@executor.last_error}"
+          error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+          conversation << { role: :assistant, content: @_last_result_text }
+          conversation << { role: :user, content: error_msg }
+
+          $stdout.puts "\e[2m  Attempting to fix...\e[0m"
+          exec_result, code, executed = one_shot_round(conversation)
         end
 
         @_last_log_attrs = {
           query: query,
-          conversation: [{ role: :user, content: query }, { role: :assistant, content: result.text }],
+          conversation: conversation,
           mode: 'one_shot',
-          code_executed: has_code ? code : nil,
+          code_executed: code,
           code_output: executed ? @executor.last_output : nil,
           code_result: executed && exec_result ? exec_result.inspect : nil,
           executed: executed,
@@ -61,6 +58,31 @@ module ConsoleAgent
       nil
     end
 
+    # Executes one LLM round: send query, display, optionally execute code.
+    # Returns [exec_result, code, executed].
+    def one_shot_round(conversation)
+      result, _ = send_query(nil, conversation: conversation)
+      track_usage(result)
+      code = @executor.display_response(result.text)
+      display_usage(result)
+      @_last_result_text = result.text
+
+      exec_result = nil
+      executed = false
+      has_code = code && !code.strip.empty?
+
+      if has_code
+        exec_result = if ConsoleAgent.configuration.auto_execute
+                        @executor.execute(code)
+                      else
+                        @executor.confirm_and_execute(code)
+                      end
+        executed = !@executor.last_cancelled?
+      end
+
+      [exec_result, has_code ? code : nil, executed]
+    end
+
     def explain(query)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
@@ -188,6 +210,7 @@ module ConsoleAgent
       @history = []
       @total_input_tokens = 0
       @total_output_tokens = 0
+      @token_usage = Hash.new { |h, k| h[k] = { input: 0, output: 0 } }
       @interactive_query = nil
       @interactive_session_id = nil
       @interactive_session_name = nil
@@ -195,6 +218,7 @@ module ConsoleAgent
       @last_interactive_output = nil
       @last_interactive_result = nil
       @last_interactive_executed = false
+      @compact_warned = false
     end
 
     def interactive_loop
@@ -202,7 +226,7 @@ module ConsoleAgent
       name_display = @interactive_session_name ? " (#{@interactive_session_name})" : ""
       # Write banner to real stdout (bypass TeeIO) so it doesn't accumulate on resume
       @interactive_old_stdout.puts "\e[36mConsoleAgent interactive mode#{name_display}. Type 'exit' or 'quit' to leave.\e[0m"
-      @interactive_old_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle) | > code to run directly | /usage | /name <label>\e[0m"
+      @interactive_old_stdout.puts "\e[2m  Auto-execute: #{auto ? 'ON' : 'OFF'} (Shift-Tab or /auto to toggle) | > code | /usage | /cost | /compact | /think | /name <label>\e[0m"
 
       # Bind Shift-Tab to insert /auto command and submit
       if Readline.respond_to?(:parse_and_bind)
@@ -236,6 +260,21 @@ module ConsoleAgent
           next
         end
 
+        if input == '/compact'
+          compact_history
+          next
+        end
+
+        if input == '/cost'
+          display_cost_summary
+          next
+        end
+
+        if input == '/think'
+          upgrade_to_thinking_model
+          next
+        end
+
         if input.start_with?('/name')
           name = input.sub('/name', '').strip
           if name.empty?
@@ -287,6 +326,11 @@ module ConsoleAgent
         # Add to Readline history (avoid consecutive duplicates)
         Readline::HISTORY.push(input) unless input == Readline::HISTORY.to_a.last
 
+        # Auto-upgrade to thinking model on "think harder" phrases
+        if input =~ /think\s*harder/i
+          upgrade_to_thinking_model
+        end
+
         @interactive_query ||= input
         @history << { role: :user, content: input }
 
@@ -296,65 +340,24 @@ module ConsoleAgent
         # Save immediately so the session is visible in the admin UI while the AI thinks
         log_interactive_turn
 
-        begin
-          result, tool_messages = send_query(input, conversation: @history)
-        rescue Interrupt
-          $stdout.puts "\n\e[33m  Aborted.\e[0m"
+        status = send_and_execute
+        if status == :interrupted
           @history.pop # Remove the user message that never got a response
           log_interactive_turn
           next
         end
 
-        track_usage(result)
-        code = @executor.display_response(result.text)
-        display_usage(result, show_session: true)
-
-        # Save after response is displayed so viewer shows progress before Execute prompt
-        log_interactive_turn
-
-        # Add tool call/result messages so the LLM remembers what it learned
-        @history.concat(tool_messages) if tool_messages && !tool_messages.empty?
-        @history << { role: :assistant, content: result.text }
-
-        if code && !code.strip.empty?
-          if ConsoleAgent.configuration.auto_execute
-            exec_result = @executor.execute(code)
-          else
-            exec_result = @executor.confirm_and_execute(code)
-          end
-
-          unless @executor.last_cancelled?
-            @last_interactive_code = code
-            @last_interactive_output = @executor.last_output
-            @last_interactive_result = exec_result ? exec_result.inspect : nil
-            @last_interactive_executed = true
-          end
-
-          if @executor.last_cancelled?
-            @history << { role: :user, content: "User declined to execute the code." }
-          else
-            output_parts = []
-
-            # Capture printed output (puts, print, etc.)
-            if @executor.last_output && !@executor.last_output.strip.empty?
-              output_parts << "Output:\n#{@executor.last_output.strip}"
-            end
-
-            # Capture return value
-            if exec_result
-              output_parts << "Return value: #{exec_result.inspect}"
-            end
-
-            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}" }
-            end
-          end
+        # Auto-retry once when execution fails — send error back to LLM for a fix
+        if status == :error
+          $stdout.puts "\e[2m  Attempting to fix...\e[0m"
+          log_interactive_turn
+          send_and_execute
         end
 
         # Update with the AI response, tokens, and any execution results
         log_interactive_turn
+
+        warn_if_history_large
       end
 
       $stdout = @interactive_old_stdout
@@ -374,6 +377,87 @@ module ConsoleAgent
       $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
     end
 
+    # Sends conversation to LLM, displays response, executes code if present.
+    # Returns :success, :error, :cancelled, :no_code, or :interrupted.
+    def send_and_execute
+      begin
+        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
+        else
+          $stderr.puts "\e[31mConsoleAgent Error: #{e.class}: #{e.message}\e[0m"
+          return :error
+        end
+      rescue Interrupt
+        $stdout.puts "\n\e[33m  Aborted.\e[0m"
+        return :interrupted
+      end
+
+      track_usage(result)
+      code = @executor.display_response(result.text)
+      display_usage(result, show_session: true)
+
+      # Save after response is displayed so viewer shows progress before Execute prompt
+      log_interactive_turn
+
+      # Add tool call/result messages so the LLM remembers what it learned
+      @history.concat(tool_messages) if tool_messages && !tool_messages.empty?
+      @history << { role: :assistant, content: result.text }
+
+      return :no_code unless code && !code.strip.empty?
+
+      exec_result = if ConsoleAgent.configuration.auto_execute
+                      @executor.execute(code)
+                    else
+                      @executor.confirm_and_execute(code)
+                    end
+
+      unless @executor.last_cancelled?
+        @last_interactive_code = code
+        @last_interactive_output = @executor.last_output
+        @last_interactive_result = exec_result ? exec_result.inspect : nil
+        @last_interactive_executed = true
+      end
+
+      if @executor.last_cancelled?
+        @history << { role: :user, content: "User declined to execute the code." }
+        :cancelled
+      elsif @executor.last_error
+        error_msg = "Code execution failed with error: #{@executor.last_error}"
+        error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+        @history << { role: :user, content: error_msg }
+        :error
+      else
+        output_parts = []
+
+        # Capture printed output (puts, print, etc.)
+        if @executor.last_output && !@executor.last_output.strip.empty?
+          output_parts << "Output:\n#{@executor.last_output.strip}"
+        end
+
+        # Capture return value
+        if exec_result
+          output_parts << "Return value: #{exec_result.inspect}"
+        end
+
+        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}" }
+        end
+
+        :success
+      end
+    end
+
     def provider
       @provider ||= Providers.build
     end
@@ -383,7 +467,32 @@ module ConsoleAgent
     end
 
     def context
-      @context ||= context_builder.build
+      base = @context_base ||= context_builder.build
+      vars = binding_variable_summary
+      vars ? "#{base}\n\n#{vars}" : base
+    end
+
+    # Summarize local and instance variables from the user's console session
+    # so the LLM knows what's available to reference in generated code.
+    def binding_variable_summary
+      parts = []
+
+      locals = @binding_context.local_variables.reject { |v| v.to_s.start_with?('_') }
+      locals.first(20).each do |var|
+        val = @binding_context.local_variable_get(var) rescue nil
+        parts << "#{var} (#{val.class})"
+      end
+
+      ivars = (@binding_context.eval("instance_variables") rescue [])
+      ivars.reject { |v| v.to_s =~ /\A@_/ }.first(20).each do |var|
+        val = @binding_context.eval(var.to_s) rescue nil
+        parts << "#{var} (#{val.class})"
+      end
+
+      return nil if parts.empty?
+      "The user's console session has these variables available: #{parts.join(', ')}. You can reference them directly in code."
+    rescue
+      nil
     end
 
     def init_system_prompt(existing_guide)
@@ -455,8 +564,18 @@ 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
@@ -469,8 +588,22 @@ module ConsoleAgent
           $stdout.puts "\e[2m  #{llm_status(round, messages, total_input, last_thinking, last_tool_names)}\e[0m"
         end
 
-        result = with_escape_monitoring do
-          provider.chat_with_tools(messages, tools: tools, system_prompt: active_system_prompt)
+        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
@@ -698,6 +831,10 @@ module ConsoleAgent
     def track_usage(result)
       @total_input_tokens += result.input_tokens || 0
       @total_output_tokens += result.output_tokens || 0
+
+      model = ConsoleAgent.configuration.resolved_model
+      @token_usage[model][:input] += result.input_tokens || 0
+      @token_usage[model][:output] += result.output_tokens || 0
     end
 
     def display_usage(result, show_session: false)
@@ -805,6 +942,129 @@ module ConsoleAgent
       $stdout.puts "\e[2m[session totals — in: #{@total_input_tokens} | out: #{@total_output_tokens} | total: #{@total_input_tokens + @total_output_tokens}]\e[0m"
     end
 
+    def display_cost_summary
+      if @token_usage.empty?
+        $stdout.puts "\e[2m  No usage yet.\e[0m"
+        return
+      end
+
+      total_cost = 0.0
+      $stdout.puts "\e[36m  Cost estimate:\e[0m"
+
+      @token_usage.each do |model, usage|
+        pricing = Configuration::PRICING[model]
+        input_str = "in: #{format_tokens(usage[:input])}"
+        output_str = "out: #{format_tokens(usage[:output])}"
+
+        if pricing
+          cost = (usage[:input] * pricing[:input]) + (usage[:output] * pricing[:output])
+          total_cost += cost
+          $stdout.puts "\e[2m    #{model}:  #{input_str}  #{output_str}  ~$#{'%.2f' % cost}\e[0m"
+        else
+          $stdout.puts "\e[2m    #{model}:  #{input_str}  #{output_str}  (pricing unknown)\e[0m"
+        end
+      end
+
+      $stdout.puts "\e[36m    Total: ~$#{'%.2f' % total_cost}\e[0m"
+    end
+
+    def upgrade_to_thinking_model
+      config = ConsoleAgent.configuration
+      current = config.resolved_model
+      thinking = config.resolved_thinking_model
+
+      if current == thinking
+        $stdout.puts "\e[36m  Already using thinking model (#{current}).\e[0m"
+      else
+        config.model = thinking
+        @provider = nil
+        $stdout.puts "\e[36m  Switched to thinking model: #{thinking}\e[0m"
+      end
+    end
+
+    def on_thinking_model?
+      config = ConsoleAgent.configuration
+      config.resolved_model == config.resolved_thinking_model
+    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
+        @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
+    end
+
+    def compact_history
+      if @history.length < 6
+        $stdout.puts "\e[33m  History too short to compact (#{@history.length} messages). Need at least 6.\e[0m"
+        return
+      end
+
+      before_chars = @history.sum { |m| m[:content].to_s.length }
+      before_count = @history.length
+
+      $stdout.puts "\e[2m  Compacting #{before_count} messages (~#{format_tokens(before_chars)} chars)...\e[0m"
+
+      system_prompt = <<~PROMPT
+        You are a conversation summarizer. The user will provide a conversation history from a Rails console AI assistant session.
+
+        Produce a concise summary that captures:
+        - What the user has been working on and their goals
+        - 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
+
+        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
+
+      history_text = @history.map { |m| "#{m[:role]}: #{m[:content]}" }.join("\n\n")
+      messages = [{ role: :user, content: "Summarize this conversation history:\n\n#{history_text}" }]
+
+      begin
+        result = provider.chat(messages, system_prompt: system_prompt)
+        track_usage(result)
+
+        summary = result.text.to_s.strip
+        if summary.empty?
+          $stdout.puts "\e[33m  Compaction failed: empty summary returned.\e[0m"
+          return
+        end
+
+        @history = [{ role: :user, content: "CONVERSATION SUMMARY (compacted):\n#{summary}" }]
+        @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" }
+        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
+
+      to_summarize = messages[0...-4]
+      to_keep = messages[-4..]
+
+      history_text = to_summarize.map { |m| "#{m[:role]}: #{m[:content].to_s[0..500]}" }.join("\n\n")
+
+      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."
+      )
+
+      [{ role: :user, content: "CONTEXT SUMMARY:\n#{summary_result.text}" }] + to_keep
+    end
+
     def display_exit_info
       display_session_summary
       if @interactive_session_id

data/lib/console_agent/tools/registry.rb

@@ -339,8 +339,12 @@ module ConsoleAgent
           # Make result available as step1, step2, etc. for subsequent steps
           @executor.binding_context.local_variable_set(:"step#{i + 1}", exec_result)
           output = @executor.last_output
+          error = @executor.last_error
 
           step_report = "Step #{i + 1} (#{step['description']}):\n"
+          if error
+            step_report += "ERROR: #{error}\n"
+          end
           if output && !output.strip.empty?
             step_report += "Output: #{output.strip}\n"
           end

data/lib/console_agent/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: console_agent
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Cortfr