rails_console_ai 0.36.0 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae704dc4b0f74645775e86661d9cb6d004df5c1e0b338ab012564d87317bff4c
-  data.tar.gz: 0f0f9c24eb4c7aad94175bde55c36571df238d3b067bbe124a49d341f7df0e03
+  metadata.gz: 0b332f5004d3946e6ad603de4c29198ebf79e912a095248d8c76220edd991b59
+  data.tar.gz: 05c4c328d8cf1f6419c3794505dce7279c9fa30d142d4d56f7fcdfa52e61ccad
 SHA512:
-  metadata.gz: 77f9088650c56287f17f4ef4e498537fdb6ddfc2a62b558085aa0cd717f02ddaa44379d427416bcc5b4ac2a6826105d361b1e9a25caacb400f25f60f369c4d43
-  data.tar.gz: 03f1b9c35af746872ac7ec9b9a4cfb5e630bcf66b006cef254501efdef0b4d04187be161fd544ffc52248cee85fe45a1ec3e01fc62f371db5c3a453b60705971
+  metadata.gz: 3a85e28e935511e28dd3ac53fe105cfd76958bcb6cbdde4589ece30e28cfad64187f0a84c36ed76b65a096460dc304f37002baa1e549f8058bc45d23995bd0c1
+  data.tar.gz: bad4c6371a4897d0363e02a2569161cd874b5cb83319108e7bf9002c311e4559988ff6bb369802cd2da3897701d5c60129b1468cf1a650842aefc53b7c14d8d9

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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

data/README.md

@@ -81,7 +81,9 @@ 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 |
@@ -123,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
@@ -132,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
 
@@ -183,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
 
@@ -307,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 five 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)
 
@@ -320,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
 
@@ -341,13 +375,13 @@ Access 400+ models (Claude, GPT, Gemini, DeepSeek, Llama, etc.) via OpenRouter w
 RailsConsoleAi.configure do |config|
   config.provider = :openrouter
   config.api_key = 'sk-or-...'  # or set OPENROUTER_API_KEY env var
-  # config.model = 'anthropic/claude-sonnet-5'  # default
+  # 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 model: `anthropic/claude-sonnet-5`. Thinking model: `anthropic/claude-opus-5`.
+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`)
@@ -369,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
 ```
 
@@ -452,6 +487,9 @@ RailsConsoleAi.configure do |config|
   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)
@@ -628,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/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 %>

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

@@ -0,0 +1,119 @@
+<div class="btn-bar">
+  <%= link_to '← All artifacts', artifacts_path, class: 'btn btn-secondary' %>
+  <%= link_to 'Download', download_artifact_path(@artifact.slug), class: 'btn' %>
+  <%= link_to 'Open raw', raw_artifact_path(@artifact.slug), class: 'btn btn-secondary', target: '_blank', rel: 'noopener noreferrer' %>
+  <%# Copies the artifact's source, exactly as stored. Fetches the raw URL on
+      click rather than embedding a second copy of the content in this page. %>
+  <button type="button" class="btn btn-secondary" id="copy-artifact"
+          data-url="<%= raw_artifact_path(@artifact.slug) %>"
+          title="Copy the artifact's content to the clipboard">Copy</button>
+  <%# button_to, not link_to: the engine layout loads no JavaScript, so a
+      data-method link would quietly do nothing. Matches skills/agents. %>
+  <span style="margin-left:auto;">
+    <%= button_to 'Delete', artifact_path(@artifact.slug), method: :delete,
+          class: 'btn btn-danger', form: { style: 'display:inline' },
+          data: { confirm: 'Delete this artifact? This cannot be undone.' } %>
+  </span>
+</div>
+
+<div class="meta-card">
+  <h2 style="font-size:18px; margin-bottom:4px;"><%= @artifact.name %></h2>
+  <% if @artifact.description.present? %>
+    <p class="text-muted" style="margin-bottom:16px;"><%= @artifact.description %></p>
+  <% end %>
+  <div class="meta-grid">
+    <div class="meta-item">
+      <label title="How the assistant addresses this artifact">Handle</label>
+      <span class="mono"><%= @artifact.slug %></span>
+    </div>
+    <div class="meta-item"><label>Revision</label><span><%= @artifact.revision %></span></div>
+    <div class="meta-item"><label>Type</label><span class="mono"><%= @artifact.content_type %></span></div>
+    <div class="meta-item"><label>Size</label><span><%= @artifact.human_size %></span></div>
+    <div class="meta-item"><label>Created by</label><span><%= @artifact.created_by || '—' %></span></div>
+    <div class="meta-item">
+      <label>Session</label>
+      <span>
+        <% if @artifact.session_id %>
+          <%= link_to "##{@artifact.session_id}", session_path(@artifact.session_id) %>
+        <% else %>
+          —
+        <% end %>
+      </span>
+    </div>
+    <div class="meta-item"><label>Created</label><span><%= @artifact.created_at.strftime('%Y-%m-%d %H:%M') %></span></div>
+    <div class="meta-item"><label>Updated</label><span><%= @artifact.updated_at.strftime('%Y-%m-%d %H:%M') %></span></div>
+  </div>
+</div>
+
+<% if @artifact.renderable? %>
+  <div class="meta-card" style="padding:0; overflow:hidden;">
+    <%#
+      Sandboxed with no allow-same-origin and no allow-scripts: the frame gets an
+      opaque origin, so even if the content carried a script it could not run, and
+      could not reach this page's session if it did. The same restrictions are set
+      as a CSP header on the raw response, which is what protects the "Open raw"
+      link where no iframe attribute applies.
+    %>
+    <iframe src="<%= raw_artifact_path(@artifact.slug) %>"
+            sandbox
+            referrerpolicy="no-referrer"
+            title="<%= @artifact.name %>"
+            style="width:100%; height:70vh; border:0; background:#fff; display:block;"></iframe>
+  </div>
+  <p class="text-muted" style="font-size:12px; margin-top:8px;">
+    Rendered in a sandboxed frame — scripts and network requests are blocked, so inline CSS shows but JavaScript will not run.
+  </p>
+<% else %>
+  <div class="terminal">
+    <pre><%= @artifact.content %></pre>
+  </div>
+<% end %>
+
+<%# The only JavaScript in the admin UI. nonce: true picks up the host app's CSP
+    nonce when it has one, and is a no-op otherwise. %>
+<%= javascript_tag nonce: true do %>
+  (function () {
+    var button = document.getElementById('copy-artifact');
+    if (!button) return;
+    var label = button.textContent;
+
+    function flash(text) {
+      button.textContent = text;
+      setTimeout(function () { button.textContent = label; }, 2000);
+    }
+
+    // navigator.clipboard needs a secure context (https or localhost). Over
+    // plain http elsewhere, fall back to the old textarea + execCommand route.
+    function writeClipboard(text) {
+      if (navigator.clipboard && window.isSecureContext) {
+        return navigator.clipboard.writeText(text);
+      }
+      return new Promise(function (resolve, reject) {
+        var area = document.createElement('textarea');
+        area.value = text;
+        area.setAttribute('readonly', '');
+        area.style.position = 'fixed';
+        area.style.top = '-1000px';
+        document.body.appendChild(area);
+        area.select();
+        var ok = false;
+        try { ok = document.execCommand('copy'); } catch (e) { ok = false; }
+        document.body.removeChild(area);
+        ok ? resolve() : reject(new Error('execCommand copy failed'));
+      });
+    }
+
+    button.addEventListener('click', function () {
+      button.disabled = true;
+      fetch(button.getAttribute('data-url'), { credentials: 'same-origin' })
+        .then(function (response) {
+          if (!response.ok) throw new Error('HTTP ' + response.status);
+          return response.text();
+        })
+        .then(writeClipboard)
+        .then(function () { flash('Copied'); })
+        .catch(function () { flash('Copy failed'); })
+        .then(function () { button.disabled = false; });
+    });
+  })();
+<% end %>