rails_console_ai 0.29.0 → 0.30.0

data/lib/rails_console_ai/tools/registry.rb

@@ -6,7 +6,7 @@ module RailsConsoleAi
       attr_reader :definitions, :last_sub_agent_usage
 
       # Tools that should never be cached (side effects or user interaction)
-      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill delegate_task explore_output].freeze
+      NO_CACHE = %w[ask_user save_memory delete_memory recall_memory execute_code execute_plan activate_skill save_skill delete_skill save_agent delete_agent delegate_task explore_output].freeze
 
       def initialize(executor: nil, mode: :default, channel: nil, allowed_tools: nil)
         @executor = executor
@@ -254,6 +254,7 @@ module RailsConsoleAi
 
             register_memory_tools
             register_skill_tools
+            register_agent_tools
             register_execute_plan
             register_delegate_task
           end
@@ -381,9 +382,20 @@ module RailsConsoleAi
           loader = AgentLoader.new
           agent_config = loader.find_agent(agent_name)
           unless agent_config
-            available = loader.load_all_agents.map { |a| a['name'] }
+            # Distinguish "doesn't exist" from "exists but isn't approved yet".
+            proposed = loader.find_any_agent(agent_name)
+            if proposed && proposed['source'] == :db && proposed['status'] != 'approved'
+              return "Agent \"#{agent_name}\" exists but is awaiting human approval and cannot be invoked yet. " \
+                     "Ask the user to approve it in the web UI at /rails_console_ai/agents."
+            end
+            available = loader.load_activatable_agents.map { |a| a['name'] }
             return "Agent not found: \"#{agent_name}\". Available agents: #{available.join(', ')}"
           end
+
+          # Usage tracking — DB-backed agents only.
+          if agent_config['source'] == :db && agent_config['id']
+            RailsConsoleAi::Agent.record_use!(agent_config['id'])
+          end
         end
 
         sub = SubAgent.new(
@@ -406,18 +418,26 @@ 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).',
+          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.',
           parameters: {
             'type' => 'object',
             'properties' => {
               'name' => { 'type' => 'string', 'description' => 'Short name for this memory (e.g. "Sharding architecture")' },
               'description' => { 'type' => 'string', 'description' => 'Detailed description of what you learned' },
-              'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags (e.g. ["database", "sharding"])' }
+              'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags (e.g. ["database", "sharding"])' },
+              'target' => { 'type' => 'string', 'enum' => ['db', 'file'], 'description' => 'Where to store this memory. "db" (default) is versioned and editable via the web UI; "file" writes a Markdown file under .rails_console_ai/memories/.' },
+              'change_note' => { 'type' => 'string', 'description' => 'Optional one-line note describing this edit (DB store only).' }
             },
             'required' => ['name', 'description']
           },
           handler: ->(args) {
-            memory.save_memory(name: args['name'], description: args['description'], tags: args['tags'] || [])
+            memory.save_memory(
+              name: args['name'],
+              description: args['description'],
+              tags: args['tags'] || [],
+              target: (args['target'] || 'db').to_sym,
+              change_note: args['change_note']
+            )
           }
         )
 
@@ -480,19 +500,30 @@ module RailsConsoleAi
           handler: ->(args) {
             skill = loader.find_skill(args['name'])
             unless skill
+              # Distinguish "doesn't exist" from "exists but isn't approved yet".
+              proposed = loader.find_any_skill(args['name'])
+              if proposed && proposed['source'] == :db && proposed['status'] != 'approved'
+                return "Skill \"#{args['name']}\" exists but is awaiting human approval and cannot be activated yet. " \
+                       "Ask the user to approve it in the web UI at /rails_console_ai/skills."
+              end
               return "Skill not found: \"#{args['name']}\". Use the skills listed in the system prompt."
             end
 
             bypass_methods = Array(skill['bypass_guards_for_methods'])
             @executor.activate_skill_bypasses(bypass_methods) unless bypass_methods.empty?
 
+            # Usage tracking — DB-backed skills only (file skills have no row to update).
+            if skill['source'] == :db && skill['id']
+              RailsConsoleAi::Skill.record_use!(skill['id'])
+            end
+
             skill['body']
           }
         )
 
         register(
           name: 'save_skill',
-          description: 'Create or update a skill — a reusable procedure for a specific operation. Use when the user asks you to create a skill, recipe, or runbook. Skills differ from memories: a skill is a step-by-step procedure to follow, while a memory is a fact or pattern you learned.',
+          description: 'Create or update a skill — a reusable procedure for a specific operation. Use when the user asks you to create a skill, recipe, or runbook. Skills differ from memories: a skill is a step-by-step procedure to follow, while a memory is a fact or pattern you learned. Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/skills directory instead. IMPORTANT: skills saved to the DB start in "proposed" state and must be approved by a human in the web UI before you can activate them. Edits to an approved skill also revert it to proposed. Tell the user to visit /rails_console_ai/skills to approve.',
           parameters: {
             'type' => 'object',
             'properties' => {
@@ -500,7 +531,9 @@ module RailsConsoleAi
               'description' => { 'type' => 'string', 'description' => 'One-line description of when to use this skill' },
               'body' => { 'type' => 'string', 'description' => 'The full skill recipe in markdown. Include: ## When to use, ## Recipe (numbered steps with code blocks), ## Notes (optional).' },
               'tags' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional tags for categorization (e.g. ["booking-page", "admin"])' },
-              'bypass_guards_for_methods' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Methods that should bypass safety guards when this skill is active (e.g. ["BookingPage#save!", "BookingPage#ensure_subdomain_set!"])' }
+              'bypass_guards_for_methods' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Methods that should bypass safety guards when this skill is active (e.g. ["BookingPage#save!", "BookingPage#ensure_subdomain_set!"])' },
+              'target' => { 'type' => 'string', 'enum' => ['db', 'file'], 'description' => 'Where to store this skill. "db" (default) is versioned and editable via the web UI; "file" writes a Markdown file under .rails_console_ai/skills/.' },
+              'change_note' => { 'type' => 'string', 'description' => 'Optional one-line note describing this edit (DB store only).' }
             },
             'required' => %w[name description body]
           },
@@ -510,7 +543,9 @@ module RailsConsoleAi
               description: args['description'],
               body: args['body'],
               tags: args['tags'] || [],
-              bypass_guards_for_methods: args['bypass_guards_for_methods'] || []
+              bypass_guards_for_methods: args['bypass_guards_for_methods'] || [],
+              target: (args['target'] || 'db').to_sym,
+              change_note: args['change_note']
             )
           }
         )
@@ -529,6 +564,62 @@ module RailsConsoleAi
         )
       end
 
+      def register_agent_tools
+        return unless @executor
+
+        require 'rails_console_ai/agent_loader'
+        loader = RailsConsoleAi::AgentLoader.new
+
+        register(
+          name: 'save_agent',
+          description: 'Create or update a sub-agent definition — a reusable specialist that the main assistant can invoke via delegate_task. ' \
+            'Use when the user asks you to create a new agent, recipe-agent, or sub-task specialist. ' \
+            'Agents differ from skills: an agent runs in its own sub-conversation with a constrained tool set, while a skill is a procedure followed inline. ' \
+            'Defaults to the versioned DB store; pass target: "file" to write to the on-disk .rails_console_ai/agents directory instead. ' \
+            'IMPORTANT: agents saved to the DB start in "proposed" state and must be approved by a human in the web UI before delegate_task can invoke them. ' \
+            'Edits to an approved agent also revert it to proposed. Tell the user to visit /rails_console_ai/agents to approve.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'Agent name (e.g. "Investigate billing"), shown in the Agents list and used as the delegate_task `agent` parameter' },
+              'description' => { 'type' => 'string', 'description' => 'One-line description of what this agent specializes in' },
+              'body' => { 'type' => 'string', 'description' => 'The agent\'s system instructions in markdown. Include: persona, strategy, rules, expected output format.' },
+              'max_rounds' => { 'type' => 'integer', 'description' => 'Optional: maximum tool-loop iterations for the sub-agent (defaults to global config). Use a smaller number for tightly-scoped agents.' },
+              'model' => { 'type' => 'string', 'description' => 'Optional: model override for this agent (e.g. "claude-haiku-4" for cheap fast agents)' },
+              'tools' => { 'type' => 'array', 'items' => { 'type' => 'string' }, 'description' => 'Optional: whitelist of tool names the sub-agent is allowed to call. Omit to allow the default set.' },
+              'target' => { 'type' => 'string', 'enum' => ['db', 'file'], 'description' => 'Where to store this agent. "db" (default) is versioned and editable via the web UI; "file" writes a Markdown file under .rails_console_ai/agents/.' },
+              'change_note' => { 'type' => 'string', 'description' => 'Optional one-line note describing this edit (DB store only).' }
+            },
+            'required' => %w[name description body]
+          },
+          handler: ->(args) {
+            loader.save_agent(
+              name: args['name'],
+              description: args['description'],
+              body: args['body'],
+              max_rounds: args['max_rounds'],
+              model: args['model'],
+              tools: args['tools'] || [],
+              target: (args['target'] || 'db').to_sym,
+              change_note: args['change_note']
+            )
+          }
+        )
+
+        register(
+          name: 'delete_agent',
+          description: 'Delete a sub-agent by name. Built-in (gem-shipped) agents cannot be deleted; this tool will tell you that and suggest creating a same-named override instead.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'The agent name to delete' }
+            },
+            'required' => ['name']
+          },
+          handler: ->(args) { loader.delete_agent(name: args['name']) }
+        )
+      end
+
       def register_execute_plan
         return unless @executor
 

data/lib/rails_console_ai/version.rb

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

data/lib/rails_console_ai.rb

@@ -55,6 +55,39 @@ module RailsConsoleAi
       @current_user = name
     end
 
+    # Enqueue an agent run. Returns the Integer session id immediately;
+    # the actual work is picked up by `rake rails_console_ai:agents`.
+    def run_agent(query, name: nil, user_name: nil)
+      require 'rails_console_ai/session_logger'
+      id = SessionLogger.log(
+        query: query,
+        conversation: [],
+        mode: 'agent_api',
+        name: name,
+        user_name: user_name,
+        status: 'queued',
+        executed: false
+      )
+      raise 'Failed to enqueue agent run (session logging disabled or table missing)' unless id
+      id
+    end
+
+    # 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'.
+    def check_agent(session_id)
+      Session.where(id: session_id).pluck(:status).first
+    end
+
+    # Returns a hash describing an agent run:
+    #   { status:, result:, error: }
+    # All three keys are nil when the session id is not found.
+    def get_agent_response(session_id)
+      row = Session.where(id: session_id).select(:status, :result, :error_message).first
+      return { status: nil, result: nil, error: nil } unless row
+      { status: row.status, result: row.result, error: row.error_message }
+    end
+
     def status
       c = configuration
       key = c.resolved_api_key
@@ -123,11 +156,183 @@ module RailsConsoleAi
         $stdout.puts "\e[32mRailsConsoleAi: created #{table} table.\e[0m"
       end
 
+      setup_skills_tables!(conn)
+      setup_memories_tables!(conn)
+      setup_agents_tables!(conn)
+
       migrate!
     rescue => e
       $stderr.puts "\e[31mRailsConsoleAi setup failed: #{e.class}: #{e.message}\e[0m"
     end
 
+    def setup_skills_tables!(conn)
+      skills_table   = 'rails_console_ai_skills'
+      versions_table = 'rails_console_ai_skill_versions'
+
+      unless conn.table_exists?(skills_table)
+        conn.create_table(skills_table) do |t|
+          t.string   :name,        limit: 255, null: false
+          t.text     :description
+          t.text     :body
+          t.text     :tags
+          t.text     :bypass_guards_for_methods
+          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(skills_table, :name, unique: true)
+        conn.add_index(skills_table, :status)
+        $stdout.puts "\e[32mRailsConsoleAi: created #{skills_table} table.\e[0m"
+      else
+        # Idempotent column-add probes for existing installs.
+        unless conn.column_exists?(skills_table, :status)
+          conn.add_column(skills_table, :status, :string, limit: 20, default: 'proposed', null: false)
+          conn.add_index(skills_table, :status) unless conn.index_exists?(skills_table, :status)
+        end
+        unless conn.column_exists?(skills_table, :approved_by)
+          conn.add_column(skills_table, :approved_by, :string, limit: 255)
+        end
+        unless conn.column_exists?(skills_table, :approved_at)
+          conn.add_column(skills_table, :approved_at, :datetime)
+        end
+        unless conn.column_exists?(skills_table, :use_count)
+          conn.add_column(skills_table, :use_count, :integer, default: 0, null: false)
+        end
+        unless conn.column_exists?(skills_table, :last_used_at)
+          conn.add_column(skills_table, :last_used_at, :datetime)
+        end
+      end
+
+      unless conn.table_exists?(versions_table)
+        conn.create_table(versions_table) do |t|
+          t.integer  :skill_id
+          t.string   :name,        limit: 255
+          t.text     :description
+          t.text     :body
+          t.text     :tags
+          t.text     :bypass_guards_for_methods
+          t.string   :status,      limit: 20
+          t.string   :edited_by,   limit: 255
+          t.text     :change_note
+          t.datetime :created_at,  null: false
+        end
+        conn.add_index(versions_table, :skill_id)
+        conn.add_index(versions_table, :created_at)
+        $stdout.puts "\e[32mRailsConsoleAi: created #{versions_table} table.\e[0m"
+      else
+        unless conn.column_exists?(versions_table, :status)
+          conn.add_column(versions_table, :status, :string, limit: 20)
+        end
+      end
+    end
+
+    def setup_memories_tables!(conn)
+      memories_table = 'rails_console_ai_memories'
+      versions_table = 'rails_console_ai_memory_versions'
+
+      unless conn.table_exists?(memories_table)
+        conn.create_table(memories_table) do |t|
+          t.string   :name,        limit: 255, null: false
+          t.text     :description
+          t.text     :tags
+          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)
+        $stdout.puts "\e[32mRailsConsoleAi: created #{memories_table} table.\e[0m"
+      else
+        unless conn.column_exists?(memories_table, :use_count)
+          conn.add_column(memories_table, :use_count, :integer, default: 0, null: false)
+        end
+        unless conn.column_exists?(memories_table, :last_used_at)
+          conn.add_column(memories_table, :last_used_at, :datetime)
+        end
+      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     :description
+          t.text     :tags
+          t.string   :edited_by,   limit: 255
+          t.text     :change_note
+          t.datetime :created_at,  null: false
+        end
+        conn.add_index(versions_table, :memory_id)
+        conn.add_index(versions_table, :created_at)
+        $stdout.puts "\e[32mRailsConsoleAi: created #{versions_table} table.\e[0m"
+      end
+    end
+
+    def setup_agents_tables!(conn)
+      agents_table   = 'rails_console_ai_agents'
+      versions_table = 'rails_console_ai_agent_versions'
+
+      unless conn.table_exists?(agents_table)
+        conn.create_table(agents_table) do |t|
+          t.string   :name,        limit: 255, null: false
+          t.text     :description
+          t.text     :body
+          t.integer  :max_rounds
+          t.string   :model,       limit: 100
+          t.text     :tools
+          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(agents_table, :name, unique: true)
+        conn.add_index(agents_table, :status)
+        $stdout.puts "\e[32mRailsConsoleAi: created #{agents_table} table.\e[0m"
+      else
+        unless conn.column_exists?(agents_table, :status)
+          conn.add_column(agents_table, :status, :string, limit: 20, default: 'proposed', null: false)
+          conn.add_index(agents_table, :status) unless conn.index_exists?(agents_table, :status)
+        end
+        unless conn.column_exists?(agents_table, :approved_by)
+          conn.add_column(agents_table, :approved_by, :string, limit: 255)
+        end
+        unless conn.column_exists?(agents_table, :approved_at)
+          conn.add_column(agents_table, :approved_at, :datetime)
+        end
+        unless conn.column_exists?(agents_table, :use_count)
+          conn.add_column(agents_table, :use_count, :integer, default: 0, null: false)
+        end
+        unless conn.column_exists?(agents_table, :last_used_at)
+          conn.add_column(agents_table, :last_used_at, :datetime)
+        end
+      end
+
+      unless conn.table_exists?(versions_table)
+        conn.create_table(versions_table) do |t|
+          t.integer  :agent_id
+          t.string   :name,        limit: 255
+          t.text     :description
+          t.text     :body
+          t.integer  :max_rounds
+          t.string   :model,       limit: 100
+          t.text     :tools
+          t.string   :status,      limit: 20
+          t.string   :edited_by,   limit: 255
+          t.text     :change_note
+          t.datetime :created_at,  null: false
+        end
+        conn.add_index(versions_table, :agent_id)
+        conn.add_index(versions_table, :created_at)
+        $stdout.puts "\e[32mRailsConsoleAi: created #{versions_table} table.\e[0m"
+      end
+    end
+
     def migrate!
       conn = session_connection
       table = 'rails_console_ai_sessions'
@@ -156,6 +361,50 @@ module RailsConsoleAi
         migrations << 'slack_channel_name'
       end
 
+      unless conn.column_exists?(table, :status)
+        conn.add_column(table, :status, :string, limit: 20)
+        migrations << 'status'
+      end
+
+      unless conn.column_exists?(table, :result)
+        conn.add_column(table, :result, :text)
+        migrations << 'result'
+      end
+
+      unless conn.column_exists?(table, :error_message)
+        conn.add_column(table, :error_message, :text)
+        migrations << 'error_message'
+      end
+
+      unless conn.index_exists?(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
+        conn.add_index(table, [:mode, :status], name: 'idx_rca_sessions_mode_status')
+        migrations << 'idx_rca_sessions_mode_status'
+      end
+
+      # Bring skills/memories/agents tables fully up to date. Each setup_* method is
+      # internally idempotent (guards both `create_table` and every `add_column` /
+      # `add_index`), so running it on an existing install adds any missing columns
+      # (e.g. `status`, `approved_by`, `approved_at`) and indexes without disturbing
+      # data. Note: we always call these — the previous version skipped them when
+      # the base table already existed, which meant column probes never ran on
+      # upgrade and methods like Skill#status hit NameError. See:
+      # https://github.com/cortfr/rails_console_ai/issues (whichever issue you file)
+      pre_columns = {
+        skills:   table_columns(conn, 'rails_console_ai_skills'),
+        memories: table_columns(conn, 'rails_console_ai_memories'),
+        agents:   table_columns(conn, 'rails_console_ai_agents')
+      }
+
+      setup_skills_tables!(conn)
+      setup_memories_tables!(conn)
+      setup_agents_tables!(conn)
+
+      [[:skills, 'rails_console_ai_skills'], [:memories, 'rails_console_ai_memories'], [:agents, 'rails_console_ai_agents']].each do |key, name|
+        post = table_columns(conn, name)
+        added = post - pre_columns[key]
+        migrations.concat(added.map { |c| "#{name}.#{c}" }) unless added.empty?
+      end
+
       if migrations.empty?
         $stdout.puts "\e[32mRailsConsoleAi: #{table} is up to date.\e[0m"
       else
@@ -214,6 +463,13 @@ module RailsConsoleAi
         ActiveRecord::Base.connection
       end
     end
+
+    def table_columns(conn, table_name)
+      return [] unless conn.table_exists?(table_name)
+      conn.columns(table_name).map { |c| c.name }
+    rescue
+      []
+    end
   end
 end
 

data/lib/tasks/rails_console_ai.rake

@@ -4,4 +4,11 @@ namespace :rails_console_ai do
     require 'rails_console_ai/slack_bot'
     RailsConsoleAi::SlackBot.new.start
   end
+
+  desc "Run the RailsConsoleAi agent runner (polls DB for queued agent runs)"
+  task agents: :environment do
+    require 'rails_console_ai/agent_runner'
+    concurrency = Integer(ENV['AGENT_CONCURRENCY'] || RailsConsoleAi::AgentRunner::DEFAULT_CONCURRENCY)
+    RailsConsoleAi::AgentRunner.new(concurrency: concurrency).start
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Cortfr
@@ -79,6 +79,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
 description: An LLM-powered agent for your Rails console. Ask questions in natural
   language, get executable Ruby code.
 email: cortfr@gmail.com
@@ -89,20 +103,59 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- app/controllers/rails_console_ai/agent_versions_controller.rb
+- app/controllers/rails_console_ai/agents_controller.rb
 - app/controllers/rails_console_ai/application_controller.rb
+- app/controllers/rails_console_ai/memories_controller.rb
+- app/controllers/rails_console_ai/memory_versions_controller.rb
 - app/controllers/rails_console_ai/sessions_controller.rb
+- app/controllers/rails_console_ai/skill_versions_controller.rb
+- app/controllers/rails_console_ai/skills_controller.rb
+- app/helpers/rails_console_ai/diff_helper.rb
 - app/helpers/rails_console_ai/sessions_helper.rb
+- app/models/rails_console_ai/agent.rb
+- app/models/rails_console_ai/agent_version.rb
+- app/models/rails_console_ai/memory.rb
+- app/models/rails_console_ai/memory_version.rb
 - app/models/rails_console_ai/session.rb
+- app/models/rails_console_ai/skill.rb
+- app/models/rails_console_ai/skill_version.rb
 - app/views/layouts/rails_console_ai/application.html.erb
+- app/views/rails_console_ai/agent_versions/index.html.erb
+- app/views/rails_console_ai/agent_versions/show.html.erb
+- app/views/rails_console_ai/agents/_form.html.erb
+- app/views/rails_console_ai/agents/diff.html.erb
+- app/views/rails_console_ai/agents/edit.html.erb
+- app/views/rails_console_ai/agents/index.html.erb
+- app/views/rails_console_ai/agents/new.html.erb
+- app/views/rails_console_ai/agents/show.html.erb
+- app/views/rails_console_ai/memories/_form.html.erb
+- app/views/rails_console_ai/memories/diff.html.erb
+- app/views/rails_console_ai/memories/edit.html.erb
+- app/views/rails_console_ai/memories/index.html.erb
+- app/views/rails_console_ai/memories/new.html.erb
+- app/views/rails_console_ai/memories/show.html.erb
+- app/views/rails_console_ai/memory_versions/index.html.erb
+- app/views/rails_console_ai/memory_versions/show.html.erb
 - app/views/rails_console_ai/sessions/index.html.erb
 - app/views/rails_console_ai/sessions/show.html.erb
+- app/views/rails_console_ai/skill_versions/index.html.erb
+- app/views/rails_console_ai/skill_versions/show.html.erb
+- app/views/rails_console_ai/skills/_form.html.erb
+- app/views/rails_console_ai/skills/diff.html.erb
+- app/views/rails_console_ai/skills/edit.html.erb
+- app/views/rails_console_ai/skills/index.html.erb
+- app/views/rails_console_ai/skills/new.html.erb
+- app/views/rails_console_ai/skills/show.html.erb
 - config/routes.rb
 - lib/generators/rails_console_ai/install_generator.rb
 - lib/generators/rails_console_ai/templates/initializer.rb
 - lib/rails_console_ai.rb
 - lib/rails_console_ai/agent_loader.rb
+- lib/rails_console_ai/agent_runner.rb
 - lib/rails_console_ai/agents/explore-data.md
 - lib/rails_console_ai/agents/investigate-code.md
+- lib/rails_console_ai/channel/api.rb
 - lib/rails_console_ai/channel/base.rb
 - lib/rails_console_ai/channel/console.rb
 - lib/rails_console_ai/channel/slack.rb
@@ -126,6 +179,7 @@ files:
 - lib/rails_console_ai/skill_loader.rb
 - lib/rails_console_ai/slack_bot.rb
 - lib/rails_console_ai/storage/base.rb
+- lib/rails_console_ai/storage/database_storage.rb
 - lib/rails_console_ai/storage/file_storage.rb
 - lib/rails_console_ai/sub_agent.rb
 - lib/rails_console_ai/tools/code_tools.rb