rails_console_ai 0.30.0 → 0.32.0

data/lib/rails_console_ai/configuration.rb

@@ -1,35 +1,51 @@
-require 'set'
-
 module RailsConsoleAi
   class Configuration
     PROVIDERS = %i[anthropic openai local bedrock].freeze
 
-    # cache_read: 0.1x input, cache_write: 1.25x input for Anthropic models
-    PRICING = {
-      'claude-sonnet-4-6' => { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000, cache_read: 0.30 / 1_000_000, cache_write: 3.75 / 1_000_000 },
-      'claude-opus-4-6'   => { input: 15.0 / 1_000_000, output: 75.0 / 1_000_000, cache_read: 1.50 / 1_000_000, cache_write: 18.75 / 1_000_000 },
-      'claude-haiku-4-5-20251001' => { input: 0.80 / 1_000_000, output: 4.0 / 1_000_000, cache_read: 0.08 / 1_000_000, cache_write: 1.0 / 1_000_000 },
-      # Bedrock model IDs (same pricing as direct API)
-      'us.anthropic.claude-sonnet-4-6' => { input: 3.0 / 1_000_000, output: 15.0 / 1_000_000, cache_read: 0.30 / 1_000_000, cache_write: 3.75 / 1_000_000 },
-      'us.anthropic.claude-opus-4-6-v1' => { input: 15.0 / 1_000_000, output: 75.0 / 1_000_000, cache_read: 1.50 / 1_000_000, cache_write: 18.75 / 1_000_000 },
+    # Per-family model attributes, matched by substring so one entry covers every
+    # ID variant of a family: bare Anthropic IDs (claude-sonnet-5), dated
+    # snapshots (claude-haiku-4-5-20251001), and Bedrock inference profiles
+    # (us.anthropic.claude-sonnet-5, global.anthropic.claude-opus-4-6-v1).
+    #
+    # input/output are $ per MTok (converted to per-token in .pricing_for).
+    # Cache pricing is derived: read = 0.1x input, write = 1.25x input.
+    # temperature: false marks families that reject the `temperature` parameter
+    # (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-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 },
+      'claude-sonnet-5'   => { input: 3.0,  output: 15.0, max_tokens: 16_000, temperature: false },
+      'claude-sonnet-4-6' => { input: 3.0,  output: 15.0, max_tokens: 16_000, temperature: true },
+      'claude-haiku-4-5'  => { input: 1.0,  output: 5.0,  max_tokens: 16_000, temperature: true },
     }.freeze
 
-    DEFAULT_MAX_TOKENS = {
-      'claude-sonnet-4-6' => 16_000,
-      'claude-haiku-4-5-20251001' => 16_000,
-      'claude-opus-4-6'   => 4_096,
-    }.freeze
+    # Family keys sorted longest-first so a more specific family always wins
+    # if keys ever overlap (e.g. a future 'claude-sonnet-5-5' entry would match
+    # before 'claude-sonnet-5').
+    MODEL_FAMILY_KEYS = MODEL_FAMILIES.keys.sort_by { |k| -k.length }.freeze
 
-    # Models that reject the `temperature` parameter. Configuration#resolved_temperature
-    # returns nil for these so providers can omit the field from the request.
-    MODELS_WITHOUT_TEMPERATURE = Set.new(%w[
-      claude-opus-4-7
-      anthropic.claude-opus-4-7
-      us.anthropic.claude-opus-4-7
-      eu.anthropic.claude-opus-4-7
-      jp.anthropic.claude-opus-4-7
-      global.anthropic.claude-opus-4-7
-    ]).freeze
+    # Returns the family attributes for a model ID, or nil for unknown models.
+    def self.model_family(model_id)
+      return nil unless model_id
+      key = MODEL_FAMILY_KEYS.find { |k| model_id.include?(k) }
+      key && MODEL_FAMILIES[key]
+    end
+
+    # Per-token pricing for a model ID, matched by family. Returns
+    # { input:, output:, cache_read:, cache_write: } or nil for unknown models.
+    def self.pricing_for(model_id)
+      family = model_family(model_id)
+      return nil unless family
+      input = family[:input] / 1_000_000
+      {
+        input: input,
+        output: family[:output] / 1_000_000,
+        cache_read: input * 0.1,
+        cache_write: input * 1.25,
+      }
+    end
 
     attr_accessor :provider, :api_key, :model, :thinking_model, :max_tokens,
                   :auto_execute, :temperature,
@@ -176,26 +192,28 @@ module RailsConsoleAi
 
       case @provider
       when :anthropic
-        'claude-sonnet-4-6'
+        'claude-sonnet-5'
       when :openai
         'gpt-5.3-codex'
       when :local
         @local_model
       when :bedrock
-        'us.anthropic.claude-sonnet-4-6'
+        'us.anthropic.claude-sonnet-5'
       end
     end
 
     def resolved_max_tokens
       return @max_tokens if @max_tokens
 
-      DEFAULT_MAX_TOKENS.fetch(resolved_model, 4096)
+      family = self.class.model_family(resolved_model)
+      family ? family[:max_tokens] : 4096
     end
 
-    # Returns nil for models that reject the `temperature` parameter (e.g. opus-4-7).
-    # Providers should use this in place of @temperature.
+    # Returns nil for model families that reject the `temperature` parameter
+    # (opus-4-7+, sonnet-5, fable-5) so providers omit the field from the request.
     def resolved_temperature
-      return nil if MODELS_WITHOUT_TEMPERATURE.include?(resolved_model)
+      family = self.class.model_family(resolved_model)
+      return nil if family && family[:temperature] == false
       @temperature
     end
 
@@ -204,13 +222,13 @@ module RailsConsoleAi
 
       case @provider
       when :anthropic
-        'claude-opus-4-6'
+        'claude-opus-4-8'
       when :openai
         'gpt-5.3-codex'
       when :local
         @local_model
       when :bedrock
-        'us.anthropic.claude-opus-4-6-v1'
+        'us.anthropic.claude-opus-4-8'
       end
     end
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -390,7 +390,7 @@ module RailsConsoleAi
       $stdout.puts "\e[36m  Cost estimate:\e[0m"
 
       @token_usage.each do |model, usage|
-        pricing = Configuration::PRICING[model]
+        pricing = Configuration.pricing_for(model)
         pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
         input_str = "in: #{format_tokens(usage[:input])}"
         output_str = "out: #{format_tokens(usage[:output])}"
@@ -1386,7 +1386,7 @@ module RailsConsoleAi
       cache_w = result.cache_write_input_tokens || 0
       parts << "cache r: #{format_tokens(cache_r)} w: #{format_tokens(cache_w)}" if cache_r > 0 || cache_w > 0
       model = effective_model
-      pricing = Configuration::PRICING[model]
+      pricing = Configuration.pricing_for(model)
       if pricing
         cost = ((result.input_tokens || 0) * pricing[:input]) + ((result.output_tokens || 0) * pricing[:output])
         if (cache_r > 0 || cache_w > 0) && pricing[:cache_read]
@@ -1419,7 +1419,7 @@ module RailsConsoleAi
       input_t = result.input_tokens || 0
       output_t = result.output_tokens || 0
       model = effective_model
-      pricing = Configuration::PRICING[model]
+      pricing = Configuration.pricing_for(model)
       pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
 
       cache_r = result.cache_read_input_tokens || 0

data/lib/rails_console_ai/safety_guards.rb

@@ -52,6 +52,22 @@ module RailsConsoleAi
       Thread.current[:rails_console_ai_guards_disabled] = true
     end
 
+    # Hard sandbox: block ALL database access (reads and writes) for the duration of the
+    # block. Used to fence in sub-agents that must never touch the DB (e.g. the
+    # output-explorer, which only examines an in-memory string). Scoped via thread-local,
+    # so it covers synchronous work in the calling thread and is restored afterward —
+    # nestable, and independent of enable!/disable! and the registered guard set.
+    def with_database_blocked
+      BuiltinGuards.ensure_write_blocker_installed!
+      prev = Thread.current[:rails_console_ai_block_all_db]
+      Thread.current[:rails_console_ai_block_all_db] = true
+      begin
+        yield
+      ensure
+        Thread.current[:rails_console_ai_block_all_db] = prev
+      end
+    end
+
     def empty?
       @guards.empty?
     end
@@ -213,6 +229,21 @@ module RailsConsoleAi
 
       private
 
+      # Hard sandbox: when active, block ALL database access (reads and writes), not just
+      # mutations. Used to fence in sub-agents that must never touch the DB (e.g. the
+      # output-explorer, which only examines an in-memory string). Deliberately does NOT
+      # honor the bypass flag — it is a true wall, not a safe-mode toggle.
+      def rails_console_ai_check_db_blocked!(_sql)
+        return unless Thread.current[:rails_console_ai_block_all_db]
+
+        raise RailsConsoleAi::SafetyError.new(
+          "Database access is disabled here. The captured data is in the `output` " \
+          "variable — examine that instead of querying the database.",
+          guard: :database_access,
+          blocked_key: nil
+        )
+      end
+
       def rails_console_ai_check_write!(sql)
         return if Thread.current[:rails_console_ai_bypass_guards]
         return unless Thread.current[:rails_console_ai_block_writes] && sql.match?(WRITE_PATTERN)
@@ -231,26 +262,31 @@ module RailsConsoleAi
       public
 
       def execute(sql, *args, **kwargs)
+        rails_console_ai_check_db_blocked!(sql)
         rails_console_ai_check_write!(sql)
         super
       end
 
       def exec_query(sql, *args, **kwargs)
+        rails_console_ai_check_db_blocked!(sql)
         rails_console_ai_check_write!(sql)
         super
       end
 
       def exec_insert(sql, *args, **kwargs)
+        rails_console_ai_check_db_blocked!(sql)
         rails_console_ai_check_write!(sql)
         super
       end
 
       def exec_delete(sql, *args, **kwargs)
+        rails_console_ai_check_db_blocked!(sql)
         rails_console_ai_check_write!(sql)
         super
       end
 
       def exec_update(sql, *args, **kwargs)
+        rails_console_ai_check_db_blocked!(sql)
         rails_console_ai_check_write!(sql)
         super
       end

data/lib/rails_console_ai/session_logger.rb

@@ -28,6 +28,10 @@ module RailsConsoleAi
         create_attrs[:status]            = attrs[:status]            if attrs.key?(:status)
         create_attrs[:result]            = attrs[:result]            if attrs.key?(:result)
         create_attrs[:error_message]     = attrs[:error_message]     if attrs.key?(:error_message)
+        if attrs.key?(:options)
+          opts = attrs[:options]
+          create_attrs[:options] = opts.is_a?(String) ? opts : opts.to_json
+        end
         record = session_class.create!(create_attrs)
         record.id
       rescue => e

data/lib/rails_console_ai/skill_loader.rb

@@ -122,15 +122,10 @@ module RailsConsoleAi
       key = skill_key(name)
       existing = load_skill_file(key)
 
-      frontmatter = {
-        'name' => name,
-        'description' => description,
-        'tags' => Array(tags)
-      }
-      bypasses = Array(bypass_guards_for_methods)
-      frontmatter['bypass_guards_for_methods'] = bypasses unless bypasses.empty?
-
-      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
+      content = self.class.dump(
+        name: name, description: description, body: body,
+        tags: tags, bypass_guards_for_methods: bypass_guards_for_methods
+      )
       @storage.write(key, content)
 
       path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
@@ -190,5 +185,19 @@ module RailsConsoleAi
     rescue Psych::SyntaxError
       nil
     end
+
+    # Inverse of parse: emit a canonical .md (frontmatter + body) string from
+    # structured attrs. Used by AI tool callers and file-fallback writers so
+    # the on-disk and DB representations stay byte-identical.
+    def self.dump(name:, description:, body:, tags: [], bypass_guards_for_methods: [])
+      frontmatter = {
+        'name' => name,
+        'description' => description,
+        'tags' => Array(tags)
+      }
+      bypasses = Array(bypass_guards_for_methods)
+      frontmatter['bypass_guards_for_methods'] = bypasses unless bypasses.empty?
+      "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
+    end
   end
 end

data/lib/rails_console_ai/slack_bot.rb

@@ -706,7 +706,7 @@ module RailsConsoleAi
       config = RailsConsoleAi.configuration
       model = engine ? engine.effective_model : config.resolved_model
       thinking = config.resolved_thinking_model
-      pricing = Configuration::PRICING[model]
+      pricing = Configuration.pricing_for(model)
 
       lines = ["*Model info:*"]
       lines << "  Provider: `#{config.provider}`"
@@ -739,7 +739,7 @@ module RailsConsoleAi
       total_cost = 0.0
 
       token_usage.each do |model, usage|
-        pricing = Configuration::PRICING[model]
+        pricing = Configuration.pricing_for(model)
         pricing ||= { input: 0.0, output: 0.0 } if RailsConsoleAi.configuration.provider == :local
         input_str = "in: #{usage[:input]}"
         output_str = "out: #{usage[:output]}"

data/lib/rails_console_ai/storage/database_storage.rb

@@ -68,14 +68,12 @@ module RailsConsoleAi
         record = RailsConsoleAi::Skill.where('LOWER(name) = ?', name.to_s.downcase).first
         record ||= RailsConsoleAi::Skill.new
         was_new = record.new_record?
+        content = RailsConsoleAi::SkillLoader.dump(
+          name: name, description: description, body: body,
+          tags: tags, bypass_guards_for_methods: bypass_guards_for_methods
+        )
         record.update_with_version!(
-          {
-            name:                      name,
-            description:               description,
-            body:                      body,
-            tags:                      Array(tags),
-            bypass_guards_for_methods: Array(bypass_guards_for_methods)
-          },
+          { content: content },
           edited_by: edited_by,
           change_note: change_note
         )
@@ -114,12 +112,11 @@ module RailsConsoleAi
         record = RailsConsoleAi::Memory.where('LOWER(name) = ?', name.to_s.downcase).first
         record ||= RailsConsoleAi::Memory.new
         was_new = record.new_record?
+        content = RailsConsoleAi::Tools::MemoryTools.dump(
+          name: name, description: description, tags: tags
+        )
         record.update_with_version!(
-          {
-            name:        name,
-            description: description,
-            tags:        Array(tags)
-          },
+          { content: content },
           edited_by: edited_by,
           change_note: change_note
         )
@@ -158,15 +155,12 @@ module RailsConsoleAi
         record = RailsConsoleAi::Agent.where('LOWER(name) = ?', name.to_s.downcase).first
         record ||= RailsConsoleAi::Agent.new
         was_new = record.new_record?
+        content = RailsConsoleAi::AgentLoader.dump(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: tools
+        )
         record.update_with_version!(
-          {
-            name:        name,
-            description: description,
-            body:        body,
-            max_rounds:  max_rounds,
-            model:       model,
-            tools:       Array(tools)
-          },
+          { content: content },
           edited_by: edited_by,
           change_note: change_note
         )

data/lib/rails_console_ai/sub_agent.rb

@@ -189,7 +189,7 @@ module RailsConsoleAi
 
     def build_system_prompt
       parts = []
-      parts << base_instructions
+      parts << base_instructions unless @agent_config['skip_base_instructions']
       parts << guide_context
       parts << pinned_memory_context
       parts << @agent_config['body'] if @agent_config['body'] && !@agent_config['body'].strip.empty?

data/lib/rails_console_ai/tools/memory_tools.rb

@@ -33,10 +33,15 @@ module RailsConsoleAi
             name: name, description: description, tags: tags,
             edited_by: edited_by || 'ai', change_note: change_note
           )
+          status_note = if record.respond_to?(:proposed?) && record.proposed?
+                          ' — status: PROPOSED. A human must approve it at /rails_console_ai/memories before you can recall it.'
+                        else
+                          ''
+                        end
           if was_new
-            "Memory saved (db): \"#{record.name}\" (id=#{record.id})"
+            "Memory saved (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
           else
-            "Memory updated (db): \"#{record.name}\" (id=#{record.id})"
+            "Memory updated (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
           end
         end
       rescue Storage::StorageError => e
@@ -72,8 +77,16 @@ module RailsConsoleAi
       end
 
       def recall_memory(name:)
-        memory = load_all_memories.find { |m| m['name'].to_s.downcase == name.to_s.downcase }
-        return "No memory found: \"#{name}\"" unless memory
+        memory = load_activatable_memories.find { |m| m['name'].to_s.downcase == name.to_s.downcase }
+        unless memory
+          # Distinguish "doesn't exist" from "exists but isn't approved yet".
+          proposed = load_all_memories.find { |m| m['name'].to_s.downcase == name.to_s.downcase }
+          if proposed && proposed['source'] == :db && proposed['status'] != 'approved'
+            return "Memory \"#{name}\" exists but is awaiting human approval and cannot be recalled yet. " \
+                   "Ask the user to approve it in the web UI at /rails_console_ai/memories."
+          end
+          return "No memory found: \"#{name}\""
+        end
 
         record_use(memory)
 
@@ -83,7 +96,7 @@ module RailsConsoleAi
       end
 
       def recall_memories(query: nil, tag: nil)
-        memories = load_all_memories
+        memories = load_activatable_memories
         return "No memories stored yet." if memories.empty?
 
         results = memories
@@ -117,7 +130,7 @@ module RailsConsoleAi
       end
 
       def memory_summaries
-        memories = load_all_memories
+        memories = load_activatable_memories
         return nil if memories.empty?
 
         memories.map { |m|
@@ -127,6 +140,10 @@ module RailsConsoleAi
         }
       end
 
+      # Includes proposed (unapproved) DB memories — they show up in the admin UI
+      # with a "PROPOSED" badge. The AI-facing surface (#memory_summaries,
+      # #recall_memory, #recall_memories) filters them out via
+      # #load_activatable_memories, so an unapproved memory can never be recalled.
       def load_all_memories
         db = Storage::DatabaseStorage.all_memories
         file = load_all_file_memories
@@ -135,6 +152,12 @@ module RailsConsoleAi
         (db + file).sort_by { |m| m['name'].to_s.downcase }
       end
 
+      # Memories the AI is allowed to see / recall: approved DB memories + all file
+      # memories. File memories are considered pre-approved because they're git-tracked.
+      def load_activatable_memories
+        load_all_memories.reject { |m| m['source'] == :db && m['status'] != 'approved' }
+      end
+
       private
 
       # DB-backed memories only — file memories have no row to update.
@@ -211,6 +234,14 @@ module RailsConsoleAi
         nil
       end
 
+      # Inverse of parse: emit a canonical .md string. The DB store uses this
+      # minimal form (name + tags only in frontmatter); the file store layers
+      # created_at/updated_at on top via save_memory_to_file.
+      def self.dump(name:, description:, tags: [])
+        frontmatter = { 'name' => name, 'tags' => Array(tags) }
+        "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{description}\n"
+      end
+
       def find_memory_key_by_name(name)
         keys = @storage.list("#{MEMORIES_DIR}/*.md")
         keys.find do |key|

data/lib/rails_console_ai/tools/registry.rb

@@ -338,19 +338,27 @@ module RailsConsoleAi
         'name' => 'output-explorer',
         'tools' => ['execute_code'],
         'max_rounds' => 8,
+        'skip_base_instructions' => true,
         'body' => <<~PROMPT.freeze
-          You are exploring a single chunk of captured tool output on behalf of the main assistant.
+          You are exploring a single chunk of already-captured tool output on behalf of the
+          main assistant. Your ONLY job is to answer a question about that captured text.
 
           The full output is bound to the local variable `output` (a String). You do NOT see it
-          directly — it lives in Ruby memory. Use `execute_code` with Ruby to query it:
+          directly — it lives in Ruby memory. Use `execute_code` with Ruby to examine it:
             - `output.length`, `output.lines.count`
             - `output[start, len]`, `output.lines[n]`
             - `output.scan(/pattern/)`, `output.include?("...")`
             - `JSON.parse(output)` if it looks like JSON, then drill in
             - any other Ruby string/collection methods
 
-          Print only the specific slice or summary the task requires — never dump the whole `output`.
-          Return a concise factual answer. No preamble.
+          Database / ActiveRecord access is DISABLED in this context — any DB query (e.g.
+          `SomeModel.where(...)`, `.find`, raw SQL) will be blocked and raise an error. The data
+          you need exists ONLY in the `output` String already in memory. Do not load models, do
+          not run queries, and do not try to "look up" anything — every fact must come from
+          examining `output`.
+
+          Print only the specific slice or summary the task requires — never dump the whole
+          `output`. Return a concise factual answer. No preamble.
         PROMPT
       }.freeze
 
@@ -368,7 +376,11 @@ module RailsConsoleAi
           executor: @executor,
           output_payload: payload.dup
         )
-        result = sub.run
+        # Hard sandbox: the output-explorer only examines the in-memory `output` string.
+        # Block all DB access for the duration of its run so a stray query can't escape to
+        # the live database. Scoped via thread-local (explore_output runs synchronously),
+        # so the parent session's guard state is untouched.
+        result = RailsConsoleAi.configuration.safety_guards.with_database_blocked { sub.run }
         @last_sub_agent_usage = { input: sub.input_tokens, output: sub.output_tokens, model: sub.model_used }
         "Exploration result (#{sub.input_tokens + sub.output_tokens} tokens used, #{payload.length} chars explored):\n#{result}"
       end
@@ -418,7 +430,7 @@ module RailsConsoleAi
 
         register(
           name: 'save_memory',
-          description: 'Save a fact or pattern you learned about this codebase for future sessions. Use after discovering how something works (e.g. sharding, auth, custom business logic). Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/memories directory instead.',
+          description: 'Save a fact or pattern you learned about this codebase for future sessions. Use after discovering how something works (e.g. sharding, auth, custom business logic). Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/memories directory instead. IMPORTANT: memories saved to the DB start in "proposed" state and must be approved by a human in the web UI before you can recall them. Edits to an approved memory also revert it to proposed. Tell the user to visit /rails_console_ai/memories to approve.',
           parameters: {
             'type' => 'object',
             'properties' => {

data/lib/rails_console_ai/version.rb

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