rails_console_ai 0.31.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '083adc4ffd8b69f950fbc4ab18f2ac056e8642c6946c8ba46e67e19e4299e0f2'
-  data.tar.gz: a01fef0fe45dfa157d638a7d4edb1ee5c8d9753be3a79956b3ebde220d3ee939
+  metadata.gz: 7eab1fd8d3a5c8c7a228206f0c723bfa845fa2d344471e0251659658c0c5e571
+  data.tar.gz: c607b6cfa9e6834612513f0c75dc1303386f79bcdd96bba203a4fb5d0549f32b
 SHA512:
-  metadata.gz: 56b8fdcd0cf445d9480d4e56e252271241af017c8ca51e2a11af36d2158ce4a3a1fdf9670685f931b8cbd0994e6828e6bac08d10247e8bec1af8c66ad83c47f4
-  data.tar.gz: 6ccb72b8b8e9b157b28722d1e532d2abf5df8037f4ba4f1f3635bb37ad8a3441e48d832d903f6f92b6dce80106082215368dde15626eb0fc41d93da60100f261
+  metadata.gz: 1acd49dcf3370eaab8a8fb8ef77c7dad4746fcb0e0eb2f78935b53c870228a9b53a2cef8dc82608ed94f5f2642de905070fe9e241e9a98d8f408653535ce30d7
+  data.tar.gz: bd7ec6fcf50788b45f47f6a7b1948a74fb83cf4ff7fba62687eb2d6e8c75743972f4e83525d87f57096c1a6cd114611a69c5b6e2299a88dea6b02063cdf09adc

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [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
+- Add an abort mechanism for background sub-agents
+- Require human approval before AI-proposed memory changes take effect
+- Keep `explore_output` focused on exploring a previous command's output instead of spinning off into database reads
+- Fix loading `ApplicationController` under the classic autoloader
+
 ## [0.31.0]
 
 - Simplify DB-backed skills, sub-agents, and memories to a single content field per record, replacing the separate frontmatter/body columns and streamlining the models, controllers, and forms
@@ -22,32 +30,6 @@ All notable changes to this project will be documented in this file.
 - Harden `Skill` / `Agent` model accessors to return safe defaults when newly added columns are not yet present
 - Fix built-in agent `.md` files with UTF-8 characters failing to load under US-ASCII locales
 
-## [Unreleased]
-
-- New skill / memory / agent pages now have a "Paste a .md file" textarea at the top. Paste the contents of a Markdown file with YAML frontmatter (same format used by `.rails_console_ai/{skills,memories,agents}/*.md` and the gem's built-in agents), click "Parse pasted content ↓", and the form fields below are prefilled from the parse. You still click Create to actually save, so the normal proposed-status + version-row flow applies — and you can tweak the parsed content before saving. Useful for moving an existing on-disk record into the versioned DB store
-- `RailsConsoleAi::SkillLoader.parse`, `RailsConsoleAi::AgentLoader.parse`, and `RailsConsoleAi::Tools::MemoryTools.parse` are now public class methods. They return a parsed frontmatter+body hash, or `nil` on malformed input
-
-- Usage tracking for DB-backed skills, memories, and agents. New `use_count` and `last_used_at` columns are bumped atomically (one SQL `UPDATE … SET use_count = use_count + 1, last_used_at = NOW()`, no callbacks, no `updated_at` change) when:
-  - `activate_skill` resolves a DB skill
-  - `recall_memory` resolves a DB memory, or `recall_memories` returns a DB memory in its result set
-  - `delegate_task` resolves a DB sub-agent
-  File / built-in records have no DB row so they're not tracked (the web UI shows `—` for them). System-prompt summary inclusion does **not** count — counters only move when the AI actively invokes/loads the record. Surfaced in the index tables (with a "Sort: most used" toggle) and on each show page (Times activated / Times recalled / Times invoked, plus Last used)
-- Bugfix: `RailsConsoleAi.migrate!` now always re-runs the `setup_*_tables!` methods so column-add probes execute on upgrades. Previously, when the base table already existed, the outer `unless table_exists?` guard skipped column probes entirely, leaving new columns un-added and causing `NameError: undefined local variable or method 'status'` from `Skill#proposed?` on host apps that hadn't fully migrated
-- Bugfix: `Skill` / `Agent` model accessors for `status` / `approved_by` / `approved_at` / `use_count` / `last_used_at` are now defensive — they return safe defaults via `has_attribute?` rather than raising NameError when the column hasn't been added yet. The `status` inclusion validation is also gated on the column being present
-
-- Sub-agents can now be stored in the database, versioned, and approved through the web UI — same workflow as skills. DB-backed agents start as `proposed` and are invisible to `delegate_task` until a human clicks Approve at `/rails_console_ai/agents`; editing an approved agent reverts it to proposed. Built-in (gem-shipped) and file-based agents are pre-approved and continue working unchanged
-- New AI tools `save_agent` and `delete_agent` — the AI can now draft a sub-agent definition (lands as proposed, awaits human approval) and request deletion. `delegate_task` now emits a specific "awaiting human approval" error when the AI references a proposed DB agent
-- New web UI section at `/rails_console_ai/agents` with three-source listing (DB / FILE / BUILTIN badges) plus the full skills-style CRUD + version history + diff + restore + approve. Built-in agents are read-only with a "Create DB override" link that prefills the new-agent form
-- `ai_db_setup` / `ai_db_migrate` now also create `rails_console_ai_agents` and `rails_console_ai_agent_versions` tables idempotently
-- Fix: built-in agent .md files containing UTF-8 (em-dashes, smart quotes) now load correctly. `safe_load_builtin_agents` was using `File.read`'s locale-default encoding, which silently swallowed `Encoding::CompatibilityError` on US-ASCII locales
-
-- Skills and memories can now be stored in the database (in addition to the existing on-disk `.rails_console_ai/skills` and `.rails_console_ai/memories` files). DB-backed records are versioned — every save creates a `SkillVersion` / `MemoryVersion` row with `edited_by` and an optional change note
-- DB-backed skills start in a **proposed** state and cannot be activated by the AI until a human approves them in the web UI. Editing an approved skill reverts it to proposed. File-backed skills are unaffected (already git-tracked, considered pre-approved). Memories are not gated
-- `SkillLoader#load_all_skills` and `MemoryTools#load_all_memories` now return the union of DB and file records (DB wins on name collision). `SkillLoader#find_skill` / `skill_summaries` filter out proposed skills so the AI never sees them
-- `save_skill` / `save_memory` AI tools accept an optional `target` parameter (`"db"` default, `"file"` to write to disk) plus `change_note`. When the AI saves a DB skill, the tool response tells it the skill is awaiting human approval
-- New web UI sections at `/rails_console_ai/skills` and `/rails_console_ai/memories` provide list, view, create, edit, delete, version history, side-by-side diff, and restore. Skills also have an Approve button and PROPOSED / APPROVED badges. File-sourced records are surfaced but read-only in the UI
-- `ai_db_setup` / `ai_db_migrate` now create the new `rails_console_ai_skills`, `rails_console_ai_skill_versions`, `rails_console_ai_memories`, and `rails_console_ai_memory_versions` tables idempotently, plus the `status` / `approved_by` / `approved_at` columns on skills
-
 ## [0.29.0]
 
 - Allow steering Slack conversations mid-run by sending follow-up messages that are folded in as user guidance at the next tool-loop boundary

data/README.md

@@ -291,7 +291,7 @@ RailsConsoleAi.configure do |config|
 end
 ```
 
-Default model: `claude-sonnet-4-6`. Thinking model: `claude-opus-4-6`. Prompt caching is enabled automatically.
+Default model: `claude-sonnet-5`. Thinking model: `claude-opus-4-8`. Prompt caching is enabled automatically.
 
 ### OpenAI
 
@@ -317,8 +317,8 @@ gem 'aws-sdk-bedrockruntime'
 RailsConsoleAi.configure do |config|
   config.provider = :bedrock
   config.bedrock_region = 'us-east-1'
-  # config.model = 'us.anthropic.claude-sonnet-4-6'           # default
-  # config.thinking_model = 'us.anthropic.claude-opus-4-6-v1' # default
+  # config.model = 'us.anthropic.claude-sonnet-5'        # default
+  # config.thinking_model = 'us.anthropic.claude-opus-4-8' # default
 end
 ```
 
@@ -365,25 +365,25 @@ Before adopting a new Claude model, smoke-test it against the Anthropic or Bedro
 
 ```bash
 # Anthropic — provider inferred from the `claude-` prefix
-ANTHROPIC_API_KEY=sk-ant-... bin/smoke_model.rb --model claude-opus-4-7
+ANTHROPIC_API_KEY=sk-ant-... bin/smoke_model.rb --model claude-opus-4-8
 
 # Bedrock — provider inferred from the regional `us.anthropic.` prefix.
 # Requires the aws-sdk-bedrockruntime gem and AWS credentials in the environment.
-bin/smoke_model.rb --model us.anthropic.claude-opus-4-7
+bin/smoke_model.rb --model us.anthropic.claude-opus-4-8
 
 # Bedrock in another region
-bin/smoke_model.rb --model eu.anthropic.claude-opus-4-7 --region eu-west-1
+bin/smoke_model.rb --model eu.anthropic.claude-opus-4-8 --region eu-west-1
 
 # Subset of checks, e.g. when iterating on cache behavior
-bin/smoke_model.rb --model claude-sonnet-4-6 --checks cache
+bin/smoke_model.rb --model claude-sonnet-5 --checks cache
 
 # Force a provider when the model ID is ambiguous
-bin/smoke_model.rb --provider anthropic --model claude-opus-4-7
+bin/smoke_model.rb --provider anthropic --model claude-opus-4-8
 ```
 
 `DEBUG=1` enables the providers' raw request/response logging.
 
-If the model rejects a parameter the gem sends by default (e.g. opus-4-7 deprecated `temperature`), add the model ID to `Configuration::MODELS_WITHOUT_TEMPERATURE` in `lib/rails_console_ai/configuration.rb` so the providers omit the field.
+Pricing, default max tokens, and parameter support (e.g. which families reject `temperature`) are keyed by model family in `Configuration::MODEL_FAMILIES` (`lib/rails_console_ai/configuration.rb`). Family matching is by substring, so one entry covers bare IDs, dated snapshots, and Bedrock inference profiles (`us.` / `global.` prefixes). When adopting a new model family, add an entry there and smoke-test it.
 
 ## Configuration
 
@@ -513,12 +513,17 @@ id = RailsConsoleAi.run_agent("How many users signed up yesterday?", name: 'dail
 # => 4821 (Integer session id, returned immediately)
 
 RailsConsoleAi.check_agent(id)
-# => 'queued' | 'running' | 'ready' | 'failed' | nil
+# => 'queued' | 'running' | 'ready' | 'failed' | 'aborted' | nil
 
 RailsConsoleAi.get_agent_response(id)
 # => { status: 'ready', result: "1,432 users signed up yesterday.\n", error: nil }
+
+RailsConsoleAi.abort_agent(id)
+# => true (aborted) | false (already finished, or unknown id)
 ```
 
+`abort_agent` cancels a run: a queued run is never picked up, and a run already executing keeps going but its result is discarded when it completes -- the session stays `status='aborted'`.
+
 `run_agent` enqueues a row in the sessions table with `mode='agent_api'` and `status='queued'`. A separate long-running rake task picks them up and runs each in its own thread using the same engine that powers `ai "..."` in the console.
 
 ### Per-run options

data/app/controllers/rails_console_ai/agent_versions_controller.rb

@@ -1,5 +1,5 @@
 module RailsConsoleAi
-  class AgentVersionsController < ApplicationController
+  class AgentVersionsController < RailsConsoleAi::ApplicationController
     before_action :load_agent
 
     def index

data/app/controllers/rails_console_ai/agents_controller.rb

@@ -1,7 +1,7 @@
 require 'rails_console_ai/agent_loader'
 
 module RailsConsoleAi
-  class AgentsController < ApplicationController
+  class AgentsController < RailsConsoleAi::ApplicationController
     before_action :load_agent, only: [:show, :edit, :update, :destroy, :approve]
 
     def index

data/app/controllers/rails_console_ai/memories_controller.rb

@@ -1,8 +1,8 @@
 require 'rails_console_ai/tools/memory_tools'
 
 module RailsConsoleAi
-  class MemoriesController < ApplicationController
-    before_action :load_memory, only: [:show, :edit, :update, :destroy]
+  class MemoriesController < RailsConsoleAi::ApplicationController
+    before_action :load_memory, only: [:show, :edit, :update, :destroy, :approve]
 
     def index
       @memories = Tools::MemoryTools.new.load_all_memories
@@ -73,6 +73,26 @@ module RailsConsoleAi
       end
     end
 
+    def approve
+      redirect_to memories_path, alert: file_memory_message and return unless @memory.is_a?(RailsConsoleAi::Memory)
+
+      approver = params[:approved_by].presence ||
+                 (request.respond_to?(:remote_user) && request.remote_user.presence) ||
+                 'web'
+
+      if @memory.approved?
+        redirect_to memory_path(@memory), notice: 'Memory is already approved.'
+        return
+      end
+
+      begin
+        @memory.approve!(approved_by: approver)
+        redirect_to memory_path(@memory), notice: "Approved by #{approver}. The AI can now recall this memory."
+      rescue ArgumentError, ActiveRecord::RecordInvalid => e
+        redirect_to memory_path(@memory), alert: "Could not approve: #{e.message}"
+      end
+    end
+
     def diff
       @memory = Memory.find(params[:memory_id])
       @from = @memory.versions.find(params[:from])

data/app/controllers/rails_console_ai/memory_versions_controller.rb

@@ -1,5 +1,5 @@
 module RailsConsoleAi
-  class MemoryVersionsController < ApplicationController
+  class MemoryVersionsController < RailsConsoleAi::ApplicationController
     before_action :load_memory
 
     def index

data/app/controllers/rails_console_ai/sessions_controller.rb

@@ -1,5 +1,5 @@
 module RailsConsoleAi
-  class SessionsController < ApplicationController
+  class SessionsController < RailsConsoleAi::ApplicationController
     PER_PAGE = 50
 
     def index

data/app/controllers/rails_console_ai/skill_versions_controller.rb

@@ -1,5 +1,5 @@
 module RailsConsoleAi
-  class SkillVersionsController < ApplicationController
+  class SkillVersionsController < RailsConsoleAi::ApplicationController
     before_action :load_skill
 
     def index

data/app/controllers/rails_console_ai/skills_controller.rb

@@ -1,7 +1,7 @@
 require 'rails_console_ai/skill_loader'
 
 module RailsConsoleAi
-  class SkillsController < ApplicationController
+  class SkillsController < RailsConsoleAi::ApplicationController
     before_action :load_skill, only: [:show, :edit, :update, :destroy, :approve]
 
     def index

data/app/models/rails_console_ai/memory.rb

@@ -4,6 +4,10 @@ module RailsConsoleAi
   class Memory < ActiveRecord::Base
     self.table_name = 'rails_console_ai_memories'
 
+    STATUS_PROPOSED = 'proposed'.freeze
+    STATUS_APPROVED = 'approved'.freeze
+    STATUSES = [STATUS_PROPOSED, STATUS_APPROVED].freeze
+
     has_many :versions,
              -> { order(created_at: :desc) },
              class_name: 'RailsConsoleAi::MemoryVersion',
@@ -12,11 +16,14 @@ module RailsConsoleAi
 
     validates :content, presence: true
     validates :name, presence: true, uniqueness: { case_sensitive: false }
+    validates :status, inclusion: { in: STATUSES }
     validate  :content_parses
 
     before_validation :sync_name_from_content
 
     scope :alphabetical, -> { order(Arel.sql('LOWER(name)')) }
+    scope :approved, -> { where(status: STATUS_APPROVED) }
+    scope :proposed, -> { where(status: STATUS_PROPOSED) }
 
     def self.connection
       klass = RailsConsoleAi.configuration.connection_class
@@ -42,6 +49,9 @@ module RailsConsoleAi
     def description; parsed['description']; end
     def tags;        Array(parsed['tags']); end
 
+    def proposed?; status.to_s == STATUS_PROPOSED; end
+    def approved?; status.to_s == STATUS_APPROVED; end
+
     def self.record_use!(id)
       where(id: id).update_all([
         'use_count = COALESCE(use_count, 0) + 1, last_used_at = ?',
@@ -60,6 +70,9 @@ module RailsConsoleAi
         'description'  => description,
         'tags'         => tags,
         'content'      => content,
+        'status'       => status,
+        'approved_by'  => approved_by,
+        'approved_at'  => approved_at,
         'use_count'    => use_count,
         'last_used_at' => last_used_at,
         'source'       => :db,
@@ -67,14 +80,25 @@ module RailsConsoleAi
       }
     end
 
-    def update_with_version!(attrs, edited_by: nil, change_note: nil)
+    # Assigns attrs, saves, and records one MemoryVersion snapshot.
+    # Any change to `content` reverts approval back to "proposed" unless
+    # `preserve_approval: true` is passed (approve! does this).
+    def update_with_version!(attrs, edited_by: nil, change_note: nil, preserve_approval: false)
       transaction do
         assign_attributes(attrs)
+
+        if !preserve_approval && approved? && changes.key?('content')
+          self.status      = STATUS_PROPOSED
+          self.approved_by = nil
+          self.approved_at = nil
+        end
+
         save!
         RailsConsoleAi::MemoryVersion.create!(
           memory_id:   id,
           name:        name,
           content:     content,
+          status:      status,
           edited_by:   edited_by,
           change_note: change_note
         )
@@ -82,6 +106,21 @@ module RailsConsoleAi
       self
     end
 
+    def approve!(approved_by:)
+      raise ArgumentError, 'approved_by is required' if approved_by.to_s.strip.empty?
+
+      update_with_version!(
+        {
+          status:      STATUS_APPROVED,
+          approved_by: approved_by,
+          approved_at: Time.now.utc
+        },
+        edited_by: approved_by,
+        change_note: "Approved by #{approved_by}",
+        preserve_approval: true
+      )
+    end
+
     private
 
     def sync_name_from_content

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

@@ -11,6 +11,13 @@
   </form>
 </div>
 
+<% proposed_count = @memories.count { |m| m['source'] == :db && m['status'] != 'approved' } %>
+<% if proposed_count > 0 %>
+  <div class="flash flash-alert" style="margin-bottom:16px;">
+    <strong><%= proposed_count %></strong> memor<%= proposed_count == 1 ? 'y' : 'ies' %> awaiting approval. The AI cannot recall them until a human approves.
+  </div>
+<% end %>
+
 <% if @memories.empty? %>
   <div class="meta-card">
     <p class="text-muted">No memories yet. <%= link_to 'Create one', new_memory_path %> or drop a Markdown file in <code>.rails_console_ai/memories/</code>.</p>
@@ -22,7 +29,7 @@
         <th>Name</th>
         <th>Description</th>
         <th>Tags</th>
-        <th>Source</th>
+        <th>Source / Status</th>
         <th title="Number of times the AI recalled this memory (DB only)">Uses</th>
         <th>Last used</th>
         <th></th>
@@ -40,6 +47,11 @@
           <td>
             <% if m['source'] == :db %>
               <span class="badge source-db">DB</span>
+              <% if m['status'] == 'approved' %>
+                <span class="badge status-approved">APPROVED</span>
+              <% else %>
+                <span class="badge status-proposed">PROPOSED</span>
+              <% end %>
             <% else %>
               <span class="badge source-file">FILE</span>
             <% end %>

data/app/views/rails_console_ai/memories/show.html.erb

@@ -8,11 +8,23 @@
 
 <%= link_to '← All memories', memories_path, class: 'back-link' %>
 
+<% if is_db && !@memory.approved? %>
+  <div class="flash flash-alert" style="margin-bottom:16px;">
+    <strong>Awaiting approval.</strong> The AI cannot recall this memory until a human approves it.
+    Review the content below, then click <strong>Approve</strong>.
+  </div>
+<% end %>
+
 <div class="meta-card">
   <h2 style="margin-bottom:8px;">
     <%= name %>
     <% if is_db %>
       <span class="badge source-db">DB</span>
+      <% if @memory.approved? %>
+        <span class="badge status-approved">APPROVED</span>
+      <% else %>
+        <span class="badge status-proposed">PROPOSED</span>
+      <% end %>
     <% else %>
       <span class="badge source-file">FILE</span>
     <% end %>
@@ -24,6 +36,10 @@
       <div class="meta-item"><label>Versions</label><span><%= @memory.versions.count %></span></div>
       <div class="meta-item"><label>Times recalled</label><span><%= @memory.use_count %></span></div>
       <div class="meta-item"><label>Last recalled</label><span><%= @memory.last_used_at&.strftime('%Y-%m-%d %H:%M') || 'never' %></span></div>
+      <% if @memory.approved? %>
+        <div class="meta-item"><label>Approved by</label><span><%= @memory.approved_by || '—' %></span></div>
+        <div class="meta-item"><label>Approved at</label><span><%= @memory.approved_at&.strftime('%Y-%m-%d %H:%M') || '—' %></span></div>
+      <% end %>
     <% else %>
       <div class="meta-item"><label>Path</label><span class="mono"><%= file_key %></span></div>
     <% end %>
@@ -32,6 +48,12 @@
 
 <div class="btn-bar">
   <% if is_db %>
+    <% unless @memory.approved? %>
+      <%= form_with url: approve_memory_path(@memory), method: :post, local: true, style: 'display:inline' do %>
+        <input type="text" name="approved_by" placeholder="Your name (required)" style="padding:7px 10px; border:1px solid #ccc; border-radius:4px; margin-right:6px;">
+        <button type="submit" class="btn btn-danger" data-confirm="Approve this memory? The AI will then be able to recall it.">Approve</button>
+      <% end %>
+    <% end %>
     <%= link_to 'Edit', edit_memory_path(@memory), class: 'btn' %>
     <%= link_to 'Versions', memory_versions_path(@memory), class: 'btn btn-secondary' %>
     <%= button_to 'Delete', memory_path(@memory), method: :delete, class: 'btn btn-danger', form: { style: 'display:inline' },data: { confirm: 'Delete this memory? Past versions remain in history.' } %>
@@ -49,6 +71,7 @@
         <div>
           <strong>v<%= v.id %></strong>
           <span class="ver-meta">— <%= v.created_at.strftime('%Y-%m-%d %H:%M') %> by <%= v.edited_by || 'unknown' %></span>
+          <% if v.status == 'approved' %><span class="badge status-approved">APPROVED</span><% end %>
           <% if v.change_note.present? %><div class="ver-meta"><%= v.change_note %></div><% end %>
         </div>
         <div>

data/config/routes.rb

@@ -17,6 +17,9 @@ RailsConsoleAi::Engine.routes.draw do
   end
 
   resources :memories do
+    member do
+      post :approve
+    end
     collection do
       get :diff
     end

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

@@ -5,11 +5,11 @@ RailsConsoleAi.configure do |config|
   # API key (or set ANTHROPIC_API_KEY / OPENAI_API_KEY env var)
   # config.api_key = 'sk-...'
 
-  # Model override (defaults: claude-opus-4-6 for Anthropic, gpt-5.3-codex for OpenAI)
-  # config.model = 'claude-opus-4-6'
+  # Model override (defaults: claude-sonnet-5 for Anthropic, gpt-5.3-codex for OpenAI)
+  # config.model = 'claude-opus-4-8'
 
-  # Max tokens for LLM response
-  config.max_tokens = 4096
+  # Max tokens for LLM response (default resolves per model family; 16000 for Claude models)
+  # config.max_tokens = 4096
 
   # Temperature (0.0 - 1.0)
   config.temperature = 0.2
@@ -35,7 +35,7 @@ RailsConsoleAi.configure do |config|
   # AWS Bedrock provider (uses AWS credential chain — no API key needed):
   # config.provider = :bedrock
   # config.bedrock_region = 'us-east-1'
-  # config.model = 'us.anthropic.claude-sonnet-4-6'
+  # config.model = 'us.anthropic.claude-sonnet-5'
 
   # Debug mode: prints full API requests/responses and tool calls to stderr
   # config.debug = true

data/lib/rails_console_ai/agent_runner.rb

@@ -134,6 +134,10 @@ module RailsConsoleAi
       end
       result_text = compose_result(channel.captured_output, exec_result)
 
+      if aborted?(session.id)
+        puts ">> aborted (result discarded)"
+        return
+      end
       SessionLogger.update(session.id, status: 'ready', result: result_text)
 
       elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
@@ -142,16 +146,23 @@ module RailsConsoleAi
       puts ">> ready (#{elapsed}ms) #{preview}"
     rescue RunnerTimeoutError => e
       warn ">> TIMEOUT #{e.message}"
-      SessionLogger.update(session.id, status: 'failed', error_message: e.message)
+      SessionLogger.update(session.id, status: 'failed', error_message: e.message) unless aborted?(session.id)
     rescue => e
       warn ">> FAILED #{e.class}: #{e.message}"
       e.backtrace&.first(5)&.each { |line| warn "   #{line}" }
+      return if aborted?(session.id)
       SessionLogger.update(session.id,
         status: 'failed',
         error_message: "#{e.class}: #{e.message}\n#{Array(e.backtrace).first(10).join("\n")}"
       )
     end
 
+    # An abort (RailsConsoleAi.abort_agent) flips the row to 'aborted' while we
+    # run; in that case the run's outcome must not overwrite the abort.
+    def aborted?(session_id)
+      Session.where(id: session_id).pluck(:status).first == 'aborted'
+    end
+
     # When cap is nil or non-positive, run inline. Otherwise spawn a nested
     # worker thread, join with the deadline, and kill + raise on overshoot.
     # Kept localized (vs Timeout.timeout) so a runaway provider call can't

data/lib/rails_console_ai/channel/console.rb

@@ -368,7 +368,7 @@ module RailsConsoleAi
         config = RailsConsoleAi.configuration
         model = @engine.effective_model
         thinking = config.resolved_thinking_model
-        pricing = Configuration::PRICING[model]
+        pricing = Configuration.pricing_for(model)
 
         @real_stdout.puts "\e[36m  Model info:\e[0m"
         @real_stdout.puts "\e[2m    Provider:        #{config.provider}\e[0m"

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/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/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.

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.31.0'.freeze
+  VERSION = '0.32.0'.freeze
 end

data/lib/rails_console_ai.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 require 'rails_console_ai/version'
 require 'rails_console_ai/configuration'
 
@@ -84,7 +86,7 @@ module RailsConsoleAi
 
     # Returns the current status string for an enqueued agent run, or nil
     # if the session id is not found. Status is one of:
-    # 'queued' | 'running' | 'ready' | 'failed'.
+    # 'queued' | 'running' | 'ready' | 'failed' | 'aborted'.
     def check_agent(session_id)
       Session.where(id: session_id).pluck(:status).first
     end
@@ -98,6 +100,16 @@ module RailsConsoleAi
       { status: row.status, result: row.result, error: row.error_message }
     end
 
+    # Abort a queued or running agent run. Returns true if the run was
+    # aborted, false if it had already finished (or doesn't exist).
+    # Queued runs are never picked up; a run already executing keeps
+    # going but its result is discarded when it completes.
+    def abort_agent(session_id)
+      n = Session.where(id: session_id, status: %w[queued running])
+                 .update_all(status: 'aborted', error_message: 'Aborted')
+      n == 1
+    end
+
     def status
       c = configuration
       key = c.resolved_api_key
@@ -242,20 +254,41 @@ module RailsConsoleAi
         conn.create_table(memories_table) do |t|
           t.string   :name,        limit: 255, null: false
           t.text     :content,     null: false
+          t.string   :status,      limit: 20,  default: 'proposed', null: false
+          t.string   :approved_by, limit: 255
+          t.datetime :approved_at
           t.integer  :use_count,   default: 0, null: false
           t.datetime :last_used_at
           t.datetime :created_at,  null: false
           t.datetime :updated_at,  null: false
         end
         conn.add_index(memories_table, :name, unique: true)
+        conn.add_index(memories_table, :status)
         $stdout.puts "\e[32mRailsConsoleAi: created #{memories_table} table.\e[0m"
       end
 
+      # Existing installs have the content-based memories table but predate the
+      # approval columns — the drop-on-missing-content guard above won't fire for
+      # them, so add the columns in place. Memories created before approval existed
+      # were trusted under the old no-approval regime, so grandfather them to
+      # "approved" rather than yanking them out from under the AI; only memories
+      # created from now on start in "proposed".
+      if conn.table_exists?(memories_table) && !conn.column_exists?(memories_table, :status)
+        conn.add_column(memories_table, :status, :string, limit: 20, default: 'proposed', null: false)
+        conn.execute("UPDATE #{conn.quote_table_name(memories_table)} SET status = 'approved'")
+      end
+      if conn.table_exists?(memories_table)
+        conn.add_column(memories_table, :approved_by, :string, limit: 255) unless conn.column_exists?(memories_table, :approved_by)
+        conn.add_column(memories_table, :approved_at, :datetime) unless conn.column_exists?(memories_table, :approved_at)
+        conn.add_index(memories_table, :status) unless conn.index_exists?(memories_table, :status)
+      end
+
       unless conn.table_exists?(versions_table)
         conn.create_table(versions_table) do |t|
           t.integer  :memory_id
           t.string   :name,        limit: 255
           t.text     :content
+          t.string   :status,      limit: 20
           t.string   :edited_by,   limit: 255
           t.text     :change_note
           t.datetime :created_at,  null: false
@@ -264,6 +297,10 @@ module RailsConsoleAi
         conn.add_index(versions_table, :created_at)
         $stdout.puts "\e[32mRailsConsoleAi: created #{versions_table} table.\e[0m"
       end
+
+      if conn.table_exists?(versions_table) && !conn.column_exists?(versions_table, :status)
+        conn.add_column(versions_table, :status, :string, limit: 20)
+      end
     end
 
     def setup_agents_tables!(conn)

metadata

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