rails_console_ai 0.35.0 → 0.38.0

data/lib/rails_console_ai/providers/bedrock.rb

@@ -49,6 +49,9 @@ module RailsConsoleAi
           messages: mark_conversation_breakpoint(format_messages(messages)),
           inference_config: inference
         }
+        # Converse has no effort field; Anthropic request fields ride along here.
+        effort = config.resolved_effort
+        params[:additional_model_request_fields] = { output_config: { effort: effort } } if effort
         if system_prompt
           sys_blocks = [{ text: system_prompt }]
           sys_blocks << cache_point if cache_supported?
@@ -65,7 +68,7 @@ module RailsConsoleAi
         debug_bedrock_response(response)
 
         tool_calls = extract_tool_calls(response)
-        stop = response.stop_reason == 'tool_use' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(response.stop_reason, %w[tool_use], %w[max_tokens])
 
         usage = response.usage
         ChatResult.new(
@@ -78,7 +81,7 @@ module RailsConsoleAi
           stop_reason: stop
         )
       rescue aws_error_class => e
-        raise ProviderError, "AWS Bedrock error: #{e.message}"
+        raise ProviderError, "AWS Bedrock error (#{e.class}): #{e.message}"
       end
 
       def client

data/lib/rails_console_ai/providers/local.rb

@@ -3,38 +3,19 @@ module RailsConsoleAi
     class Local < OpenAI
       private
 
-      def call_api(messages, system_prompt: nil, tools: nil)
-        base_url = config.local_url
-
-        headers = { 'Content-Type' => 'application/json' }
-        api_key = config.local_api_key
-        if api_key && api_key != 'no-key' && !api_key.empty?
-          headers['Authorization'] = "Bearer #{api_key}"
-        end
-
-        conn = build_connection(base_url, headers)
-
-        formatted = []
-        formatted << { role: 'system', content: system_prompt } if system_prompt
-        formatted.concat(format_messages(messages))
-
-        body = {
-          model: config.resolved_model,
-          max_tokens: config.resolved_max_tokens,
-          messages: formatted
-        }
-        temp = config.resolved_temperature
-        body[:temperature] = temp unless temp.nil?
-        body[:tools] = tools.to_openai_format if tools
+      def api_base
+        config.local_url
+      end
 
-        estimated_input_tokens = estimate_tokens(formatted, system_prompt, tools)
+      def request_headers
+        key = config.local_api_key
+        return {} if key.nil? || key.empty? || key == 'no-key'
+        { 'Authorization' => "Bearer #{key}" }
+      end
 
-        json_body = JSON.generate(body)
-        debug_request("#{base_url}/v1/chat/completions", body)
-        response = conn.post('/v1/chat/completions', json_body)
-        debug_response(response.body)
-        data = parse_response(response)
+      def build_result(data, body:, tools: nil)
         usage = data['usage'] || {}
+        estimated_input_tokens = estimate_tokens(body)
 
         prompt_tokens = usage['prompt_tokens']
         if prompt_tokens && estimated_input_tokens > 0 && prompt_tokens < estimated_input_tokens * 0.5
@@ -50,9 +31,6 @@ module RailsConsoleAi
 
         tool_calls = extract_tool_calls(message)
 
-        # Fallback: some local models (e.g. Ollama) emit tool calls as JSON
-        # in the content field instead of using the structured tool_calls format.
-        # Only match when the JSON "name" is a known tool name to avoid false positives.
         if tool_calls.empty? && tools
           tool_names = tools.to_openai_format.map { |t| t.dig('function', 'name') }.compact
           text_calls = extract_tool_calls_from_text(message['content'], tool_names)
@@ -63,7 +41,7 @@ module RailsConsoleAi
           end
         end
 
-        stop = finish_reason == 'tool_calls' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(finish_reason, %w[tool_calls], %w[length])
 
         ChatResult.new(
           text: message['content'] || '',
@@ -74,10 +52,12 @@ module RailsConsoleAi
         )
       end
 
-      def estimate_tokens(messages, system_prompt, tools)
-        chars = system_prompt.to_s.length
-        messages.each { |m| chars += m[:content].to_s.length + (m[:tool_calls].to_s.length) }
-        chars += tools.to_openai_format.to_s.length if tools
+      def estimate_tokens(body)
+        chars = 0
+        (body[:messages] || []).each do |m|
+          chars += m[:content].to_s.length + (m[:tool_calls].to_s.length)
+        end
+        chars += body[:tools].to_s.length if body[:tools]
         chars / 4
       end
 

data/lib/rails_console_ai/providers/openai.rb

@@ -40,12 +40,35 @@ module RailsConsoleAi
       private
 
       def call_api(messages, system_prompt: nil, tools: nil)
-        conn = build_connection(API_URL, {
-          'Authorization' => "Bearer #{config.resolved_api_key}"
-        })
+        conn = build_connection(api_base, request_headers)
+        body = build_body(messages, system_prompt: system_prompt, tools: tools)
+        debug_request("#{api_base}#{endpoint_path}", body)
+        response = with_retries { conn.post(endpoint_path, JSON.generate(body)) }
+        debug_response(response.body)
+        build_result(parse_response(response), body: body, tools: tools)
+      end
+
+      def api_base
+        API_URL
+      end
+
+      def endpoint_path
+        '/v1/chat/completions'
+      end
 
+      def request_headers
+        { 'Authorization' => "Bearer #{config.resolved_api_key}" }
+      end
+
+      # Overridable: providers that support explicit cache breakpoints emit
+      # multipart content here instead of a bare string.
+      def system_message(system_prompt)
+        { role: 'system', content: system_prompt }
+      end
+
+      def build_body(messages, system_prompt:, tools:)
         formatted = []
-        formatted << { role: 'system', content: system_prompt } if system_prompt
+        formatted << system_message(system_prompt) if system_prompt
         formatted.concat(format_messages(messages))
 
         body = {
@@ -56,12 +79,10 @@ module RailsConsoleAi
         temp = config.resolved_temperature
         body[:temperature] = temp unless temp.nil?
         body[:tools] = tools.to_openai_format if tools
+        body
+      end
 
-        json_body = JSON.generate(body)
-        debug_request("#{API_URL}/v1/chat/completions", body)
-        response = with_retries { conn.post('/v1/chat/completions', json_body) }
-        debug_response(response.body)
-        data = parse_response(response)
+      def build_result(data, body:, tools: nil)
         usage = data['usage'] || {}
 
         choice = (data['choices'] || []).first || {}
@@ -69,7 +90,7 @@ module RailsConsoleAi
         finish_reason = choice['finish_reason']
 
         tool_calls = extract_tool_calls(message)
-        stop = finish_reason == 'tool_calls' ? :tool_use : :end_turn
+        stop = normalize_stop_reason(finish_reason, %w[tool_calls], %w[length])
 
         ChatResult.new(
           text: message['content'] || '',

data/lib/rails_console_ai/providers/openrouter.rb

@@ -0,0 +1,108 @@
+module RailsConsoleAi
+  module Providers
+    class OpenRouter < OpenAI
+      DEFAULT_URL = 'https://openrouter.ai'.freeze
+      ANTHROPIC_MODEL = /anthropic\/|claude/i
+
+      private
+
+      def api_base
+        config.openrouter_url || DEFAULT_URL
+      end
+
+      def endpoint_path
+        '/api/v1/chat/completions'
+      end
+
+      def request_headers
+        h = { 'Authorization' => "Bearer #{config.resolved_api_key}" }
+        h['HTTP-Referer'] = config.openrouter_site_url if config.openrouter_site_url
+        h['X-Title'] = config.openrouter_app_name if config.openrouter_app_name
+        h
+      end
+
+      def build_body(messages, system_prompt:, tools:)
+        body = super
+        # Root-level cache_control is OpenRouter's automatic mode: it places a
+        # breakpoint on the last cacheable block and moves it forward as the
+        # conversation grows, which is what a tool loop needs — otherwise every
+        # round re-bills the whole accumulated history at full input price.
+        body[:cache_control] = cache_control if cache_supported?
+        body[:session_id] = routing_session_id if routing_session_id
+        # OpenRouter only returns usage.cost — the real dollars every cost
+        # readout prefers over an estimate — when the request asks for it.
+        body[:usage] = { include: true }
+        # OpenRouter maps `verbosity` to Anthropic's output_config.effort; its
+        # `reasoning.effort` sets a thinking-token budget instead.
+        effort = config.resolved_effort
+        body[:verbosity] = effort if effort
+        body
+      end
+
+      # The static system prefix gets its own explicit breakpoint so it has a
+      # guaranteed read point no matter what happens later in `messages`; the
+      # automatic breakpoint above then covers the growing tail. OpenRouter
+      # expresses Anthropic breakpoints as OpenAI-style multipart content.
+      def system_message(system_prompt)
+        return super unless cache_supported?
+
+        { role: 'system',
+          content: [{ type: 'text', text: system_prompt, cache_control: cache_control }] }
+      end
+
+      # Same TTL on every breakpoint: entries with the longer TTL must precede
+      # shorter ones, and an explicit marker whose TTL differs from the root-level
+      # field's is rejected outright.
+      def cache_control
+        ttl = config.respond_to?(:resolved_cache_ttl) ? config.resolved_cache_ttl : nil
+        ttl ? { type: 'ephemeral', ttl: ttl } : { type: 'ephemeral' }
+      end
+
+      def build_result(data, body:, tools: nil)
+        raise_inline_error!(data)
+        result = super
+        usage = data['usage'] || {}
+        details = usage['prompt_tokens_details'] || {}
+
+        cache_read = details['cached_tokens'].to_i
+        cache_write = details['cache_write_tokens'].to_i
+        result.cache_read_input_tokens = cache_read
+        result.cache_write_input_tokens = cache_write
+        result.cost = usage['cost']
+
+        # OpenAI-shaped `prompt_tokens` is the WHOLE prompt, cached tokens
+        # included; Anthropic's `input_tokens` is the uncached remainder, and the
+        # engine is built on the Anthropic contract — it reconstructs total prompt
+        # volume as input + cache_read + cache_write for the runaway-loop budget
+        # breakers. Left as sent, a cached round counts twice and those breakers
+        # fire at half the volume they are set to.
+        if result.input_tokens
+          result.input_tokens = [result.input_tokens - cache_read - cache_write, 0].max
+        end
+
+        # Some OpenRouter upstreams return tool calls with a finish_reason of
+        # "stop"; trust the calls over the label. Not when the response was cut
+        # off at the output cap, though — those arguments are half-written, and
+        # promoting them to :tool_use hands the engine a truncated call to run.
+        if result.tool_calls&.any? && !result.truncated?
+          result.stop_reason = :tool_use
+        end
+
+        result
+      end
+
+      def cache_supported?
+        config.resolved_model.to_s.match?(ANTHROPIC_MODEL)
+      end
+
+      def raise_inline_error!(data)
+        err = data['error'] || (data['choices'] || []).first&.dig('error')
+        return unless err
+
+        msg = err.is_a?(Hash) ? (err['message'] || err.to_s) : err.to_s
+        code = err.is_a?(Hash) ? err['code'] : 'unknown'
+        raise ProviderError, "OpenRouter error (#{code}): #{msg}"
+      end
+    end
+  end
+end

data/lib/rails_console_ai/slack_bot.rb

@@ -453,7 +453,7 @@ module RailsConsoleAi
         Thread.current.report_on_exception = false
         Thread.current[:log_prefix] = "[#{channel_id}/#{thread_ts}]#{channel_log_tag(channel_id)} @#{user_name}"
         begin
-          channel.display_status("_session: #{channel_id}/#{thread_ts}_")
+          channel.display_status("_#{session_reference(engine, text, channel_id, thread_ts)}_")
           if restored
             puts "Restored session for thread #{thread_ts} (#{engine.history.length} messages)"
             channel.display_status("_(session restored — continuing from previous conversation)_")
@@ -468,6 +468,32 @@ module RailsConsoleAi
       end
     end
 
+    # A link to the session's page, so whoever is in the thread can find the
+    # transcript later. Falls back to the channel/thread pair the logs are
+    # tagged with when there is no row to link to, or no host to link with.
+    def session_reference(engine, text, channel_id, thread_ts)
+      session_id = engine.ensure_session_record(text)
+      unless session_id
+        return session_reference_fallback(channel_id, thread_ts, "no session row (session_logging off, or the sessions table not found)")
+      end
+
+      url = RailsConsoleAi.session_url(session_id)
+      unless url.start_with?('http')
+        return session_reference_fallback(channel_id, thread_ts, "no host for #{url} (set config.base_url)")
+      end
+
+      "Session ##{session_id}: <#{url}|view transcript>"
+    rescue => e
+      session_reference_fallback(channel_id, thread_ts, "#{e.class}: #{e.message}")
+    end
+
+    # Said on stdout, where the bot's own log goes, so a missing link is explained.
+    # The session thread already prefixes the line with the channel and thread.
+    def session_reference_fallback(channel_id, thread_ts, reason)
+      puts "no session link: #{reason}"
+      "Session: #{channel_id}/#{thread_ts}"
+    end
+
     def restore_from_db(engine, thread_ts)
       require 'rails_console_ai/session_logger'
       saved = SessionLogger.find_by_slack_thread(thread_ts)
@@ -652,14 +678,11 @@ module RailsConsoleAi
       when 'model'
         summary = bang_model(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
-      when 'think'
-        model = engine.upgrade_to_thinking_model
-        post_message(channel: channel_id, thread_ts: thread_ts,
-          text: "Switched to thinking model: `#{model}`")
-      when 'unthink'
-        model = engine.downgrade_from_thinking_model
+      when 'think', 'unthink', 'cheap'
+        tier = { 'think' => :thinking, 'unthink' => :default, 'cheap' => :cheap }[cmd]
+        engine.switch_model_tier(tier)
         post_message(channel: channel_id, thread_ts: thread_ts,
-          text: "Switched to default model: `#{model}`")
+          text: "Switched to #{tier} model: `#{engine.effective_model_label}`")
       when 'context'
         summary = bang_context(engine)
         post_message(channel: channel_id, thread_ts: thread_ts, text: summary)
@@ -678,7 +701,7 @@ module RailsConsoleAi
           end
         end
       else
-        commands = %w[name usage cost model compact think unthink context retry].map { |c| "`!#{c}`" }
+        commands = %w[name usage cost model compact think unthink cheap context retry].map { |c| "`!#{c}`" }
         post_message(channel: channel_id, thread_ts: thread_ts,
           text: "Unknown command `!#{cmd}`. Available: #{commands.join(', ')}")
       end
@@ -705,13 +728,18 @@ module RailsConsoleAi
     def bang_model(engine = nil)
       config = RailsConsoleAi.configuration
       model = engine ? engine.effective_model : config.resolved_model
-      thinking = config.resolved_thinking_model
       pricing = Configuration.pricing_for(model)
+      with_effort = lambda do |m, e|
+        e = Configuration.effort_for(m, e)
+        e ? "`#{m}` (#{e} effort)" : "`#{m}`"
+      end
 
       lines = ["*Model info:*"]
       lines << "  Provider: `#{config.provider}`"
-      lines << "  Model: `#{model}`"
-      lines << "  Thinking model: `#{thinking}`"
+      lines << (engine ? "  Model: `#{engine.effective_model_label}` [#{engine.model_tier}]" : "  Model: `#{model}`")
+      lines << "  Default model: #{with_effort.(config.resolved_model, config.effort)}"
+      lines << "  Thinking model: #{with_effort.(config.resolved_thinking_model, config.thinking_effort)}"
+      lines << "  Cheap model: `#{config.resolved_cheap_model}`"
       lines << "  Max tokens: #{config.resolved_max_tokens}"
       if pricing
         lines << "  Pricing: $#{pricing[:input] * 1_000_000}/M in, $#{pricing[:output] * 1_000_000}/M out"
@@ -737,6 +765,7 @@ module RailsConsoleAi
 
       lines = ["*Cost estimate:*"]
       total_cost = 0.0
+      has_reported_cost = false
 
       token_usage.each do |model, usage|
         pricing = Configuration.pricing_for(model, cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
@@ -744,18 +773,23 @@ module RailsConsoleAi
         input_str = "in: #{usage[:input]}"
         output_str = "out: #{usage[:output]}"
 
-        if pricing
-          cost = (usage[:input] * pricing[:input]) + (usage[:output] * pricing[:output])
+        reported_cost = usage[:cost]
+        if reported_cost && reported_cost > 0
+          has_reported_cost = true
+          total_cost += reported_cost
+          cache_read = usage[:cache_read] || 0
+          cache_write = usage[:cache_write] || 0
+          cache_str = ""
+          cache_str = "  cache r: #{cache_read} w: #{cache_write}" if cache_read > 0 || cache_write > 0
+          lines << "  `#{model}`: #{input_str}  #{output_str}#{cache_str}  $#{'%.4f' % reported_cost}"
+        elsif pricing
+          cost = Configuration.estimate_cost(model,
+            input: usage[:input], output: usage[:output],
+            cache_read: usage[:cache_read] || 0, cache_write: usage[:cache_write] || 0,
+            cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl)
+          total_cost += cost if cost
           cache_read = usage[:cache_read] || 0
           cache_write = usage[:cache_write] || 0
-          if (cache_read > 0 || cache_write > 0) && pricing[:cache_read]
-            # input_tokens excludes cached tokens — bill each bucket at its own
-            # rate rather than discounting cache_read out of input (see
-            # ConversationEngine#display_cost_summary).
-            cost += cache_read * pricing[:cache_read]
-            cost += cache_write * pricing[:cache_write]
-          end
-          total_cost += cost
           cache_str = ""
           cache_str = "  cache r: #{cache_read} w: #{cache_write}" if cache_read > 0 || cache_write > 0
           lines << "  `#{model}`: #{input_str}  #{output_str}#{cache_str}  ~$#{'%.2f' % cost}"
@@ -764,7 +798,8 @@ module RailsConsoleAi
         end
       end
 
-      lines << "*Total: ~$#{'%.2f' % total_cost}*"
+      label = has_reported_cost ? "Total:" : "Total: ~"
+      lines << "*#{label}$#{'%.2f' % total_cost}*"
       lines.join("\n")
     end
 

data/lib/rails_console_ai/slash_commands.rb

@@ -0,0 +1,150 @@
+require 'rails_console_ai/skill_loader'
+require 'rails_console_ai/agent_loader'
+
+module RailsConsoleAi
+  # The union of everything a user can invoke by typing "/" in interactive mode:
+  # the fixed REPL commands, plus every activatable skill and agent, each exposed
+  # under a slug derived from its display name ("Restart user trial" -> /restart-user-trial).
+  #
+  # Backs three surfaces that must agree with each other: the "/" listing, the
+  # completion candidates offered by the line editor, and the dispatcher that
+  # decides what a typed slash command actually does.
+  class SlashCommands
+    Command = Struct.new(:slug, :name, :description, :kind, :record, keyword_init: true) do
+      def builtin?; kind == :builtin; end
+      def skill?;   kind == :skill;   end
+      def agent?;   kind == :agent;   end
+    end
+
+    KIND_LABELS = { builtin: 'command', skill: 'skill', agent: 'agent' }.freeze
+
+    # Slug => one-line help. Order is the order they render in the listing.
+    # Descriptions that depend on live state (auto-execute on/off, safe mode)
+    # are filled in by the channel at render time; these are the static fallbacks.
+    BUILTINS = {
+      'auto'    => 'Toggle auto-execute',
+      'danger'  => 'Toggle safe mode',
+      'safe'    => 'Show safety guard status',
+      'model'   => 'Show provider, model, and pricing info',
+      'think'   => 'Switch to thinking model',
+      'unthink' => 'Switch back to default model',
+      'cheap'   => 'Switch to the cheaper, faster model',
+      'compact' => 'Summarize conversation to reduce context',
+      'usage'   => 'Show session token totals',
+      'cost'    => 'Show cost estimate by model',
+      'name'    => 'Name this session for easy resume',
+      'context' => 'Show conversation history sent to the LLM',
+      'system'  => 'Show the system prompt',
+      'expand'  => 'Show full omitted output',
+      'debug'   => 'Toggle debug summaries',
+      'retry'   => 'Re-execute the last code block'
+    }.freeze
+
+    # "Restart user trial" -> restart-user-trial.
+    #
+    # Close to SkillLoader#skill_key / AgentLoader#agent_key, but kinder to names
+    # that aren't plain prose: those two drop "/" and case boundaries outright,
+    # which turns "Approve/Reject ChangeApprovals" into the unreadable
+    # "approvereject-changeapprovals". Here every boundary a human would read as
+    # a word break becomes a dash. The slug is only ever a handle for typing and
+    # dispatch — file lookup still goes through the loaders — so the two are free
+    # to differ.
+    def self.slugify(name)
+      name.to_s.strip
+        .gsub(%r{[/_\s]+}, '-')                       # separators
+        .gsub(/([a-z0-9])([A-Z])/, '\1-\2')           # fooBar    -> foo-Bar
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')        # HTTPToken -> HTTP-Token
+        .downcase
+        .gsub(/[^a-z0-9-]/, '')
+        .gsub(/-+/, '-')
+        .sub(/\A-/, '').sub(/-\z/, '')
+    end
+
+    def initialize(skill_loader: nil, agent_loader: nil)
+      @skill_loader = skill_loader
+      @agent_loader = agent_loader
+    end
+
+    # Loading skills and agents touches the DB and the filesystem, and completion
+    # runs on every keystroke — so the list is built once and reused until something
+    # that could have changed it (a save_skill/save_agent tool call) finishes.
+    def refresh!
+      @commands = nil
+      self
+    end
+
+    def commands
+      @commands ||= build
+    end
+
+    def skills
+      commands.select(&:skill?)
+    end
+
+    def agents
+      commands.select(&:agent?)
+    end
+
+    # Completion candidates, already "/"-prefixed.
+    def candidates
+      commands.map { |c| "/#{c.slug}" }
+    end
+
+    # [slug, kind label] pairs for the line editor. The label is what lets a Tab
+    # list say which entries are built-in commands and which are skills or agents.
+    def completion_entries
+      commands.map { |c| ["/#{c.slug}", KIND_LABELS[c.kind]] }
+    end
+
+    def find(slug)
+      slug = slug.to_s.sub(%r{\A/}, '').downcase
+      commands.find { |c| c.slug == slug }
+    end
+
+    private
+
+    def build
+      builtins = BUILTINS.map do |slug, desc|
+        Command.new(slug: slug, name: slug, description: desc, kind: :builtin, record: nil)
+      end
+
+      taken = builtins.map(&:slug)
+
+      skills = safe(:skills) do
+        skill_loader.load_activatable_skills.filter_map do |s|
+          slug = self.class.slugify(s['name'])
+          next if slug.empty? || taken.include?(slug)
+          taken << slug
+          Command.new(slug: slug, name: s['name'], description: s['description'], kind: :skill, record: s)
+        end
+      end
+
+      agents = safe(:agents) do
+        agent_loader.load_activatable_agents.filter_map do |a|
+          slug = self.class.slugify(a['name'])
+          next if slug.empty? || taken.include?(slug)
+          taken << slug
+          Command.new(slug: slug, name: a['name'], description: a['description'], kind: :agent, record: a)
+        end
+      end
+
+      builtins + skills.sort_by(&:slug) + agents.sort_by(&:slug)
+    end
+
+    # A broken skill file or an unmigrated database must not take down the prompt.
+    def safe(what)
+      yield
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load #{what} for slash commands: #{e.message}")
+      []
+    end
+
+    def skill_loader
+      @skill_loader ||= SkillLoader.new
+    end
+
+    def agent_loader
+      @agent_loader ||= AgentLoader.new
+    end
+  end
+end

data/lib/rails_console_ai/sub_agent.rb

@@ -10,7 +10,7 @@ module RailsConsoleAi
     LARGE_OUTPUT_THRESHOLD = 10_000
     LARGE_OUTPUT_PREVIEW_CHARS = 8_000
 
-    attr_reader :input_tokens, :output_tokens, :model_used
+    attr_reader :input_tokens, :output_tokens, :model_used, :cost
 
     def initialize(task:, agent_config:, binding_context:, parent_channel:, executor:,
                    output_payload: nil, output_local_name: :output)
@@ -23,6 +23,7 @@ module RailsConsoleAi
       @output_local_name = output_local_name
       @input_tokens = 0
       @output_tokens = 0
+      @cost = 0
       @model_used = nil
     end
 
@@ -83,8 +84,18 @@ module RailsConsoleAi
         end
         @input_tokens += result.input_tokens || 0
         @output_tokens += result.output_tokens || 0
+        @cost += result.cost || 0
 
         break if channel.cancelled?
+
+        # Cut off at the output cap: the tool call it was writing is incomplete
+        # and gets discarded, so the sub-agent would otherwise return whatever
+        # half-sentence preceded it as if that were its finding.
+        if result.truncated?
+          channel.display_warning("  Sub-agent response hit the output-token cap — its result is incomplete.")
+          break
+        end
+
         break unless result.tool_use?
 
         # Display the LLM's reasoning text before executing its tool calls
@@ -152,6 +163,7 @@ module RailsConsoleAi
         result = provider.chat_with_tools(messages, tools: tools, system_prompt: system_prompt)
         @input_tokens += result.input_tokens || 0
         @output_tokens += result.output_tokens || 0
+        @cost += result.cost || 0
       end
 
       text = result&.text.to_s
@@ -181,7 +193,7 @@ module RailsConsoleAi
       config = RailsConsoleAi.configuration
       model_override = @agent_config['model'] || config.sub_agent_model
 
-      if model_override
+      p = if model_override
         config_dup = config.dup
         config_dup.model = model_override
         @model_used = model_override
@@ -190,6 +202,8 @@ module RailsConsoleAi
         @model_used = config.resolved_model
         Providers.build(config)
       end
+      p.routing_session_id = SecureRandom.hex(8) if p.respond_to?(:routing_session_id=)
+      p
     end
 
     def build_system_prompt
@@ -197,6 +211,7 @@ module RailsConsoleAi
       parts << base_instructions unless @agent_config['skip_base_instructions']
       parts << guide_context
       parts << pinned_memory_context
+      parts << memory_context if memory_recall_available?
       parts << @agent_config['body'] if @agent_config['body'] && !@agent_config['body'].strip.empty?
       parts.compact.join("\n\n")
     end
@@ -212,6 +227,9 @@ module RailsConsoleAi
         - Use tools to look up schema/model details rather than guessing.
         - Prefer ActiveRecord query interface over raw SQL.
         - Use describe_model to understand models before querying them.
+        - Check the Memories section below BEFORE investigating. If a memory looks relevant,
+          call recall_memory (by name) or recall_memories (by keyword) to read it, and apply it.
+          Memories record how this app actually works; do not rediscover what one already says.
         - NEVER fabricate URLs, IDs, or data. Always look things up using model methods.
         - When you find methods on a model (e.g. via .methods.grep), USE them rather than
           constructing values manually.
@@ -230,6 +248,21 @@ module RailsConsoleAi
       nil
     end
 
+    # Same memory index the main agent sees, so the sub-agent knows what it can
+    # recall instead of finding out only if it happens to call recall_memories.
+    def memory_context
+      require 'rails_console_ai/context_builder'
+      ContextBuilder.new(RailsConsoleAi.configuration).memory_context
+    end
+
+    # An agent definition can restrict tools; the output-explorer does, to
+    # execute_code alone. Listing memories it cannot recall would only invite
+    # calls to a tool it does not have.
+    def memory_recall_available?
+      allowed = @agent_config['tools']
+      allowed.nil? || Array(allowed).include?('recall_memories')
+    end
+
     def pinned_memory_context
       channel_mode = @parent_channel.respond_to?(:mode) ? @parent_channel.mode : nil
       # For sub-agents spawned from Slack, use the Slack channel's pinned memories.