rails_console_ai 0.35.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37ef99b1cc4572e89283e5210b15e6110bac2b0adc758a1b7d222c603c4557c2
-  data.tar.gz: 511f76003fdc00ce0104b506eaa71d7de918e3cf1f62eebd395308461caeefd1
+  metadata.gz: 0b332f5004d3946e6ad603de4c29198ebf79e912a095248d8c76220edd991b59
+  data.tar.gz: 05c4c328d8cf1f6419c3794505dce7279c9fa30d142d4d56f7fcdfa52e61ccad
 SHA512:
-  metadata.gz: e6cb2ccc4f03fbcafff6d7edcace1c80fd76a99692404f7e05aa039e9276665b07e03ab70b12043635b37742c5e05ffe1fa9fd42f77e25de6daff329c90e0dfc
-  data.tar.gz: ee6acd8f33f2d13c921832fd1d4470e9d08bd8a795ec45d7ebb3c7b67ae7ca3fb6475b46796192dcd4a0b2a48d66b0bbb8bc2b2e47e498e9785c12dad7eefba4
+  metadata.gz: 3a85e28e935511e28dd3ac53fe105cfd76958bcb6cbdde4589ece30e28cfad64187f0a84c36ed76b65a096460dc304f37002baa1e549f8058bc45d23995bd0c1
+  data.tar.gz: bad4c6371a4897d0363e02a2569161cd874b5cb83319108e7bf9002c311e4559988ff6bb369802cd2da3897701d5c60129b1468cf1a650842aefc53b7c14d8d9

data/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.38.0]
+
+- Support the Claude Sonnet 5.5 model family
+- Show more detail in Bedrock error messages
+- Link Slack sessions to a session page showing the Slack thread
+
+## [0.37.0]
+
+- Add artifacts for saving and viewing output in the browser
+- Name artifacts and revise them in place
+- Add a Copy button to the artifact viewer
+- Surface responses that were cut off at the token limit
+- Give sub-agents access to the memory index
+- Support Claude Opus 5.5 as the default model
+- Add a cheaper Sonnet model tier
+
+## [0.36.0]
+
+- Add an OpenRouter provider with access to 400+ models
+- Report exact costs when a provider returns them
+- Run any skill or agent as a slash command from the console
+- Add a live completion menu for slash commands
+- Support choosing between the Reline and Readline line editors
+- Fix cost reporting in the Slack bot
+
 ## [0.35.0]
 
 - Extend prompt caching to the full conversation history

data/README.md

@@ -81,13 +81,42 @@ end
 | `/compact` | Compress history into a summary (saves tokens) |
 | `/usage` | Show token stats |
 | `/cost` | Show per-model cost breakdown |
-| `/think` | Upgrade to thinking model (Opus) for the rest of the session |
+| `/think` | Switch to the thinking tier (Opus 5.5 at high effort) for the rest of the session |
+| `/unthink` | Switch back to the default tier |
+| `/cheap` | Switch to the cheap tier (Sonnet 5) for faster, cheaper routine lookups |
 | `/debug` | Toggle debug summaries (context stats, cost per call) |
 | `/expand <id>` | Show full omitted output |
 | `/context` | Show conversation history as sent to the LLM |
 | `/system` | Show the system prompt |
 | `/name <label>` | Name the session for easy resume |
 
+#### Running skills and agents from the prompt
+
+Every skill and agent is also a slash command, under a slug built from its name —
+"Restart user trial" becomes `/restart-user-trial`. Type `/` and a menu of everything
+available appears as you type; press Enter on a bare `/` to print the full list.
+
+```
+ai> /restart-user-trial user 4821
+ai> /find-shard jess@example.com
+```
+
+The two behave differently on purpose:
+
+- **A skill runs here.** Its recipe is prepended to your request and its guard
+  bypasses are installed on the live executor, so the assistant follows the
+  procedure in the current conversation with full context.
+- **An agent runs elsewhere.** It gets its own context and tool loop, and only its
+  summary comes back into the conversation — the same isolation `delegate_task`
+  gives the model, now available to you directly. Its tokens are billed to the session.
+
+Anything after the command name is passed along as your request. A skill invoked
+bare (`/restart-user-trial`) just runs its procedure.
+
+Completion needs [Reline](https://github.com/ruby/reline), bundled with Ruby >= 2.7.
+Without it the gem falls back to Readline, where Tab completes instead of a live menu.
+Force one or the other with `c.line_editor = :reline` / `:readline` (default `:auto`).
+
 Prefix input with `>` to run Ruby directly (no LLM round-trip). The result is added to conversation context.
 
 Say "think harder" in any query to auto-upgrade to the thinking model for that session. After 5+ tool rounds, you'll also be prompted to switch.
@@ -96,7 +125,7 @@ Say "think harder" in any query to auto-upgrade to the thinking model for that s
 
 - **Tool use** — AI introspects your schema, models, files (Ruby, ERB, HTML, JS, CSS, YAML, etc), and code to write accurate queries
 - **Multi-step plans** — complex tasks are broken into steps, executed sequentially with `step1`/`step2` references
-- **Two-tier models** — defaults to Sonnet for speed/cost; `/think` upgrades to Opus when you need it
+- **Three model tiers** — defaults to Opus 5.5 at medium effort; `/think` raises it to high effort, `/cheap` drops to Sonnet 5
 - **Cost tracking** — `/cost` shows per-model token usage and estimated spend
 - **Skills** — predefined procedures with guard bypasses that the AI activates on demand
 - **Memories** — AI saves what it learns about your app across sessions
@@ -105,6 +134,7 @@ Say "think harder" in any query to auto-upgrade to the thinking model for that s
 - **History compaction** — `/compact` summarizes long conversations to reduce cost and latency
 - **Output trimming** — older execution outputs are automatically replaced with references; the LLM can recall them on demand via `recall_output`, and you can `/expand <id>` to see them
 - **Debug mode** — `/debug` shows context breakdown, token counts, and per-call cost estimates before and after each LLM call
+- **Artifacts** — reports, exports and pages are saved and served at `/rails_console_ai/artifacts` instead of scrolling past in the console
 - **Sub-agents** — delegate multi-step investigations to a separate LLM context that returns only a concise summary, keeping the main conversation lean
 - **Safe mode** — configurable guards that block side effects (DB writes, HTTP mutations, email delivery) during AI code execution
 
@@ -156,7 +186,7 @@ The markdown body becomes additional system prompt instructions for the sub-agen
 4. It runs the investigation (up to `max_rounds` tool calls)
 5. The main conversation receives only: `"Sub-agent result: User 56653 is on shard 5."`
 
-Sub-agents have access to read-only memory tools (`recall_memory`, `recall_memories`), code execution (`execute_code`), and all schema/code introspection tools. They cannot ask the user questions, write memories, or spawn further sub-agents.
+Sub-agents have access to read-only memory tools (`recall_memory`, `recall_memories`), code execution (`execute_code`), and all schema/code introspection tools. Their system prompt carries the same memory index and pinned memories as the main conversation, so they check memories before investigating. They cannot ask the user questions, write memories, activate skills, or spawn further sub-agents.
 
 ### Configuration
 
@@ -280,9 +310,40 @@ Skills and global `bypass_guards_for_methods` coexist — use config-level bypas
 - **`d`** at the `Execute? [y/N/danger]` prompt disables guards for that single execution
 - When a guard blocks an operation, the user is prompted: `Re-run with safe mode disabled? [y/N]`
 
+## Artifacts
+
+When the answer is a document rather than a sentence — a report, an export, a page — the
+assistant calls `save_artifact` and hands back a URL instead of printing it into the console.
+Artifacts are listed at `/rails_console_ai/artifacts`, named with the day they were made
+(`20260911_Q3 churn summary`, addressed as `20260911-q3-churn-summary`), and saving under an
+existing name replaces it and bumps its revision.
+
+**Saving from Ruby.** Anything the assistant writes into `save_artifact` has to fit inside its
+response, and a response has a hard output-token cap — a 40KB file does not fit. Rather than
+being cut off mid-argument, content the console already holds should go straight in:
+
+```ruby
+html = S3.read_file("mathnasium_calendar_move_plan.html")
+RailsConsoleAi.save_artifact(name: "Mathnasium migration", content: html)
+# => "https://secure.example.com/rails_console_ai/artifacts/20260911-mathnasium-migration"
+```
+
+The bytes never pass through the model, so this is also the only way to store something
+*verbatim* — anything retyped by the assistant is its recollection of the file, not the file.
+`content_type:` is inferred when omitted, and the naming and revision rules are the same as the
+tool's. The assistant knows to reach for this itself when content is already in a variable.
+
 ## LLM Providers
 
-RailsConsoleAi supports four LLM providers. Each uses a two-tier model system: a default model for speed/cost, and a thinking model activated via `/think` or by saying "think harder".
+RailsConsoleAi supports five LLM providers. Each session runs on one of three tiers:
+
+| Tier | Switch with | Model setting | Effort setting | Claude default |
+|---|---|---|---|---|
+| default | `/unthink` | `config.model` | `config.effort` | Opus 5.5, `medium` |
+| thinking | `/think`, or say "think harder" | `config.thinking_model` | `config.thinking_effort` | Opus 5.5, `high` |
+| cheap | `/cheap` | `config.cheap_model` | none sent | Sonnet 5 |
+
+Effort is sent as Anthropic's `output_config.effort` (`low`, `medium`, `high`, `xhigh`, `max`) and only to Claude models that accept it. It is omitted for Haiku 4.5 and non-Claude models. Set `config.effort = nil` to leave the model's own default in place.
 
 ### Anthropic (default)
 
@@ -293,7 +354,7 @@ RailsConsoleAi.configure do |config|
 end
 ```
 
-Default model: `claude-sonnet-5`. Thinking model: `claude-opus-5`. Prompt caching is enabled automatically.
+Default and thinking model: `claude-opus-5-5`. Cheap model: `claude-sonnet-5`. Prompt caching is enabled automatically.
 
 ### OpenAI
 
@@ -306,6 +367,29 @@ end
 
 Default model: `gpt-5.3-codex`. OpenAI applies prompt caching automatically on their end for prompts over 1024 tokens.
 
+### OpenRouter
+
+Access 400+ models (Claude, GPT, Gemini, DeepSeek, Llama, etc.) via OpenRouter with unified OpenAI-compatible API. Automatic prompt caching for Anthropic models, real-time cost tracking, and provider sticky routing for cache hits.
+
+```ruby
+RailsConsoleAi.configure do |config|
+  config.provider = :openrouter
+  config.api_key = 'sk-or-...'  # or set OPENROUTER_API_KEY env var
+  # config.model = 'anthropic/claude-opus-5.5'  # default
+  # config.openrouter_site_url = 'https://yoursite.com'  # attribution
+  # config.openrouter_app_name = 'MyApp'                # shown on openrouter.ai
+end
+```
+
+Default and thinking model: `anthropic/claude-opus-5.5`. Cheap model: `anthropic/claude-sonnet-5`. Effort is sent as OpenRouter's `verbosity` parameter.
+
+**Features:**
+- **Exact cost reporting**: The gem reports the actual USD cost from OpenRouter (`$0.0431` vs estimated `~$0.04`)
+- **Automatic prompt caching**: Anthropic-family models (`anthropic/claude-*`) get a top-level `cache_control` breakpoint for multi-turn cache hits
+- **Sticky routing**: Session-based routing keeps requests on the same provider endpoint for cache warmth across the tool-use loop
+
+**Timeout note:** OpenRouter adds latency from request queueing and provider fallbacks. If you're routing to reasoning models, you may want to raise `config.timeout` above the 30s default.
+
 ### AWS Bedrock
 
 Access frontier models (Claude, Mistral, DeepSeek, Llama) via your AWS account with pay-per-token pricing. No API key needed — authentication uses the AWS SDK credential chain (IAM roles, env vars, `~/.aws/credentials`).
@@ -319,8 +403,9 @@ gem 'aws-sdk-bedrockruntime'
 RailsConsoleAi.configure do |config|
   config.provider = :bedrock
   config.bedrock_region = 'us-east-1'
-  # config.model = 'us.anthropic.claude-sonnet-5'        # default
-  # config.thinking_model = 'us.anthropic.claude-opus-5'   # default
+  # config.model = 'us.anthropic.claude-opus-5-5'           # default
+  # config.thinking_model = 'us.anthropic.claude-opus-5-5'  # default
+  # config.cheap_model = 'us.anthropic.claude-sonnet-5'     # default
 end
 ```
 
@@ -369,6 +454,9 @@ Before adopting a new Claude model, smoke-test it against the Anthropic or Bedro
 # Anthropic — provider inferred from the `claude-` prefix
 ANTHROPIC_API_KEY=sk-ant-... bin/smoke_model.rb --model claude-opus-4-8
 
+# OpenRouter — provider inferred from the `provider/model` format
+OPENROUTER_API_KEY=sk-or-... bin/smoke_model.rb --model anthropic/claude-opus-4
+
 # 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-8
@@ -391,13 +479,17 @@ Pricing, default max tokens, and parameter support (e.g. which families reject `
 
 ```ruby
 RailsConsoleAi.configure do |config|
-  config.provider = :anthropic       # :anthropic, :openai, :bedrock, :local
+  config.provider = :anthropic       # :anthropic, :openai, :openrouter, :bedrock, :local
   config.auto_execute = false         # true to skip confirmations
   config.session_logging = true       # requires ai_db_setup
   config.temperature = 0.2
   config.timeout = 30                 # HTTP timeout in seconds
   config.max_tool_rounds = 200        # safety cap on tool-use loops
   config.code_search_paths = %w[app]  # directories for list_files / search_code
+  config.line_editor = :auto          # :auto, :reline (live "/" menu), :readline
+  # Public base URL, so links the assistant hands out (artifacts) are absolute.
+  # Falls back to the app's default_url_options, then to a relative path.
+  config.base_url = 'https://secure.example.com'
 
   # Runaway-loop circuit breakers (see "Runaway sessions" below)
   config.token_nudge_threshold = 500_000    # input tokens in one tool loop → nudge model to wrap up (nil disables)
@@ -574,12 +666,12 @@ RailsConsoleAi.abort_agent(id)
 ```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)
+  use_thinking_model: true,        # run on the thinking tier (Opus 5.5 at high effort)
   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.
+- `use_thinking_model:` (default `false`) — switches the run to the thinking tier (`config.thinking_model` at `config.thinking_effort`) 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.

data/app/controllers/rails_console_ai/artifacts_controller.rb

@@ -0,0 +1,67 @@
+module RailsConsoleAi
+  class ArtifactsController < RailsConsoleAi::ApplicationController
+    before_action :load_artifact, only: [:show, :raw, :download, :destroy]
+
+    # Artifact content is written by the model, from data the model read — some
+    # of which other people wrote. Treat it as untrusted and never let it execute
+    # on this origin.
+    #
+    # `sandbox` with no tokens is the strictest form: unique opaque origin, no
+    # scripts, no forms, no popups. It is set as a *header* rather than relying on
+    # the iframe's sandbox attribute alone, because the raw URL can be opened
+    # directly in a tab, where no iframe attribute applies. nosniff stops a
+    # text/plain artifact being re-interpreted as something executable.
+    ARTIFACT_CSP = "sandbox; default-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:".freeze
+
+    def index
+      @artifacts = Artifact.newest_first
+      @q = params[:q].to_s.strip
+      unless @q.empty?
+        needle = "%#{@q.downcase}%"
+        @artifacts = @artifacts.where(
+          'LOWER(name) LIKE :q OR LOWER(COALESCE(description, \'\')) LIKE :q', q: needle
+        )
+      end
+      @artifacts = @artifacts.limit(200).to_a
+    end
+
+    def show
+    end
+
+    # The bytes themselves, sandboxed. The show page frames this URL.
+    def raw
+      send_artifact(disposition: 'inline')
+    end
+
+    def download
+      send_artifact(disposition: 'attachment')
+    end
+
+    def destroy
+      @artifact.destroy
+      redirect_to artifacts_path, notice: "Artifact \"#{@artifact.name}\" deleted."
+    end
+
+    private
+
+    def send_artifact(disposition:)
+      response.headers['Content-Security-Policy'] = ARTIFACT_CSP
+      response.headers['X-Content-Type-Options'] = 'nosniff'
+      # Belt and braces for older browsers that honour it.
+      response.headers['X-Frame-Options'] = 'SAMEORIGIN'
+
+      send_data @artifact.content,
+                type: "#{@artifact.content_type}; charset=utf-8",
+                disposition: disposition,
+                filename: @artifact.filename
+    end
+
+    # Addressed by slug, so the URL says what it points at. Tokens still resolve:
+    # links handed out before slugs existed, or shared from an older version,
+    # must keep working.
+    def load_artifact
+      @artifact = Artifact.find_by_handle(params[:id])
+      redirect_to artifacts_path, alert: 'Artifact not found.' unless @artifact
+    end
+  end
+end

data/app/helpers/rails_console_ai/sessions_helper.rb

@@ -1,17 +1,17 @@
 module RailsConsoleAi
   module SessionsHelper
-    # All four usage buckets bill at their own rate. `input_tokens` is the uncached
-    # remainder only — on a cached session it is a tiny fraction of the prompt, so
-    # pricing input+output alone reads as near-zero for the sessions that actually
-    # cost the most.
+    # The cache buckets have to be included: `input_tokens` is the uncached
+    # remainder only, so on a well-cached session pricing input+output alone reads
+    # as near-zero for exactly the sessions that cost the most.
     def estimated_cost(session)
-      pricing = Configuration.pricing_for(session.model)
-      return nil unless pricing
-
-      (session.input_tokens * pricing[:input]) +
-        (session.output_tokens * pricing[:output]) +
-        (session.try(:cache_read_tokens).to_i * pricing[:cache_read]) +
-        (session.try(:cache_write_tokens).to_i * pricing[:cache_write])
+      Configuration.estimate_cost(
+        session.model,
+        input: session.input_tokens,
+        output: session.output_tokens,
+        cache_read: session.try(:cache_read_tokens).to_i,
+        cache_write: session.try(:cache_write_tokens).to_i,
+        cache_ttl: RailsConsoleAi.configuration.resolved_cache_ttl
+      )
     end
 
     def format_cost(session)

data/app/models/rails_console_ai/artifact.rb

@@ -0,0 +1,231 @@
+require 'securerandom'
+require 'rails_console_ai/slash_commands'
+
+module RailsConsoleAi
+  # A file the assistant produced — an HTML report, a CSV extract, a JSON dump —
+  # kept so it can be looked at in the admin UI instead of scrolling past in the
+  # console. Unlike skills and agents these are outputs, not configuration, so
+  # there is no propose/approve cycle and no file-backed source.
+  class Artifact < ActiveRecord::Base
+    self.table_name = 'rails_console_ai_artifacts'
+
+    # Content types the UI knows how to serve. Anything outside this list is
+    # rejected rather than passed through: the value reaches a Content-Type
+    # header, and letting the model choose it freely is how you end up serving
+    # something the browser treats as a script on your own origin.
+    CONTENT_TYPES = {
+      'text/html'        => { ext: 'html', renders: true },
+      'text/markdown'    => { ext: 'md',   renders: false },
+      'text/csv'         => { ext: 'csv',  renders: false },
+      'application/json' => { ext: 'json', renders: false },
+      'text/plain'       => { ext: 'txt',  renders: false }
+    }.freeze
+
+    # A generated report is a few hundred KB at the very outside. The cap is here
+    # because the content lands in a text column and in a single console turn's
+    # memory, and a runaway generation shouldn't be able to fill either.
+    MAX_BYTES = 2_000_000
+
+    belongs_to :session,
+               class_name: 'RailsConsoleAi::Session',
+               foreign_key: :session_id,
+               optional: true
+
+    validates :name, presence: true, length: { maximum: 255 }
+    validates :slug, presence: true, uniqueness: { case_sensitive: false }
+    validates :content, presence: true
+    validates :content_type, inclusion: {
+      in: CONTENT_TYPES.keys,
+      message: "must be one of: #{CONTENT_TYPES.keys.join(', ')}"
+    }
+    validate :content_within_limit
+
+    before_validation :assign_token
+    before_validation :assign_slug
+    before_validation :measure_content
+
+    scope :newest_first, -> { order(created_at: :desc) }
+
+    def self.connection
+      klass = RailsConsoleAi.configuration.connection_class
+      if klass
+        klass = Object.const_get(klass) if klass.is_a?(String)
+        klass.connection
+      else
+        super
+      end
+    end
+
+    # False when the gem's tables haven't been installed, so callers can say
+    # "run ai_db_setup" instead of surfacing a raw ActiveRecord error.
+    def self.available?
+      connection.table_exists?(table_name)
+    rescue ::ActiveRecord::ActiveRecordError, ::ActiveRecord::NoDatabaseError
+      false
+    end
+
+    def self.find_by_token!(token)
+      find_by!(token: token.to_s)
+    end
+
+    # How the assistant addresses an artifact across turns and sessions: the
+    # slug it was given, the name a human typed, or the token from a URL. Name
+    # is matched case-insensitively because the user will not retype it exactly.
+    def self.find_by_handle(handle)
+      handle = handle.to_s.strip
+      return nil if handle.empty?
+
+      slug = RailsConsoleAi::SlashCommands.slugify(handle)
+      find_by(slug: slug) ||
+        find_by(slug: handle) ||
+        where('LOWER(name) = ?', handle.downcase).first ||
+        find_by(token: handle) ||
+        most_recent_matching(handle)
+    end
+
+    # The handle a new artifact with this name would take, minus any suffix the
+    # uniqueness check would add.
+    def self.slug_for(name)
+      RailsConsoleAi::SlashCommands.slugify(name)
+    end
+
+    # Leading "20260911_" / "20260911-", as added to new names.
+    DATE_PREFIX = /\A\d{8}[_-]/.freeze
+
+    def self.date_prefix_for(time = Time.now)
+      "#{time.strftime('%Y%m%d')}_"
+    end
+
+    # The slug mirrors the name, date and all, so the two always correspond:
+    # "20260911_Dog on a bike" is addressed as 20260911-dog-on-a-bike.
+    def self.base_slug_for(name)
+      slug_for(name).sub(DATE_PREFIX, '')
+    end
+
+    def base_slug
+      slug.to_s.sub(DATE_PREFIX, '')
+    end
+
+    # Resolves an undated handle to the most recent artifact carrying it, so a
+    # user can say "the churn report" without knowing which day's it was.
+    # Only a convenience for reading and deleting — saving matches exactly.
+    def self.most_recent_matching(handle)
+      base = base_slug_for(handle)
+      return nil if base.empty?
+
+      candidates = where('slug = ? OR slug LIKE ?', base, "________-#{base}")
+                   .order(created_at: :desc).to_a
+      candidates.find { |a| a.base_slug == base }
+    end
+
+    # Applies the date stamp unless the caller already supplied one, or the app
+    # has turned stamping off.
+    def self.stamped_name(name, time = Time.now)
+      name = name.to_s.strip
+      # A blank name must stay blank: stamping it would smuggle an unnamed
+      # artifact past the presence validation as "20260911_".
+      return name if name.empty?
+      return name unless RailsConsoleAi.configuration.artifact_date_prefix
+      return name if name =~ DATE_PREFIX
+      "#{date_prefix_for(time)}#{name}"
+    end
+
+    # The one place an artifact is written. Both callers reach it: the
+    # save_artifact tool, which carries content the model typed out, and
+    # RailsConsoleAi.save_artifact, which carries a string the console already
+    # holds. Saving under a name that already exists is an edit, not a second
+    # copy — that is what lets a user say "update the churn report" two sessions
+    # later. Returns the (possibly unsaved) record; callers report its errors.
+    def self.store(name:, content:, content_type:, description: nil)
+      stamped = stamped_name(name)
+      existing = find_by(slug: slug_for(stamped))
+      artifact = existing || new
+
+      artifact.name = stamped
+      artifact.content_type = content_type
+      artifact.content = content
+      artifact.description = description if description || artifact.new_record?
+      artifact.session_id = RailsConsoleAi.current_session_id
+      artifact.created_by ||= RailsConsoleAi.current_user
+      artifact.revision = artifact.revision.to_i + 1 if existing
+
+      artifact.save
+      artifact
+    end
+
+    # Only consulted when a caller omits the type. Deliberately narrow: the value
+    # becomes a Content-Type header, so anything it isn't confident about lands on
+    # text/plain rather than being guessed into something the browser will run.
+    def self.infer_content_type(content)
+      sample = content.to_s.lstrip[0, 512].to_s
+      return 'text/html' if sample.match?(/\A<(!doctype html|html|\?xml|!--)/i) || sample.match?(/\A\s*<[a-z]+[\s>]/i)
+      return 'application/json' if sample.match?(/\A[\[{]/)
+      'text/plain'
+    end
+
+    def extension
+      CONTENT_TYPES.dig(content_type, :ext) || 'txt'
+    end
+
+    # Whether the show page offers a rendered preview. Only HTML gets one, and
+    # even then it is rendered inside a sandboxed frame — see ArtifactsController.
+    def renderable?
+      !!CONTENT_TYPES.dig(content_type, :renders)
+    end
+
+    def filename
+      base = name.to_s.strip.downcase
+        .gsub(/[^a-z0-9]+/, '-')
+        .gsub(/-+/, '-')
+        .sub(/\A-/, '').sub(/-\z/, '')
+      base = "artifact-#{id}" if base.empty?
+      "#{base}.#{extension}"
+    end
+
+    def human_size
+      bytes = byte_size.to_i
+      return "#{bytes} B" if bytes < 1024
+      return "#{(bytes / 1024.0).round(1)} KB" if bytes < 1024 * 1024
+      "#{(bytes / 1024.0 / 1024.0).round(1)} MB"
+    end
+
+    private
+
+    def assign_token
+      self.token = SecureRandom.hex(16) if token.to_s.empty?
+    end
+
+    def assign_slug
+      return unless slug.to_s.empty?
+
+      base = self.class.slug_for(name)
+      # A name with nothing sluggable in it leaves just the date stamp, which
+      # would collide with the next such name saved the same day.
+      # The separator is already gone when nothing followed it, so match the
+      # date with the separator optional.
+      if base.sub(/\A\d{8}[_-]?/, '').empty?
+        stamp = base[/\A\d{8}/]
+        base = [stamp, "artifact-#{SecureRandom.hex(4)}"].compact.join('-')
+      end
+
+      candidate = base
+      n = 1
+      # Only reached when the caller did not mean to update an existing artifact
+      # (save_artifact looks the slug up first), so the newcomer takes a suffix.
+      while self.class.where(slug: candidate).where.not(id: id).exists?
+        n += 1
+        candidate = "#{base}-#{n}"
+      end
+      self.slug = candidate
+    end
+
+    def measure_content
+      self.byte_size = content.to_s.bytesize
+    end
+
+    def content_within_limit
+      return if content.to_s.bytesize <= MAX_BYTES
+      errors.add(:content, "is #{content.to_s.bytesize} bytes, over the #{MAX_BYTES} byte limit")
+    end
+  end
+end

data/app/views/layouts/rails_console_ai/application.html.erb

@@ -155,6 +155,7 @@
       <a href="<%= rails_console_ai.skills_path %>">Skills</a>
       <a href="<%= rails_console_ai.memories_path %>">Memories</a>
       <a href="<%= rails_console_ai.agents_path %>">Agents</a>
+      <a href="<%= rails_console_ai.artifacts_path %>">Artifacts</a>
     </div>
   </div>
   <div class="container">

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

@@ -0,0 +1,60 @@
+<div class="btn-bar">
+  <form method="get" action="<%= artifacts_path %>" style="margin-left:auto;">
+    <input type="text" name="q" value="<%= @q %>" placeholder="Search artifacts…" style="padding:6px 10px; border:1px solid #ccc; border-radius:4px;">
+  </form>
+</div>
+
+<% if @artifacts.empty? %>
+  <div class="meta-card">
+    <% if @q.present? %>
+      <p class="text-muted">No artifacts match “<%= @q %>”. <%= link_to 'Show all', artifacts_path %>.</p>
+    <% else %>
+      <p class="text-muted">
+        No artifacts yet. The assistant creates them with the <code>save_artifact</code> tool —
+        ask it for a report, summary or export and it will save one here instead of printing it into the console.
+      </p>
+    <% end %>
+  </div>
+<% else %>
+  <table>
+    <thead>
+      <tr>
+        <th>Name</th>
+        <th title="How the assistant addresses this artifact">Handle</th>
+        <th>Description</th>
+        <th>Type</th>
+        <th>Size</th>
+        <th>Created by</th>
+        <th>Session</th>
+        <th>Updated</th>
+        <th></th>
+      </tr>
+    </thead>
+    <tbody>
+      <% @artifacts.each do |a| %>
+        <tr>
+          <td>
+            <strong><%= link_to a.name, artifact_path(a.slug) %></strong>
+            <% if a.revision.to_i > 1 %>
+              <span class="badge badge-status-queued">rev <%= a.revision %></span>
+            <% end %>
+          </td>
+          <td class="mono"><%= a.slug %></td>
+          <td class="query-cell"><%= a.description %></td>
+          <td class="mono"><%= a.content_type %></td>
+          <td class="mono"><%= a.human_size %></td>
+          <td><%= a.created_by || '—' %></td>
+          <td>
+            <% if a.session_id %>
+              <%= link_to "##{a.session_id}", session_path(a.session_id) %>
+            <% else %>
+              —
+            <% end %>
+          </td>
+          <td><%= a.updated_at.strftime('%Y-%m-%d %H:%M') %></td>
+          <td><%= link_to 'Download', download_artifact_path(a.slug), class: 'btn btn-secondary' %></td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+<% end %>