rails_console_ai 0.32.0 → 0.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7eab1fd8d3a5c8c7a228206f0c723bfa845fa2d344471e0251659658c0c5e571
-  data.tar.gz: c607b6cfa9e6834612513f0c75dc1303386f79bcdd96bba203a4fb5d0549f32b
+  metadata.gz: 61fcabfed3f03e58e104b7c8b49b86ccf365db5dbae5e1dbf1f8f1b7e63d811c
+  data.tar.gz: ec844ca4e1251fb9c1f0c0172095050745ef9690a90defefbcded92eae0962f8
 SHA512:
-  metadata.gz: 1acd49dcf3370eaab8a8fb8ef77c7dad4746fcb0e0eb2f78935b53c870228a9b53a2cef8dc82608ed94f5f2642de905070fe9e241e9a98d8f408653535ce30d7
-  data.tar.gz: bd7ec6fcf50788b45f47f6a7b1948a74fb83cf4ff7fba62687eb2d6e8c75743972f4e83525d87f57096c1a6cd114611a69c5b6e2299a88dea6b02063cdf09adc
+  metadata.gz: f2294a51714714de69afcc908dccbcb8d5034999973c40b4533600579e8617efc1133ed918ed7925aa082a3afd5598335b5a09527d1a933b38a6ddbf8143d595
+  data.tar.gz: bce68674c9467a92eac6b7521e4f1e39f1d06c32b374f38f627513c7ab31bdda57a12a2e937654103a2322d075b594aa56b610cf2ad716f1965f1c2d6123cfad

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.34.0]
+
+- Add an `:in_process_requests` built-in safety guard that blocks in-process HTTP dispatch against the app itself — `ActionDispatch::Integration::Session` requests (the console `app` helper) and direct Rack dispatch (`Rails.application.call`) — for all verbs including GET, since these can hang the session thread indefinitely; allowlist entries are request paths
+- Create/update the session record with a `running` status before each turn's tool loop starts, so a turn that hangs or dies mid-loop still leaves a visible session record, and show each session's status in the admin sessions page
+- Make session logging drop attributes the sessions table doesn't have a column for yet, so a gem newer than the table degrades to a partial row instead of losing the insert
+- Fix the sessions page cost display after the pricing refactor
+
+## [0.33.0]
+
+- Support Claude Opus 5 and make it the default model for the Anthropic and Bedrock providers
+- Add runaway-loop circuit breakers to the tool loop — break when the same error signature repeats (warn at 3 occurrences, stop at 5) or when a token budget is exceeded (nudge at 500K input tokens, force a final answer at 1M), with a tailored wrap-up prompt for each break reason
+- Fail fast on known environment errors: a built-in hint recognizes decryption key misconfiguration (`bad decrypt` / `ActiveRecord::Encryption`) and tells the model not to retry, and apps can register their own hints via `config.error_hints`
+
 ## [0.32.0]
 
 - Switch default models to Claude Sonnet 5 and Opus 4.8, and rework pricing to match models by family so dated snapshots and Bedrock IDs are covered

data/README.md

@@ -176,15 +176,17 @@ Safety guards prevent AI-generated code from causing side effects. When a guard
 
 ```ruby
 RailsConsoleAi.configure do |config|
-  config.use_builtin_safety_guard :database_writes  # blocks INSERT/UPDATE/DELETE/DROP/etc.
-  config.use_builtin_safety_guard :http_mutations    # blocks POST/PUT/PATCH/DELETE via Net::HTTP
-  config.use_builtin_safety_guard :mailers           # disables ActionMailer delivery
+  config.use_builtin_safety_guard :database_writes      # blocks INSERT/UPDATE/DELETE/DROP/etc.
+  config.use_builtin_safety_guard :http_mutations        # blocks POST/PUT/PATCH/DELETE via Net::HTTP
+  config.use_builtin_safety_guard :mailers               # disables ActionMailer delivery
+  config.use_builtin_safety_guard :in_process_requests   # blocks in-process requests against the app itself
 end
 ```
 
 - **`:database_writes`** — intercepts the ActiveRecord connection adapter to block write SQL. Works on Rails 5+ with any database adapter.
 - **`:http_mutations`** — intercepts `Net::HTTP#request` to block non-GET/HEAD/OPTIONS requests. Covers libraries built on Net::HTTP (HTTParty, RestClient, Faraday).
 - **`:mailers`** — sets `ActionMailer::Base.perform_deliveries = false` during execution.
+- **`:in_process_requests`** — blocks `ActionDispatch::Integration::Session` requests (the console `app` helper) and direct Rack dispatch (`Rails.application.call`). These run the app's full middleware stack inside the current process and can deadlock or hang the session thread indefinitely, so **all verbs are blocked, including GET**. Allowlist entries are request paths.
 
 ### Custom Guards
 
@@ -291,7 +293,7 @@ RailsConsoleAi.configure do |config|
 end
 ```
 
-Default model: `claude-sonnet-5`. Thinking model: `claude-opus-4-8`. Prompt caching is enabled automatically.
+Default model: `claude-sonnet-5`. Thinking model: `claude-opus-5`. Prompt caching is enabled automatically.
 
 ### OpenAI
 
@@ -318,7 +320,7 @@ RailsConsoleAi.configure do |config|
   config.provider = :bedrock
   config.bedrock_region = 'us-east-1'
   # config.model = 'us.anthropic.claude-sonnet-5'        # default
-  # config.thinking_model = 'us.anthropic.claude-opus-4-8' # default
+  # config.thinking_model = 'us.anthropic.claude-opus-5'   # default
 end
 ```
 
@@ -396,9 +398,48 @@ RailsConsoleAi.configure do |config|
   config.timeout = 30                 # HTTP timeout in seconds
   config.max_tool_rounds = 200        # safety cap on tool-use loops
   config.code_search_paths = %w[app]  # directories for list_files / search_code
+
+  # Runaway-loop circuit breakers (see "Runaway sessions" below)
+  config.token_nudge_threshold = 500_000    # input tokens in one tool loop → nudge model to wrap up (nil disables)
+  config.token_stop_threshold  = 1_000_000  # input tokens in one tool loop → force a final answer (nil disables)
 end
 ```
 
+### Runaway sessions & known-issue hints
+
+Two mechanisms stop the LLM from burning tokens on a dead end:
+
+**Known-issue hints** — when executed code fails (or prints a rescued error) matching a
+known environment-level problem, the tool result includes explicit guidance telling the
+model not to retry. The built-in hint recognizes decryption failures
+(`OpenSSL::Cipher::CipherError` / "bad decrypt" / `ActiveRecord::Encryption` errors),
+which indicate a missing or placeholder encryption key in the console process — an
+environment issue no amount of retrying can fix. Repeat occurrences escalate the message.
+Apps can add their own:
+
+```ruby
+RailsConsoleAi.configure do |config|
+  config.error_hints << {
+    name: :vpn_required,
+    pattern: /Errno::ECONNREFUSED.*10\.8\./,
+    hint: "This host is only reachable over the VPN, which this console does not have. " \
+          "Do not retry; report the limitation to the user."
+  }
+end
+```
+
+**Circuit breakers** — inside a single tool loop, the engine tracks:
+
+- *Identical tool calls* (same tool + same args): warns at 3, breaks at 5.
+- *Repeated error signatures* (same normalized error from **different** code): warns at 3,
+  breaks at 5. This catches "new code, same dead end" loops that identical-call detection
+  misses. Digits are normalized so varying record IDs don't disguise the same failure.
+- *Token budget*: at `token_nudge_threshold` cumulative input tokens the model is told to
+  wrap up; at `token_stop_threshold` the loop is stopped and a final answer is forced.
+
+When any breaker trips, the model is asked to summarize what it established, what it
+could not determine and why, and what a human should do next — instead of iterating.
+
 ### Code Search Paths
 
 By default, `list_files` and `search_code` only look in `app/`. If your project has code in other directories (e.g. a frontend in `public/portal`, or shared code in `lib`), add them:

data/app/helpers/rails_console_ai/sessions_helper.rb

@@ -1,7 +1,7 @@
 module RailsConsoleAi
   module SessionsHelper
     def estimated_cost(session)
-      pricing = Configuration::PRICING[session.model]
+      pricing = Configuration.pricing_for(session.model)
       return nil unless pricing
 
       (session.input_tokens * pricing[:input]) + (session.output_tokens * pricing[:output])

data/app/views/layouts/rails_console_ai/application.html.erb

@@ -35,6 +35,11 @@
     .badge-one_shot { background: #d4edda; color: #155724; }
     .badge-interactive { background: #cce5ff; color: #004085; }
     .badge-explain { background: #fff3cd; color: #856404; }
+    .badge-status-running { background: #fff3cd; color: #856404; }
+    .badge-status-queued { background: #e2e3e5; color: #383d41; }
+    .badge-status-ready { background: #d4edda; color: #155724; }
+    .badge-status-failed { background: #f8d7da; color: #721c24; }
+    .badge-status-aborted { background: #f8d7da; color: #721c24; }
     .meta-card {
       background: #fff; border-radius: 8px; padding: 20px;
       box-shadow: 0 1px 3px rgba(0,0,0,0.1); margin-bottom: 24px;

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

@@ -17,6 +17,7 @@
         <th>Name</th>
         <th style="max-width: 400px;">Query</th>
         <th>Mode</th>
+        <th>Status</th>
         <th>Tokens</th>
         <th>Cost</th>
         <th>Duration</th>
@@ -31,6 +32,7 @@
           <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>
+          <td><% status = session.try(:status) %><%= status.present? ? content_tag(:span, status, class: "badge badge-status-#{status}") : '-' %></td>
           <td class="mono"><%= session.input_tokens + session.output_tokens %></td>
           <td class="mono"><%= format_cost(session) %></td>
           <td class="mono"><%= session.duration_ms ? "#{session.duration_ms}ms" : '-' %></td>

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

@@ -72,6 +72,13 @@ RailsConsoleAi.configure do |config|
   # Built-in guard for mailers — disables ActionMailer delivery:
   # config.use_builtin_safety_guard :mailers
   #
+  # Built-in guard for in-process requests — blocks ActionDispatch::Integration::Session
+  # (the console `app` helper) and direct Rack dispatch against the running app.
+  # These run the full middleware stack inside this process and can hang the session
+  # thread indefinitely, so ALL verbs are blocked (including GET). Strongly recommended
+  # for Slack/API channels:
+  # config.use_builtin_safety_guard :in_process_requests
+  #
   # config.safety_guard :jobs do |&execute|
   #   Sidekiq::Testing.fake! { execute.call }
   # end

data/lib/rails_console_ai/configuration.rb

@@ -13,6 +13,7 @@ module RailsConsoleAi
     # (removed on opus-4-7+, sonnet-5, and fable-5).
     MODEL_FAMILIES = {
       'claude-fable-5'    => { input: 10.0, output: 50.0, max_tokens: 16_000, temperature: false },
+      'claude-opus-5'     => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: false },
       'claude-opus-4-8'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: false },
       'claude-opus-4-7'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: false },
       'claude-opus-4-6'   => { input: 5.0,  output: 25.0, max_tokens: 16_000, temperature: true },
@@ -47,9 +48,30 @@ module RailsConsoleAi
       }
     end
 
+    # Known environment-level failures the executor recognizes and explains to the
+    # LLM on the FIRST occurrence, so it doesn't burn rounds rediscovering them
+    # through trial and error. Each entry: { name:, pattern:, hint: }.
+    # The pattern is matched against the execution error AND the captured output
+    # (to catch errors rescued and printed by the generated code itself).
+    DEFAULT_ERROR_HINTS = [
+      {
+        name: :decryption_failure,
+        pattern: /OpenSSL::Cipher::CipherError|bad decrypt|ActiveRecord::Encryption::Errors/i,
+        hint: "Decryption failed — this console process's encryption key (e.g. ENV['ENCRYPTION_KEY']) " \
+              "appears to be missing, invalid, or a placeholder for the data you are reading. This is an " \
+              "environment configuration issue, not a data issue, and it affects EVERY encrypted field in " \
+              "this session. Retrying with different code (reloading records, toggling encryption flags, " \
+              "decrypting other fields or records) will fail the same way. Do NOT retry. Report this " \
+              "limitation to the user, tell them the encryption key needs to be configured for this " \
+              "environment, and answer using only what you can determine without decrypting."
+      }
+    ].freeze
+
     attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
                   :timeout, :debug, :max_tool_rounds,
+                  :error_hints,
+                  :token_nudge_threshold, :token_stop_threshold,
                   :storage_adapter, :memories_enabled,
                   :session_logging, :connection_class,
                   :admin_username, :admin_password,
@@ -75,6 +97,9 @@ module RailsConsoleAi
       @timeout      = 30
       @debug        = false
       @max_tool_rounds = 200
+      @error_hints = DEFAULT_ERROR_HINTS.dup
+      @token_nudge_threshold = 500_000    # input tokens in one tool loop → nudge model to wrap up (nil disables)
+      @token_stop_threshold  = 1_000_000  # input tokens in one tool loop → force a final answer (nil disables)
       @storage_adapter  = nil
       @memories_enabled = true
       @session_logging  = true
@@ -147,12 +172,13 @@ module RailsConsoleAi
     end
 
     # Register a built-in safety guard by name.
-    # Available: :database_writes, :http_mutations, :mailers
+    # Available: :database_writes, :http_mutations, :mailers, :in_process_requests
     #
     # Options:
     #   allow: Array of strings or regexps to allowlist for this guard.
-    #     - :http_mutations  → hosts (e.g. "s3.amazonaws.com", /googleapis\.com/)
-    #     - :database_writes → table names (e.g. "rails_console_ai_sessions")
+    #     - :http_mutations      → hosts (e.g. "s3.amazonaws.com", /googleapis\.com/)
+    #     - :database_writes     → table names (e.g. "rails_console_ai_sessions")
+    #     - :in_process_requests → request paths (e.g. "/health")
     def use_builtin_safety_guard(name, allow: nil)
       require 'rails_console_ai/safety_guards'
       guard_name = name.to_sym
@@ -163,8 +189,10 @@ module RailsConsoleAi
         safety_guards.add(:http_mutations, &BuiltinGuards.http_mutations)
       when :mailers
         safety_guards.add(:mailers, &BuiltinGuards.mailers)
+      when :in_process_requests
+        safety_guards.add(:in_process_requests, &BuiltinGuards.in_process_requests)
       else
-        raise ConfigurationError, "Unknown built-in safety guard: #{name}. Available: database_writes, http_mutations, mailers"
+        raise ConfigurationError, "Unknown built-in safety guard: #{name}. Available: database_writes, http_mutations, mailers, in_process_requests"
       end
 
       if allow
@@ -222,13 +250,13 @@ module RailsConsoleAi
 
       case @provider
       when :anthropic
-        'claude-opus-4-8'
+        'claude-opus-5'
       when :openai
         'gpt-5.3-codex'
       when :local
         @local_model
       when :bedrock
-        'us.anthropic.claude-opus-4-8'
+        'us.anthropic.claude-opus-5'
       end
     end
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -7,6 +7,8 @@ module RailsConsoleAi
     LARGE_OUTPUT_PREVIEW_CHARS = 16_000  # chars — how much of the output the LLM sees upfront
     LOOP_WARN_THRESHOLD = 3              # same tool+args repeated → inject warning
     LOOP_BREAK_THRESHOLD = 5             # same tool+args repeated → break loop
+    REPEAT_ERROR_WARN_THRESHOLD = 3      # same error signature (any args) → inject warning
+    REPEAT_ERROR_BREAK_THRESHOLD = 5     # same error signature (any args) → force wrap-up
 
     def initialize(binding_context:, channel:, slack_thread_ts: nil, slack_channel_name: nil)
       @binding_context = binding_context
@@ -46,6 +48,7 @@ module RailsConsoleAi
         if executed && @executor.last_error && !@executor.last_safety_error
           error_msg = "Code execution failed with error: #{@executor.last_error}"
           error_msg = error_msg[0..1000] + '...' if error_msg.length > 1000
+          error_msg += "\n\n#{@executor.last_error_hint}" if @executor.last_error_hint
           conversation << { role: :assistant, content: @_last_result_text }
           conversation << { role: :user, content: error_msg }
 
@@ -239,6 +242,8 @@ module RailsConsoleAi
     end
 
     def execute_direct(raw_code)
+      @interactive_query ||= "> #{raw_code}"
+      log_interactive_turn(status: 'running')
       exec_result = @executor.execute_unsafe(raw_code)
 
       output_parts = []
@@ -257,14 +262,31 @@ module RailsConsoleAi
       end
       @history << { role: :user, content: context_msg, output_id: output_id }
 
-      @interactive_query ||= "> #{raw_code}"
       @last_interactive_code = raw_code
       @last_interactive_output = @executor.last_output
       @last_interactive_result = exec_result ? exec_result.inspect : nil
       @last_interactive_executed = true
+      log_interactive_turn(status: 'ready')
     end
 
+    # Wraps run_turn with session-row status tracking. The row is created/updated
+    # with status 'running' BEFORE the tool loop starts, so a turn that hangs or
+    # dies mid-loop (hung eval, OOM-killed pod, deploy) still leaves a visible
+    # session record instead of vanishing without a trace.
     def send_and_execute
+      log_interactive_turn(status: 'running')
+      status = run_turn
+      log_interactive_turn(status: status == :error ? 'failed' : 'ready')
+      status
+    rescue Interrupt
+      log_interactive_turn(status: 'ready')
+      raise
+    rescue StandardError
+      log_interactive_turn(status: 'failed')
+      raise
+    end
+
+    def run_turn
       begin
         result, tool_messages, last_llm_stats = send_query(nil, conversation: @history)
       rescue Providers::ProviderError => e
@@ -347,6 +369,7 @@ module RailsConsoleAi
       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
+        error_msg += "\n\n#{@executor.last_error_hint}" if @executor.last_error_hint
         @history << { role: :user, content: error_msg }
         :error
       else
@@ -564,7 +587,7 @@ module RailsConsoleAi
 
     # --- Session logging ---
 
-    def log_interactive_turn
+    def log_interactive_turn(status: nil)
       require 'rails_console_ai/session_logger'
       session_attrs = {
         conversation:  @history,
@@ -576,6 +599,7 @@ module RailsConsoleAi
         executed:      @last_interactive_executed,
         console_output: @channel.respond_to?(:console_capture_string) ? @channel.console_capture_string : nil
       }
+      session_attrs[:status] = status if status
 
       if @interactive_session_id
         SessionLogger.update(@interactive_session_id, session_attrs)
@@ -796,7 +820,11 @@ module RailsConsoleAi
       last_tool_names = []
 
       exhausted = false
+      wrap_up_reason = nil
       tool_call_counts = Hash.new(0)
+      error_sig_counts = Hash.new(0)
+      warned_error_sigs = Set.new
+      token_nudge_sent = false
 
       max_rounds.times do |round|
         if @channel.cancelled?
@@ -918,6 +946,12 @@ module RailsConsoleAi
             $stderr.puts "\e[35m[debug] tool result (#{tool_result.to_s.length} chars)\e[0m"
           end
 
+          # Track repeated error signatures across DIFFERENT tool calls — the
+          # identical-call loop detection below misses "same dead end, new code".
+          if (sig = error_signature(tool_result))
+            error_sig_counts[sig] += 1
+          end
+
           tool_msg = provider.format_tool_result(tc[:id], tool_result)
           full_text = tool_result.to_s
           output_id = @executor.store_output(full_text)
@@ -942,23 +976,68 @@ module RailsConsoleAi
           if tool_call_counts[key] >= LOOP_BREAK_THRESHOLD
             @channel.display_status("  Loop detected: #{tc[:name]} called #{tool_call_counts[key]} times with same args — stopping.")
             exhausted = true
+            wrap_up_reason ||= :tool_loop
           elsif tool_call_counts[key] >= LOOP_WARN_THRESHOLD
             @channel.display_status("  Warning: #{tc[:name]} called #{tool_call_counts[key]} times with same args — consider a different approach.")
             messages << { role: :user, content: "You are repeating the same tool call (#{tc[:name]}) with the same arguments. This is not making progress. Try a different approach or provide your answer now." }
           end
         end
+
+        # Circuit breaker: the same error signature recurring across different
+        # tool calls means no new information is being gained (e.g. every
+        # decryption attempt failing with "bad decrypt" regardless of the code).
+        error_sig_counts.each do |sig, count|
+          if count >= REPEAT_ERROR_BREAK_THRESHOLD
+            @channel.display_status("  Circuit breaker: same error hit #{count} times (#{sig}) — stopping.")
+            exhausted = true
+            wrap_up_reason ||= :repeated_errors
+          elsif count >= REPEAT_ERROR_WARN_THRESHOLD && !warned_error_sigs.include?(sig)
+            warned_error_sigs << sig
+            @channel.display_status("  Warning: same error hit #{count} times — nudging model to change strategy.")
+            messages << { role: :user, content: "You have now hit the same error #{count} times (#{sig}). Trying variations of the same approach is not producing new information. If this error cannot be resolved from this session, stop investigating it: summarize what you have established, state what you could not determine and why, and give the user your best answer." }
+          end
+        end
+
+        # Circuit breaker: token budget for a single tool loop.
+        config = RailsConsoleAi.configuration
+        if config.token_stop_threshold && total_input >= config.token_stop_threshold
+          @channel.display_status("  Token budget exceeded (#{format_tokens(total_input)} input tokens this request) — forcing wrap-up.")
+          exhausted = true
+          wrap_up_reason ||= :token_budget
+        elsif config.token_nudge_threshold && total_input >= config.token_nudge_threshold && !token_nudge_sent
+          token_nudge_sent = true
+          @channel.display_status("  High token usage (#{format_tokens(total_input)} input tokens this request) — nudging model to wrap up.")
+          messages << { role: :user, content: "This investigation has consumed #{format_tokens(total_input)} input tokens without reaching a conclusion. Wrap up now: stop opening new lines of investigation, summarize what you have established, state what you could not determine and why, and give the user your best answer. Only make another tool call if you are confident a single call will resolve the question." }
+        end
+
         break if exhausted
 
         # 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
+        if round == max_rounds - 1
+          exhausted = true
+          wrap_up_reason ||= :round_cap
+        end
       end
 
       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." }
+        final_nudge =
+          case wrap_up_reason
+          when :repeated_errors
+            "You have hit the same error repeatedly without gaining new information. Do not attempt any further tool calls. Give the user a final answer now: (1) what you established, (2) what you could not determine and the blocking error, and (3) what a human should do next."
+          when :token_budget
+            "This session has exceeded its token budget. Do not attempt any further tool calls. Give the user a final answer now: (1) what you established, (2) what you could not determine and why, and (3) what a human should do next."
+          when :tool_loop
+            "You kept repeating the same tool call with the same arguments. Do not attempt any further tool calls. Provide your best answer now based on what you've learned so far."
+          else
+            "You've used all available tool rounds. Please provide your best answer now based on what you've learned so far."
+          end
+        if wrap_up_reason.nil? || wrap_up_reason == :round_cap
+          $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"
+        end
+        messages << { role: :user, content: final_nudge }
         result = provider.chat(messages, system_prompt: active_system_prompt)
         total_input += result.input_tokens || 0
         total_output += result.output_tokens || 0
@@ -1167,6 +1246,15 @@ module RailsConsoleAi
       str.length > max ? str[0..max] + '...' : str
     end
 
+    # Extract a normalized error signature from a tool result so we can detect
+    # "same failure, different code" loops. Digits are collapsed so record IDs,
+    # counts, and offsets don't make identical failures look distinct.
+    def error_signature(tool_result)
+      line = tool_result.to_s[/^ERROR: [^\n]+/]
+      return nil unless line
+      line.gsub(/\d+/, 'N')[0, 160]
+    end
+
     # Wraps mid-task user messages with explicit framing so the model treats them
     # as a real-time interruption that supersedes the prior task, rather than as
     # a reply to the most recent tool result.

data/lib/rails_console_ai/executor.rb

@@ -44,7 +44,8 @@ module RailsConsoleAi
   class Executor
     CODE_REGEX = /```ruby\s*\n(.*?)```/m
 
-    attr_reader :binding_context, :last_error, :last_safety_error, :last_safety_exception
+    attr_reader :binding_context, :last_error, :last_safety_error, :last_safety_exception,
+                :last_error_hint
     attr_accessor :on_prompt
 
     def initialize(binding_context, channel: nil)
@@ -55,6 +56,7 @@ module RailsConsoleAi
       @output_store = {}
       @output_counter = 0
       @active_skill_bypass_methods = Set.new
+      @error_hint_counts = Hash.new(0)
     end
 
     def extract_code(response)
@@ -98,6 +100,7 @@ module RailsConsoleAi
       @last_error = nil
       @last_safety_error = false
       @last_safety_exception = nil
+      @last_error_hint = nil
       captured_output = StringIO.new
       old_stdout = $stdout
       # Three capture strategies:
@@ -140,6 +143,8 @@ module RailsConsoleAi
       display_result(result) if display
 
       @last_output = captured_output.string
+      # Code may have rescued a known failure and printed it — still surface the hint.
+      @last_error_hint = build_error_hint(@last_output)
       result
     rescue Interrupt
       restore_stdout(use_thread_local, old_stdout)
@@ -174,6 +179,7 @@ module RailsConsoleAi
         return nil
       end
       @last_error = "#{e.class}: #{e.message}"
+      @last_error_hint = build_error_hint(@last_error, captured_output&.string)
       backtrace = e.backtrace.first(3).map { |line| "  #{line}" }.join("\n")
       log_execution_error("Error: #{@last_error}\n#{backtrace}")
       @last_output = captured_output&.string
@@ -346,6 +352,29 @@ module RailsConsoleAi
 
     private
 
+    # Match the error/output against configured known-issue patterns
+    # (Configuration#error_hints). Returns a guidance string for the LLM, or nil.
+    # The first occurrence explains the issue; repeats escalate so the model
+    # stops probing the same dead end.
+    def build_error_hint(*texts)
+      text = texts.compact.join("\n")
+      return nil if text.strip.empty?
+
+      hint_def = Array(RailsConsoleAi.configuration.error_hints).find do |h|
+        h[:pattern] && text.match?(h[:pattern])
+      end
+      return nil unless hint_def
+
+      count = (@error_hint_counts[hint_def[:name]] += 1)
+      if count == 1
+        "KNOWN ISSUE DETECTED (#{hint_def[:name]}): #{hint_def[:hint]}"
+      else
+        "KNOWN ISSUE (#{hint_def[:name]}) — this is failure ##{count} for the same underlying problem. " \
+        "You were already told this cannot succeed from this session. Stop retrying now and report the " \
+        "limitation to the user. Reminder: #{hint_def[:hint]}"
+      end
+    end
+
     def restore_stdout(use_thread_local, old_stdout)
       if use_thread_local
         Thread.current[:capture_io] = nil

data/lib/rails_console_ai/safety_guards.rb

@@ -364,6 +364,81 @@ module RailsConsoleAi
       }
     end
 
+    # Blocks in-process HTTP dispatch against the running app itself.
+    # An ActionDispatch::Integration::Session request (the console `app` helper,
+    # or a manually built integration session) runs the app's full middleware
+    # stack inside the current process and can deadlock or hang the session
+    # thread indefinitely — so ALL verbs are blocked, including GET.
+    module InProcessRequestBlocker
+      def process(*args, **kwargs, &block)
+        RailsConsoleAi::BuiltinGuards.check_in_process_request!(args[0], args[1])
+        super
+      end
+    end
+
+    # Backstop for the same hazard via direct Rack dispatch
+    # (e.g. Rails.application.call(env)), which bypasses Integration::Session.
+    module EngineCallBlocker
+      def call(env, *args)
+        if env.is_a?(Hash)
+          RailsConsoleAi::BuiltinGuards.check_in_process_request!(env['REQUEST_METHOD'], env['PATH_INFO'])
+        end
+        super
+      end
+    end
+
+    def self.check_in_process_request!(http_method, path)
+      return unless Thread.current[:rails_console_ai_block_in_process_requests]
+      return if Thread.current[:rails_console_ai_bypass_guards]
+
+      key = path.to_s
+      guards = RailsConsoleAi.configuration.safety_guards
+      return if !key.empty? && guards.allowed?(:in_process_requests, key)
+
+      label = [http_method.to_s.upcase, key].reject(&:empty?).join(' ')
+      raise RailsConsoleAi::SafetyError.new(
+        "In-process HTTP request blocked (#{label.empty? ? 'app dispatch' : label}). " \
+        "Dispatching a request through the app's own middleware stack from this session " \
+        "can hang the process indefinitely, even for GET. Do not retry via another route " \
+        "or Rack — call the controller's underlying service or model code directly instead.",
+        guard: :in_process_requests,
+        blocked_key: key.empty? ? nil : key
+      )
+    end
+
+    def self.in_process_requests
+      ->(&block) {
+        ensure_in_process_blocker_installed!
+        prev = Thread.current[:rails_console_ai_block_in_process_requests]
+        Thread.current[:rails_console_ai_block_in_process_requests] = true
+        begin
+          block.call
+        ensure
+          Thread.current[:rails_console_ai_block_in_process_requests] = prev
+        end
+      }
+    end
+
+    def self.ensure_in_process_blocker_installed!
+      return if @in_process_blocker_installed
+
+      begin
+        require 'action_dispatch'
+        require 'action_dispatch/testing/integration'
+      rescue LoadError, NameError
+        nil # actionpack not (fully) available — the Engine backstop may still apply
+      end
+
+      if defined?(ActionDispatch::Integration::Session) &&
+         !ActionDispatch::Integration::Session.ancestors.include?(InProcessRequestBlocker)
+        ActionDispatch::Integration::Session.prepend(InProcessRequestBlocker)
+      end
+      if defined?(Rails::Engine) && !Rails::Engine.ancestors.include?(EngineCallBlocker)
+        Rails::Engine.prepend(EngineCallBlocker)
+      end
+      @in_process_blocker_installed = true
+    end
+
     def self.ensure_http_blocker_installed!
       return if @http_blocker_installed
 

data/lib/rails_console_ai/session_logger.rb

@@ -32,7 +32,7 @@ module RailsConsoleAi
           opts = attrs[:options]
           create_attrs[:options] = opts.is_a?(String) ? opts : opts.to_json
         end
-        record = session_class.create!(create_attrs)
+        record = session_class.create!(filter_to_columns(create_attrs))
         record.id
       rescue => e
         msg = "RailsConsoleAi: session logging failed: #{e.class}: #{e.message}"
@@ -70,6 +70,7 @@ module RailsConsoleAi
         updates[:result]        = attrs[:result]         if attrs.key?(:result)
         updates[:error_message] = attrs[:error_message]  if attrs.key?(:error_message)
 
+        updates = filter_to_columns(updates)
         session_class.where(id: id).update_all(updates) unless updates.empty?
       rescue => e
         msg = "RailsConsoleAi: session update failed: #{e.class}: #{e.message}"
@@ -80,6 +81,17 @@ module RailsConsoleAi
 
       private
 
+      # Drop attrs the table doesn't have a column for, so a gem that's newer
+      # than the table (e.g. status added before RailsConsoleAi.migrate! ran)
+      # degrades to a partial row instead of losing the whole insert.
+      def filter_to_columns(attrs)
+        return attrs unless session_class.respond_to?(:column_names)
+        cols = session_class.column_names.map(&:to_s)
+        attrs.select { |k, _| cols.include?(k.to_s) }
+      rescue StandardError
+        attrs
+      end
+
       def table_exists?
         # Only cache positive results — retry on failure so transient
         # errors (boot timing, connection not ready) don't stick forever

data/lib/rails_console_ai/tools/registry.rb

@@ -698,13 +698,16 @@ module RailsConsoleAi
         end
 
         if @executor.last_error
-          return "ERROR: #{@executor.last_error}"
+          result = "ERROR: #{@executor.last_error}"
+          result += "\n\n#{@executor.last_error_hint}" if @executor.last_error_hint
+          return result
         end
 
         output = @executor.last_output
         parts = []
         parts << "Output:\n#{output.strip}" if output && !output.strip.empty?
         parts << "Return value: #{exec_result.inspect}"
+        parts << @executor.last_error_hint if @executor.last_error_hint
         parts.join("\n\n")
       end
 
@@ -808,6 +811,7 @@ module RailsConsoleAi
           step_report = "Step #{i + 1} (#{step['description']}):\n"
           if error
             step_report += "ERROR: #{error}\n"
+            step_report += "#{@executor.last_error_hint}\n" if @executor.last_error_hint
           end
           if output && !output.strip.empty?
             step_report += "Output: #{output.strip}\n"

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.32.0'.freeze
+  VERSION = '0.34.0'.freeze
 end

metadata

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