rails_console_ai 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30c7955113bc3e4ce45989fcc0e93034185fbabc0e95acfa01df56ec397900b5
-  data.tar.gz: 87b0399d973e448404b234820067ed2f20d4148f78613963904c9e288a17d87a
+  metadata.gz: 7455c7e1d55abd75c69bfa99621f1f83ec53a5faa2313e3095b3d80b88ec9938
+  data.tar.gz: 0a12cdef783d5f101d0c45b7fce9876e54bf31b1874fc4178a5d2103064ecb0a
 SHA512:
-  metadata.gz: ad1091c711239e286408f0133378c3597c83075b3f9435a40f43bf2df4fa279cf459cf3af84c58027842d2da4c8bccc5d11bfbec616c6e3ec1212784ad59b764
-  data.tar.gz: 61ea9cc3afd50b35ec3d0740b723a076175731d1289c4a98ee5727aaec78c993abb0b78637cb6ac7ef4b550b81b473ff287d83c32405c8fbd345dbf05b0b3b72
+  metadata.gz: 7433c944553f7c683b61e58653e76138e389e41ff29dff45c28fb344913a50514d2a58783fca2c916ff6f86a46a4d71cbad47803625e8078aa25895a2b12a057
+  data.tar.gz: 6cb61503f513cf4864fd918e95719f167733fc94ef001bb61290f6e0b262be0b2a3d83a936904ea7100096103c6c5c8145f74f5e99536088e45ad3aeb90d5a99

data/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.30.0]
+
+- Add background agent support — new `run_agent` mechanism to launch agents asynchronously alongside an HTTP API channel
+- Store skills and memories in the database with versioning, side-by-side diff, and restore, in addition to on-disk files
+- Store sub-agents in the database with the same versioned workflow as skills
+- Require human approval before the AI can use DB-backed skills or sub-agents; editing reverts them to proposed
+- Track per-record usage (`use_count`, `last_used_at`) for DB-backed skills, memories, and sub-agents, surfaced in the web UI
+- Add web UI sections for skills, memories, and agents with list / view / create / edit / delete / approve / version history
+- Add `save_agent`, `delete_agent` AI tools and a `target` parameter on `save_skill` / `save_memory` for DB vs file
+- Add a "Paste a .md file" import box on new skill / memory / agent pages that prefills the form from frontmatter
+- Make `RailsConsoleAi.migrate!` re-run column probes on upgrades so new columns are added on existing installs
+- 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

@@ -504,6 +504,54 @@ This starts a long-running process (run it separately from your web server). The
 - **Channels** — the bot only responds when @mentioned. @mention it in any channel message or thread to start a session. The person who first @mentions the bot owns the session — only they can continue the conversation, and they must @mention the bot on each message. Exception: when the bot asks a question, the owner can reply without @mentioning.
 - **Joining threads** — when @mentioned mid-thread, the bot reads the thread history for context so it understands what's already been discussed.
 
+## Background Agents
+
+Fire off agent runs from your application code and pick up the result later. Useful when you want to delegate a question (or a multi-step task) to the AI from a controller action, a job, a webhook handler, or any place where blocking on an LLM round-trip is undesirable.
+
+```ruby
+id = RailsConsoleAi.run_agent("How many users signed up yesterday?", name: 'daily-stats', user_name: 'cron')
+# => 4821 (Integer session id, returned immediately)
+
+RailsConsoleAi.check_agent(id)
+# => 'queued' | 'running' | 'ready' | 'failed' | nil
+
+RailsConsoleAi.get_agent_response(id)
+# => { status: 'ready', result: "1,432 users signed up yesterday.\n", error: nil }
+```
+
+`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.
+
+### Running the background runner
+
+```bash
+bundle exec rake rails_console_ai:agents
+# AGENT_CONCURRENCY=3 by default; bump it for more parallelism
+AGENT_CONCURRENCY=8 bundle exec rake rails_console_ai:agents
+```
+
+The background runner polls every 2 seconds, claims queued rows atomically (only one worker wins a row), and updates each row to `status='ready'` with the result, or `status='failed'` with an error message. SIGINT/SIGTERM triggers a graceful drain — up to 60 seconds for in-flight jobs, then any stragglers are marked `failed`.
+
+Run it separately from your web server, alongside (or instead of) the Slack bot. If the process crashes mid-job, rows stuck in `status='running'` are left as-is — no built-in reaper yet.
+
+### Requirements
+
+- `RailsConsoleAi.setup!` must have been run so the sessions table has the `status`, `result`, and `error_message` columns. `ai_db_setup` (or `ai_db_migrate` on existing installs) handles this.
+- `session_logging` must be enabled (it is by default).
+
+### Behavior notes
+
+- The agent runs with `Channel::Api`, a non-interactive channel — `prompt` returns `''` and `confirm` auto-yes, so the agent never blocks waiting for human input. Safety guards are always on (`supports_danger?` is `false`), and `bypass_guards_for_methods` still applies as usual.
+- `result` is composed from the agent's prose answer plus the inspected return value of any code it executed:
+
+  ```
+  Let me query the users table for signups from yesterday.
+
+  Result: 1432
+  ```
+
+  If the agent answers without running code, you get just the prose. The raw code, its stdout, and the raw return value also live on the session row as `code_executed` / `code_output` / `code_result` if you need them.
+- The queue row and the result row are the same row, so the existing session viewer at `/rails_console_ai` shows background runs alongside REPL and Slack sessions.
+
 ## Requirements
 
 Ruby >= 2.5, Rails >= 5.0, Faraday >= 1.0. For Bedrock: `aws-sdk-bedrockruntime` (loaded lazily, not a hard dependency).

data/app/controllers/rails_console_ai/agent_versions_controller.rb

@@ -0,0 +1,36 @@
+module RailsConsoleAi
+  class AgentVersionsController < ApplicationController
+    before_action :load_agent
+
+    def index
+      @versions = @agent.versions
+    end
+
+    def show
+      @version = @agent.versions.find(params[:id])
+    end
+
+    def restore
+      version = @agent.versions.find(params[:id])
+      @agent.update_with_version!(
+        {
+          name:        version.name,
+          description: version.description,
+          body:        version.body,
+          max_rounds:  version.max_rounds,
+          model:       version.model,
+          tools:       Array(version.tools)
+        },
+        edited_by: params[:edited_by].presence || 'web',
+        change_note: "Restored from version ##{version.id}"
+      )
+      redirect_to agent_path(@agent), notice: "Restored version ##{version.id}."
+    end
+
+    private
+
+    def load_agent
+      @agent = Agent.find(params[:agent_id])
+    end
+  end
+end

data/app/controllers/rails_console_ai/agents_controller.rb

@@ -0,0 +1,199 @@
+require 'rails_console_ai/agent_loader'
+
+module RailsConsoleAi
+  class AgentsController < ApplicationController
+    before_action :load_agent, only: [:show, :edit, :update, :destroy, :approve]
+
+    def index
+      @agents = AgentLoader.new.load_all_agents
+      @q = params[:q].to_s.strip
+      unless @q.empty?
+        needle = @q.downcase
+        @agents = @agents.select { |a|
+          [a['name'], a['description'], Array(a['tools']).join(' ')].compact.join(' ').downcase.include?(needle)
+        }
+      end
+
+      @sort = params[:sort].to_s
+      if @sort == 'used'
+        @agents = @agents.sort_by { |a| [-(a['use_count'].to_i), a['name'].to_s.downcase] }
+      end
+    end
+
+    def show
+      @versions = @agent.versions if @agent.is_a?(RailsConsoleAi::Agent)
+    end
+
+    def new
+      # Allow prefilling from a built-in (the "Create override" action on the show page).
+      @agent = Agent.new
+      if params[:from_builtin].present?
+        builtin = AgentLoader.new.load_all_agents.find { |a|
+          a['source'] == :builtin && a['name'].to_s.downcase == params[:from_builtin].to_s.downcase
+        }
+        if builtin
+          @agent.name        = builtin['name']
+          @agent.description = builtin['description']
+          @agent.body        = builtin['body']
+          @agent.max_rounds  = builtin['max_rounds']
+          @agent.model       = builtin['model']
+          @agent.tools       = Array(builtin['tools'])
+        end
+      end
+    end
+
+    def create
+      @agent = Agent.new
+      begin
+        @agent.update_with_version!(
+          agent_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to agent_path(@agent), notice: 'Agent created.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :new
+      end
+    end
+
+    # POST /agents/import — parse a pasted .md blob and re-render `new` with fields prefilled.
+    def import
+      content = params[:content].to_s
+      if content.strip.empty?
+        redirect_to new_agent_path, alert: 'Nothing to parse — paste the .md content into the box first.'
+        return
+      end
+
+      parsed = AgentLoader.parse(content)
+      if parsed.nil? || parsed['name'].to_s.strip.empty?
+        redirect_to new_agent_path,
+                    alert: 'Could not parse. Expected YAML frontmatter (between `---` lines) with at least a `name` field, followed by the agent body.'
+        return
+      end
+
+      @agent = Agent.new(
+        name: parsed['name'],
+        description: parsed['description'],
+        body: parsed['body'],
+        max_rounds: parsed['max_rounds'],
+        model: parsed['model']
+      )
+      @agent.tools = Array(parsed['tools'])
+
+      flash.now[:notice] = "Parsed \"#{parsed['name']}\" from pasted content. Review the fields below and click Create agent to save to the DB."
+      render :new
+    end
+
+    def edit
+      redirect_to agents_path, alert: read_only_message and return unless @agent.is_a?(RailsConsoleAi::Agent)
+    end
+
+    def update
+      redirect_to agents_path, alert: read_only_message and return unless @agent.is_a?(RailsConsoleAi::Agent)
+
+      begin
+        @agent.update_with_version!(
+          agent_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to agent_path(@agent), notice: 'Agent updated.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :edit
+      end
+    end
+
+    def destroy
+      if @agent.is_a?(RailsConsoleAi::Agent)
+        @agent.destroy
+        redirect_to agents_path, notice: 'Agent deleted. Past versions remain in history.'
+      else
+        redirect_to agents_path, alert: read_only_message
+      end
+    end
+
+    def approve
+      redirect_to agents_path, alert: read_only_message and return unless @agent.is_a?(RailsConsoleAi::Agent)
+
+      approver = params[:approved_by].presence || 'web'
+
+      if @agent.approved?
+        redirect_to agent_path(@agent), notice: 'Agent is already approved.'
+        return
+      end
+
+      begin
+        @agent.approve!(approved_by: approver)
+        redirect_to agent_path(@agent), notice: "Approved by #{approver}. The AI can now invoke this agent via delegate_task."
+      rescue ArgumentError, ActiveRecord::RecordInvalid => e
+        redirect_to agent_path(@agent), alert: "Could not approve: #{e.message}"
+      end
+    end
+
+    def diff
+      @agent = Agent.find(params[:agent_id])
+      @from = @agent.versions.find(params[:from])
+      @to   = params[:to].present? ? @agent.versions.find(params[:to]) : nil
+      @to_label = @to ? "Version ##{@to.id}" : 'Current'
+      @to_body  = @to ? @to.body : @agent.body
+      @to_tools = @to ? Array(@to.tools) : Array(@agent.tools)
+    end
+
+    private
+
+    def load_agent
+      if params[:id].to_s =~ /\A\d+\z/
+        @agent = Agent.find(params[:id])
+        return
+      end
+
+      # Non-numeric :id — prefer the AR record if a DB row matches by name or slug.
+      ar = Agent.where('LOWER(name) = ?', params[:id].to_s.downcase).first
+      ar ||= Agent.all.find { |a| slugify(a.name) == params[:id] }
+      if ar
+        @agent = ar
+        return
+      end
+
+      all = AgentLoader.new.load_all_agents
+      @agent = all.find { |a| slugify(a['name']) == params[:id] || a['name'] == params[:id] }
+      raise ActiveRecord::RecordNotFound, "Agent not found: #{params[:id]}" unless @agent
+    end
+
+    def agent_params
+      {
+        name:        params.require(:agent)[:name],
+        description: params[:agent][:description],
+        body:        params[:agent][:body],
+        max_rounds:  params[:agent][:max_rounds].presence&.to_i,
+        model:       params[:agent][:model].presence,
+        tools:       split_lines(params[:agent][:tools])
+      }
+    end
+
+    def edited_by_param
+      params[:edited_by].presence || 'web'
+    end
+
+    def split_lines(str)
+      str.to_s.split(/[\r\n,]+/).map(&:strip).reject(&:empty?)
+    end
+
+    def slugify(name)
+      name.to_s.downcase.strip
+        .gsub(/[^a-z0-9\s-]/, '')
+        .gsub(/[\s]+/, '-')
+        .gsub(/-+/, '-')
+    end
+
+    def read_only_message
+      if @agent.is_a?(Hash) && @agent['source'] == :builtin
+        'This is a built-in agent shipped with the gem. To customize it, create a same-named DB agent override.'
+      else
+        'This agent lives on disk under .rails_console_ai/agents/. Edit the file directly to change it.'
+      end
+    end
+  end
+end

data/app/controllers/rails_console_ai/application_controller.rb

@@ -1,5 +1,10 @@
 module RailsConsoleAi
   class ApplicationController < ActionController::Base
+    # Pin to the engine's layout. Without this, Rails layout auto-resolution can
+    # fall back to the host app's `layouts/application` (which usually references
+    # host-only helpers like `logout_url`).
+    layout 'rails_console_ai/application'
+
     protect_from_forgery with: :exception
 
     before_action :rails_console_ai_authenticate!

data/app/controllers/rails_console_ai/memories_controller.rb

@@ -0,0 +1,159 @@
+require 'rails_console_ai/tools/memory_tools'
+
+module RailsConsoleAi
+  class MemoriesController < ApplicationController
+    before_action :load_memory, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @memories = Tools::MemoryTools.new.load_all_memories
+      @q = params[:q].to_s.strip
+      unless @q.empty?
+        needle = @q.downcase
+        @memories = @memories.select { |m|
+          [m['name'], m['description'], Array(m['tags']).join(' ')].compact.join(' ').downcase.include?(needle)
+        }
+      end
+
+      @sort = params[:sort].to_s
+      if @sort == 'used'
+        @memories = @memories.sort_by { |m| [-(m['use_count'].to_i), m['name'].to_s.downcase] }
+      end
+    end
+
+    def show
+      @versions = @memory.versions if @memory.is_a?(RailsConsoleAi::Memory)
+    end
+
+    def new
+      @memory = Memory.new
+    end
+
+    # POST /memories/import — parse a pasted .md blob and re-render `new` with fields prefilled.
+    def import
+      content = params[:content].to_s
+      if content.strip.empty?
+        redirect_to new_memory_path, alert: 'Nothing to parse — paste the .md content into the box first.'
+        return
+      end
+
+      parsed = Tools::MemoryTools.parse(content)
+      if parsed.nil? || parsed['name'].to_s.strip.empty?
+        redirect_to new_memory_path,
+                    alert: 'Could not parse. Expected YAML frontmatter (between `---` lines) with at least a `name` field, followed by the memory body.'
+        return
+      end
+
+      @memory = Memory.new(
+        name: parsed['name'],
+        description: parsed['description']
+      )
+      @memory.tags = Array(parsed['tags'])
+
+      flash.now[:notice] = "Parsed \"#{parsed['name']}\" from pasted content. Review the fields below and click Create memory to save to the DB."
+      render :new
+    end
+
+    def create
+      @memory = Memory.new
+      attrs = memory_params
+      begin
+        @memory.update_with_version!(
+          attrs,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to memory_path(@memory), notice: 'Memory created.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :new
+      end
+    end
+
+    def edit
+      redirect_to memories_path, alert: file_memory_message and return unless @memory.is_a?(RailsConsoleAi::Memory)
+    end
+
+    def update
+      redirect_to memories_path, alert: file_memory_message and return unless @memory.is_a?(RailsConsoleAi::Memory)
+
+      begin
+        @memory.update_with_version!(
+          memory_params,
+          edited_by: edited_by_param,
+          change_note: params[:change_note].presence
+        )
+        redirect_to memory_path(@memory), notice: 'Memory updated.'
+      rescue ActiveRecord::RecordInvalid => e
+        flash.now[:alert] = e.message
+        render :edit
+      end
+    end
+
+    def destroy
+      if @memory.is_a?(RailsConsoleAi::Memory)
+        @memory.destroy
+        redirect_to memories_path, notice: 'Memory deleted. Past versions remain in history.'
+      else
+        redirect_to memories_path, alert: file_memory_message
+      end
+    end
+
+    def diff
+      @memory = Memory.find(params[:memory_id])
+      @from = @memory.versions.find(params[:from])
+      @to   = params[:to].present? ? @memory.versions.find(params[:to]) : nil
+      @to_label = @to ? "Version ##{@to.id}" : 'Current'
+      @to_description = @to ? @to.description : @memory.description
+      @to_tags = @to ? Array(@to.tags) : Array(@memory.tags)
+    end
+
+    private
+
+    def load_memory
+      if params[:id].to_s =~ /\A\d+\z/
+        @memory = Memory.find(params[:id])
+        return
+      end
+
+      # Non-numeric :id — prefer the AR record if a DB row matches by name or slug,
+      # so write actions (update/destroy) get the AR object, not a read-only Hash.
+      ar = Memory.where('LOWER(name) = ?', params[:id].to_s.downcase).first
+      ar ||= Memory.all.find { |m| slugify(m.name) == params[:id] }
+      if ar
+        @memory = ar
+        return
+      end
+
+      all = Tools::MemoryTools.new.load_all_memories
+      @memory = all.find { |m| slugify(m['name']) == params[:id] || m['name'] == params[:id] }
+      raise ActiveRecord::RecordNotFound, "Memory not found: #{params[:id]}" unless @memory
+    end
+
+    def memory_params
+      {
+        name:        params.require(:memory)[:name],
+        description: params[:memory][:description],
+        tags:        split_csv(params[:memory][:tags])
+      }
+    end
+
+    def edited_by_param
+      params[:edited_by].presence || 'web'
+    end
+
+    def split_csv(str)
+      str.to_s.split(',').map(&:strip).reject(&:empty?)
+    end
+
+    def slugify(name)
+      name.to_s.downcase.strip
+        .gsub(/[^a-z0-9\s-]/, '')
+        .gsub(/[\s]+/, '-')
+        .gsub(/-+/, '-')
+    end
+
+    def file_memory_message
+      'This memory lives on disk under .rails_console_ai/memories/. Edit the file directly to change it.'
+    end
+  end
+end

data/app/controllers/rails_console_ai/memory_versions_controller.rb

@@ -0,0 +1,33 @@
+module RailsConsoleAi
+  class MemoryVersionsController < ApplicationController
+    before_action :load_memory
+
+    def index
+      @versions = @memory.versions
+    end
+
+    def show
+      @version = @memory.versions.find(params[:id])
+    end
+
+    def restore
+      version = @memory.versions.find(params[:id])
+      @memory.update_with_version!(
+        {
+          name:        version.name,
+          description: version.description,
+          tags:        Array(version.tags)
+        },
+        edited_by: params[:edited_by].presence || 'web',
+        change_note: "Restored from version ##{version.id}"
+      )
+      redirect_to memory_path(@memory), notice: "Restored version ##{version.id}."
+    end
+
+    private
+
+    def load_memory
+      @memory = Memory.find(params[:memory_id])
+    end
+  end
+end

data/app/controllers/rails_console_ai/skill_versions_controller.rb

@@ -0,0 +1,35 @@
+module RailsConsoleAi
+  class SkillVersionsController < ApplicationController
+    before_action :load_skill
+
+    def index
+      @versions = @skill.versions
+    end
+
+    def show
+      @version = @skill.versions.find(params[:id])
+    end
+
+    def restore
+      version = @skill.versions.find(params[:id])
+      @skill.update_with_version!(
+        {
+          name:                      version.name,
+          description:               version.description,
+          body:                      version.body,
+          tags:                      Array(version.tags),
+          bypass_guards_for_methods: Array(version.bypass_guards_for_methods)
+        },
+        edited_by: params[:edited_by].presence || 'web',
+        change_note: "Restored from version ##{version.id}"
+      )
+      redirect_to skill_path(@skill), notice: "Restored version ##{version.id}."
+    end
+
+    private
+
+    def load_skill
+      @skill = Skill.find(params[:skill_id])
+    end
+  end
+end