rails_console_ai 0.30.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7455c7e1d55abd75c69bfa99621f1f83ec53a5faa2313e3095b3d80b88ec9938
-  data.tar.gz: 0a12cdef783d5f101d0c45b7fce9876e54bf31b1874fc4178a5d2103064ecb0a
+  metadata.gz: 7eab1fd8d3a5c8c7a228206f0c723bfa845fa2d344471e0251659658c0c5e571
+  data.tar.gz: c607b6cfa9e6834612513f0c75dc1303386f79bcdd96bba203a4fb5d0549f32b
 SHA512:
-  metadata.gz: 7433c944553f7c683b61e58653e76138e389e41ff29dff45c28fb344913a50514d2a58783fca2c916ff6f86a46a4d71cbad47803625e8078aa25895a2b12a057
-  data.tar.gz: 6cb61503f513cf4864fd918e95719f167733fc94ef001bb61290f6e0b262be0b2a3d83a936904ea7100096103c6c5c8145f74f5e99536088e45ad3aeb90d5a99
+  metadata.gz: 1acd49dcf3370eaab8a8fb8ef77c7dad4746fcb0e0eb2f78935b53c870228a9b53a2cef8dc82608ed94f5f2642de905070fe9e241e9a98d8f408653535ce30d7
+  data.tar.gz: bd7ec6fcf50788b45f47f6a7b1948a74fb83cf4ff7fba62687eb2d6e8c75743972f4e83525d87f57096c1a6cd114611a69c5b6e2299a88dea6b02063cdf09adc

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 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
+- Add options for running agents
+- Fix the `/script/release` script
+
 ## [0.30.0]
 
 - Add background agent support — new `run_agent` mechanism to launch agents asynchronously alongside an HTTP API channel
@@ -16,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,14 +513,36 @@ 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
+
+`run_agent` accepts two extra keyword arguments to tune individual runs:
+
+```ruby
+RailsConsoleAi.run_agent(
+  "Trace why nightly billing is double-charging some accounts",
+  use_thinking_model: true,        # run on the thinking-tier model (e.g. Opus)
+  max_wall_clock_seconds: 1800     # hard kill after 30 minutes; pass nil for no cap
+)
+```
+
+- `use_thinking_model:` (default `false`) — switches the run to `config.thinking_model` (or the provider default thinking model) for the duration of the agent. Useful for harder, multi-step problems.
+- `max_wall_clock_seconds:` (default `600`) — hard ceiling on wall-clock time. If the run exceeds the cap, the worker thread is killed and the session is marked `status='failed'` with `error_message: "exceeded max_wall_clock_seconds (Ns)"`. Pass `nil` to opt out of any cap.
+
+These (along with any future per-run options) are stored in a JSON `options` column on the session row, so they survive the handoff to the background runner.
+
 ### Running the background runner
 
 ```bash
@@ -535,7 +557,7 @@ Run it separately from your web server, alongside (or instead of) the Slack bot.
 
 ### 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.
+- `RailsConsoleAi.setup!` must have been run so the sessions table has the `status`, `result`, `error_message`, and `options` columns. `ai_db_setup` (or `ai_db_migrate` on existing installs) handles this.
 - `session_logging` must be enabled (it is by default).
 
 ### Behavior notes

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
@@ -13,14 +13,7 @@ module RailsConsoleAi
     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)
-        },
+        { content: version.content },
         edited_by: params[:edited_by].presence || 'web',
         change_note: "Restored from version ##{version.id}"
       )

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
@@ -32,14 +32,17 @@ module RailsConsoleAi
           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'])
+          @agent.content = AgentLoader.dump(
+            name: builtin['name'],
+            description: builtin['description'],
+            body: builtin['body'],
+            max_rounds: builtin['max_rounds'],
+            model: builtin['model'],
+            tools: Array(builtin['tools'])
+          )
         end
       end
+      @agent.content ||= new_agent_template
     end
 
     def create
@@ -57,34 +60,6 @@ module RailsConsoleAi
       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
@@ -136,9 +111,8 @@ module RailsConsoleAi
       @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)
+      @to_label   = @to ? "Version ##{@to.id}" : 'Current'
+      @to_content = @to ? @to.content : @agent.content
     end
 
     private
@@ -163,22 +137,25 @@ module RailsConsoleAi
     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])
-      }
+      { content: params.require(:agent)[:content].to_s }
     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?)
+    def new_agent_template
+      <<~MD
+        ---
+        name:
+        description:
+        max_rounds:
+        model:
+        tools: []
+        ---
+
+        Persona, strategy, rules…
+      MD
     end
 
     def slugify(name)

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
@@ -25,32 +25,7 @@ module RailsConsoleAi
     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
+      @memory = Memory.new(content: new_memory_template)
     end
 
     def create
@@ -98,13 +73,32 @@ 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])
       @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)
+      @to_label   = @to ? "Version ##{@to.id}" : 'Current'
+      @to_content = @to ? @to.content : @memory.content
     end
 
     private
@@ -130,19 +124,22 @@ module RailsConsoleAi
     end
 
     def memory_params
-      {
-        name:        params.require(:memory)[:name],
-        description: params[:memory][:description],
-        tags:        split_csv(params[:memory][:tags])
-      }
+      { content: params.require(:memory)[:content].to_s }
     end
 
     def edited_by_param
       params[:edited_by].presence || 'web'
     end
 
-    def split_csv(str)
-      str.to_s.split(',').map(&:strip).reject(&:empty?)
+    def new_memory_template
+      <<~MD
+        ---
+        name:
+        tags: []
+        ---
+
+        The fact or pattern you're persisting.
+      MD
     end
 
     def slugify(name)

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
@@ -13,11 +13,7 @@ module RailsConsoleAi
     def restore
       version = @memory.versions.find(params[:id])
       @memory.update_with_version!(
-        {
-          name:        version.name,
-          description: version.description,
-          tags:        Array(version.tags)
-        },
+        { content: version.content },
         edited_by: params[:edited_by].presence || 'web',
         change_note: "Restored from version ##{version.id}"
       )

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
@@ -13,13 +13,7 @@ module RailsConsoleAi
     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)
-        },
+        { content: version.content },
         edited_by: params[:edited_by].presence || 'web',
         change_note: "Restored from version ##{version.id}"
       )

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
@@ -26,37 +26,7 @@ module RailsConsoleAi
     end
 
     def new
-      @skill = Skill.new
-    end
-
-    # POST /skills/import — accepts a pasted .md blob in params[:content], parses
-    # YAML frontmatter + body, and re-renders `new` with the fields pre-populated.
-    # The user reviews + clicks Create skill to actually persist (normal proposed-
-    # status + version-row flow applies).
-    def import
-      content = params[:content].to_s
-      if content.strip.empty?
-        redirect_to new_skill_path, alert: 'Nothing to parse — paste the .md content into the box first.'
-        return
-      end
-
-      parsed = SkillLoader.parse(content)
-      if parsed.nil? || parsed['name'].to_s.strip.empty?
-        redirect_to new_skill_path,
-                    alert: 'Could not parse. Expected YAML frontmatter (between `---` lines) with at least a `name` field, followed by a markdown body.'
-        return
-      end
-
-      @skill = Skill.new(
-        name: parsed['name'],
-        description: parsed['description'],
-        body: parsed['body']
-      )
-      @skill.tags = Array(parsed['tags'])
-      @skill.bypass_guards_for_methods = Array(parsed['bypass_guards_for_methods'])
-
-      flash.now[:notice] = "Parsed \"#{parsed['name']}\" from pasted content. Review the fields below and click Create skill to save to the DB."
-      render :new
+      @skill = Skill.new(content: new_skill_template)
     end
 
     def create
@@ -130,10 +100,8 @@ module RailsConsoleAi
       @from = @skill.versions.find(params[:from])
       @to   = params[:to].present? ? @skill.versions.find(params[:to]) : nil
       # If `to` is omitted, diff against the current skill.
-      @to_label = @to ? "Version ##{@to.id}" : 'Current'
-      @to_body  = @to ? @to.body : @skill.body
-      @to_tags  = @to ? Array(@to.tags) : Array(@skill.tags)
-      @to_bypass = @to ? Array(@to.bypass_guards_for_methods) : Array(@skill.bypass_guards_for_methods)
+      @to_label   = @to ? "Version ##{@to.id}" : 'Current'
+      @to_content = @to ? @to.content : @skill.content
     end
 
     private
@@ -165,25 +133,28 @@ module RailsConsoleAi
     end
 
     def skill_params
-      {
-        name:                       params.require(:skill)[:name],
-        description:                params[:skill][:description],
-        body:                       params[:skill][:body],
-        tags:                       split_csv(params[:skill][:tags]),
-        bypass_guards_for_methods:  split_lines(params[:skill][:bypass_guards_for_methods])
-      }
+      { content: params.require(:skill)[:content].to_s }
     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 new_skill_template
+      <<~MD
+        ---
+        name:
+        description:
+        tags: []
+        bypass_guards_for_methods: []
+        ---
+
+        ## When to use
+
+        ## Recipe
 
-    def split_lines(str)
-      str.to_s.split(/[\r\n]+/).map(&:strip).reject(&:empty?)
+        ## Notes
+      MD
     end
 
     def slugify(name)