rails_console_ai 0.29.0 → 0.30.0

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

@@ -0,0 +1,94 @@
+<%
+  # @skill can be either a Skill AR record or a Hash from a file source.
+  is_db = @skill.is_a?(RailsConsoleAi::Skill)
+  name = is_db ? @skill.name : @skill['name']
+  description = is_db ? @skill.description : @skill['description']
+  body = is_db ? @skill.body : @skill['body']
+  tags = is_db ? Array(@skill.tags) : Array(@skill['tags'])
+  bypass = is_db ? Array(@skill.bypass_guards_for_methods) : Array(@skill['bypass_guards_for_methods'])
+  file_key = is_db ? nil : @skill['file_key']
+  status   = is_db ? @skill.status : 'approved'  # file skills are implicitly approved
+%>
+
+<%= link_to '← All skills', skills_path, class: 'back-link' %>
+
+<% if is_db && !@skill.approved? %>
+  <div class="flash flash-alert" style="margin-bottom:16px;">
+    <strong>Awaiting approval.</strong> The AI cannot activate this skill until a human approves it.
+    Review the recipe and bypass-guard list below, then click <strong>Approve</strong>.
+  </div>
+<% end %>
+
+<div class="meta-card">
+  <h2 style="margin-bottom:8px;">
+    <%= name %>
+    <% if is_db %>
+      <span class="badge source-db">DB</span>
+      <% if @skill.approved? %>
+        <span class="badge status-approved">APPROVED</span>
+      <% else %>
+        <span class="badge status-proposed">PROPOSED</span>
+      <% end %>
+    <% else %>
+      <span class="badge source-file">FILE</span>
+    <% end %>
+  </h2>
+  <p class="text-muted"><%= description %></p>
+  <div class="meta-grid" style="margin-top:16px;">
+    <div class="meta-item"><label>Tags</label><span><%= tags.empty? ? '—' : tags.join(', ') %></span></div>
+    <div class="meta-item"><label>Bypass guards</label><span><%= bypass.empty? ? '—' : bypass.join(', ') %></span></div>
+    <% if is_db %>
+      <div class="meta-item"><label>Updated</label><span><%= @skill.updated_at.strftime('%Y-%m-%d %H:%M') %></span></div>
+      <div class="meta-item"><label>Versions</label><span><%= @skill.versions.count %></span></div>
+      <div class="meta-item"><label>Times activated</label><span><%= @skill.use_count %></span></div>
+      <div class="meta-item"><label>Last activated</label><span><%= @skill.last_used_at&.strftime('%Y-%m-%d %H:%M') || 'never' %></span></div>
+      <% if @skill.approved? %>
+        <div class="meta-item"><label>Approved by</label><span><%= @skill.approved_by || '—' %></span></div>
+        <div class="meta-item"><label>Approved at</label><span><%= @skill.approved_at&.strftime('%Y-%m-%d %H:%M') || '—' %></span></div>
+      <% end %>
+    <% else %>
+      <div class="meta-item"><label>Path</label><span class="mono"><%= file_key %></span></div>
+    <% end %>
+  </div>
+</div>
+
+<div class="btn-bar">
+  <% if is_db %>
+    <% unless @skill.approved? %>
+      <%= form_with url: approve_skill_path(@skill), method: :post, local: true, style: 'display:inline' do %>
+        <input type="text" name="approved_by" placeholder="Your name (required)" style="padding:7px 10px; border:1px solid #ccc; border-radius:4px; margin-right:6px;">
+        <button type="submit" class="btn btn-danger" data-confirm="Approve this skill? The AI will then be able to activate it and use its guard bypasses.">Approve</button>
+      <% end %>
+    <% end %>
+    <%= link_to 'Edit', edit_skill_path(@skill), class: 'btn' %>
+    <%= link_to 'Versions', skill_versions_path(@skill), class: 'btn btn-secondary' %>
+    <%= button_to 'Delete', skill_path(@skill), method: :delete, class: 'btn btn-danger', form: { style: 'display:inline' }, data: { confirm: 'Delete this skill? Past versions remain in history.' } %>
+  <% end %>
+</div>
+
+<h3 style="margin-bottom:8px;">Recipe</h3>
+<div class="markdown-body"><%= body %></div>
+
+<% if is_db && @versions && @versions.any? %>
+  <h3 style="margin:24px 0 8px;">Recent versions</h3>
+  <div class="versions-list">
+    <% @versions.first(5).each do |v| %>
+      <div class="ver-row">
+        <div>
+          <strong>v<%= v.id %></strong>
+          <span class="ver-meta">— <%= v.created_at.strftime('%Y-%m-%d %H:%M') %> by <%= v.edited_by || 'unknown' %></span>
+          <% if v.status == 'approved' %><span class="badge status-approved">APPROVED</span><% end %>
+          <% if v.change_note.present? %><div class="ver-meta"><%= v.change_note %></div><% end %>
+        </div>
+        <div>
+          <%= link_to 'View', skill_version_path(@skill, v) %>
+          ·
+          <%= link_to 'Diff vs current', diff_skills_path(skill_id: @skill.id, from: v.id) %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+  <% if @versions.size > 5 %>
+    <p style="margin-top:8px;"><%= link_to "See all #{@versions.size} versions →", skill_versions_path(@skill) %></p>
+  <% end %>
+<% end %>

data/config/routes.rb

@@ -1,4 +1,46 @@
 RailsConsoleAi::Engine.routes.draw do
   root to: 'sessions#index'
   resources :sessions, only: [:index, :show]
+
+  resources :skills do
+    member do
+      post :approve
+    end
+    collection do
+      get :diff
+      post :import
+    end
+    resources :versions, only: [:index, :show], controller: 'skill_versions' do
+      member do
+        post :restore
+      end
+    end
+  end
+
+  resources :memories do
+    collection do
+      get :diff
+      post :import
+    end
+    resources :versions, only: [:index, :show], controller: 'memory_versions' do
+      member do
+        post :restore
+      end
+    end
+  end
+
+  resources :agents do
+    member do
+      post :approve
+    end
+    collection do
+      get :diff
+      post :import
+    end
+    resources :versions, only: [:index, :show], controller: 'agent_versions' do
+      member do
+        post :restore
+      end
+    end
+  end
 end

data/lib/rails_console_ai/agent_loader.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'rails_console_ai/storage/database_storage'
 
 module RailsConsoleAi
   class AgentLoader
@@ -9,21 +10,32 @@ module RailsConsoleAi
       @storage = storage || RailsConsoleAi.storage
     end
 
+    # Three-source union: DB > file > built-in.
+    # Each record is tagged with `source: :db | :file | :builtin`. DB records
+    # also carry `status`, `approved_by`, `approved_at`. Proposed (unapproved)
+    # DB agents are surfaced here so the admin UI can render them — use
+    # #load_activatable_agents on AI-facing paths to filter them out.
     def load_all_agents
-      agents = load_builtin_agents
-      app_agents = load_app_agents
-      # App-specific agents override built-ins with the same name
-      app_names = app_agents.map { |a| a['name'].to_s.downcase }.to_set
-      agents.reject! { |a| app_names.include?(a['name'].to_s.downcase) }
-      agents.concat(app_agents)
-      agents
-    rescue => e
-      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load agents: #{e.message}")
-      []
+      db      = safe_load_db_agents
+      file    = safe_load_file_agents
+      builtin = safe_load_builtin_agents
+
+      db_names = db.map { |a| a['name'].to_s.downcase }
+      file.reject! { |a| db_names.include?(a['name'].to_s.downcase) }
+
+      file_names = file.map { |a| a['name'].to_s.downcase }
+      builtin.reject! { |a| db_names.include?(a['name'].to_s.downcase) || file_names.include?(a['name'].to_s.downcase) }
+
+      (db + file + builtin).sort_by { |a| a['name'].to_s.downcase }
+    end
+
+    # AI-facing: hides proposed DB agents. File + built-in are pre-approved.
+    def load_activatable_agents
+      load_all_agents.reject { |a| a['source'] == :db && a['status'] != 'approved' }
     end
 
     def agent_summaries
-      agents = load_all_agents
+      agents = load_activatable_agents
       return nil if agents.empty?
 
       agents.map { |a|
@@ -31,45 +43,79 @@ module RailsConsoleAi
       }
     end
 
+    # AI-facing — returns nil for proposed DB agents so delegate_task can't reach them.
     def find_agent(name)
-      agents = load_all_agents
-      agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+      load_activatable_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
     end
 
-    def save_agent(name:, description:, body:, max_rounds: nil, model: nil, tools: nil)
-      key = agent_key(name)
-      existing = find_agent(name)
-
-      frontmatter = {
-        'name' => name,
-        'description' => description
-      }
-      frontmatter['max_rounds'] = max_rounds if max_rounds
-      frontmatter['model'] = model if model
-      frontmatter['tools'] = Array(tools) if tools && !tools.empty?
+    # UI-facing — includes proposed DB agents.
+    def find_any_agent(name)
+      load_all_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+    end
 
-      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
-      @storage.write(key, content)
+    # target: :db (default) | :file
+    # Falls back to :file (with a notice in the return string) if DB tables aren't set up.
+    def save_agent(name:, description:, body:, max_rounds: nil, model: nil, tools: nil, target: :db, edited_by: nil, change_note: nil)
+      target = (target || :db).to_sym
+      db_fell_back = false
+      if target == :db && !Storage::DatabaseStorage.agents_available?
+        target = :file
+        db_fell_back = true
+      end
 
-      path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
-      if existing
-        "Agent updated: \"#{name}\" (#{path})"
+      if target == :file
+        result = save_agent_to_file(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: tools
+        )
+        if db_fell_back
+          result += "\nNOTE: DB storage was requested but the rails_console_ai_agents table does not exist. " \
+                    "Run `ai_db_setup` in your Rails console to enable the versioned DB store. " \
+                    "Saved to a file instead."
+        end
+        result
       else
-        "Agent created: \"#{name}\" (#{path})"
+        record, was_new = Storage::DatabaseStorage.save_agent(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: Array(tools),
+          edited_by: edited_by || 'ai', change_note: change_note
+        )
+        status_note = if record.respond_to?(:proposed?) && record.proposed?
+                        ' — status: PROPOSED. A human must approve it at /rails_console_ai/agents before delegate_task can invoke it.'
+                      else
+                        ''
+                      end
+        if was_new
+          "Agent created (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
+        else
+          "Agent updated (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
+        end
       end
-    rescue Storage::StorageError => e
+    rescue Storage::StorageError, ::ActiveRecord::RecordInvalid => e
       "FAILED to save agent (#{e.message})."
     end
 
+    # Tries DB first, then file. Built-in agents can't be deleted.
     def delete_agent(name:)
+      if Storage::DatabaseStorage.delete_agent_by_name(name)
+        return "Agent deleted (db): \"#{name}\""
+      end
+
+      # Built-in agents are gem-shipped and not deletable.
+      builtin = safe_load_builtin_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+      if builtin
+        return "Cannot delete built-in agent \"#{builtin['name']}\". Built-in agents ship with the gem. " \
+               "Create a same-named DB agent to override it instead."
+      end
+
       key = agent_key(name)
       unless @storage.exists?(key)
-        found = load_all_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+        found = safe_load_file_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
         return "No agent found: \"#{name}\"" unless found
         key = agent_key(found['name'])
       end
 
-      agent = load_agent(key)
+      agent = load_agent_file(key)
       @storage.delete(key)
       "Agent deleted: \"#{agent ? agent['name'] : name}\""
     rescue Storage::StorageError => e
@@ -78,24 +124,59 @@ module RailsConsoleAi
 
     private
 
-    def load_builtin_agents
+    def safe_load_db_agents
+      Storage::DatabaseStorage.all_agents
+    end
+
+    def safe_load_file_agents
+      keys = @storage.list("#{AGENTS_DIR}/*.md")
+      keys.filter_map { |key|
+        agent = load_agent_file(key)
+        next nil unless agent
+        agent.merge('source' => :file, 'file_key' => key)
+      }
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load file agents: #{e.message}")
+      []
+    end
+
+    def safe_load_builtin_agents
       return [] unless File.directory?(BUILTIN_DIR)
       Dir.glob(File.join(BUILTIN_DIR, '*.md')).sort.filter_map do |path|
-        content = File.read(path)
+        # Explicit UTF-8 — File.read defaults to the locale encoding, which on
+        # some CI / spec setups is US-ASCII and chokes on em-dashes etc.
+        content = File.read(path, encoding: 'UTF-8')
         agent = parse_agent(content)
-        agent['builtin'] = true if agent
-        agent
+        next nil unless agent
+        agent.merge('source' => :builtin, 'builtin' => true, 'file_key' => path)
       end
     rescue => e
       RailsConsoleAi.logger.debug("RailsConsoleAi: failed to load built-in agents: #{e.message}")
       []
     end
 
-    def load_app_agents
-      keys = @storage.list("#{AGENTS_DIR}/*.md")
-      keys.filter_map { |key| load_agent(key) }
-    rescue => e
-      []
+    def save_agent_to_file(name:, description:, body:, max_rounds:, model:, tools:)
+      key = agent_key(name)
+      existing = load_agent_file(key)
+
+      frontmatter = {
+        'name' => name,
+        'description' => description
+      }
+      frontmatter['max_rounds'] = max_rounds if max_rounds
+      frontmatter['model'] = model if model
+      tool_list = Array(tools)
+      frontmatter['tools'] = tool_list unless tool_list.empty?
+
+      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
+      @storage.write(key, content)
+
+      path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
+      if existing
+        "Agent updated: \"#{name}\" (#{path})"
+      else
+        "Agent created: \"#{name}\" (#{path})"
+      end
     end
 
     def agent_key(name)
@@ -107,7 +188,7 @@ module RailsConsoleAi
       "#{AGENTS_DIR}/#{slug}.md"
     end
 
-    def load_agent(key)
+    def load_agent_file(key)
       content = @storage.read(key)
       return nil if content.nil? || content.strip.empty?
       parse_agent(content)
@@ -117,10 +198,17 @@ module RailsConsoleAi
     end
 
     def parse_agent(content)
+      self.class.parse(content)
+    end
+
+    # Public: parse a raw .md (YAML frontmatter + body) string into a hash.
+    def self.parse(content)
       return nil unless content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
       frontmatter = YAML.safe_load($1, permitted_classes: [Time, Date]) || {}
       body = $2.strip
       frontmatter.merge('body' => body)
+    rescue Psych::SyntaxError
+      nil
     end
   end
 end

data/lib/rails_console_ai/agent_runner.rb

@@ -0,0 +1,158 @@
+require 'rails_console_ai/prefixed_io'
+require 'rails_console_ai/session_logger'
+require 'rails_console_ai/channel/api'
+require 'rails_console_ai/conversation_engine'
+require 'rails_console_ai/context_builder'
+require 'rails_console_ai/providers/base'
+require 'rails_console_ai/executor'
+
+module RailsConsoleAi
+  # Long-running worker that polls the sessions table for queued agent_api
+  # rows, claims them atomically, and runs each in its own Thread via
+  # ConversationEngine#one_shot. Started by `rake rails_console_ai:agents`.
+  class AgentRunner
+    POLL_INTERVAL = 2.0
+    DEFAULT_CONCURRENCY = 3
+    DRAIN_TIMEOUT = 60
+
+    def initialize(concurrency: DEFAULT_CONCURRENCY, poll_interval: POLL_INTERVAL)
+      @concurrency = concurrency
+      @poll_interval = poll_interval
+      @threads = {}      # session_id => Thread
+      @mutex = Mutex.new
+      @stopping = false
+    end
+
+    def start
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdout = RailsConsoleAi::PrefixedIO.new($stdout) unless $stdout.is_a?(RailsConsoleAi::PrefixedIO)
+      $stderr = RailsConsoleAi::PrefixedIO.new($stderr) unless $stderr.is_a?(RailsConsoleAi::PrefixedIO)
+
+      install_signal_handlers
+      puts "AgentRunner starting (concurrency=#{@concurrency}, poll=#{@poll_interval}s)"
+      loop do
+        break if @stopping
+        reap_finished
+        fill_slots
+        sleep @poll_interval
+      end
+      drain
+      puts "AgentRunner stopped."
+    end
+
+    private
+
+    def install_signal_handlers
+      %w[INT TERM].each do |sig|
+        Signal.trap(sig) { @stopping = true }
+      end
+    end
+
+    def reap_finished
+      @mutex.synchronize { @threads.reject! { |_, t| !t.alive? } }
+    end
+
+    def slots_available
+      @concurrency - @mutex.synchronize { @threads.size }
+    end
+
+    def fill_slots
+      slots = slots_available
+      return if slots <= 0
+      claim_next(slots).each { |session| spawn(session) }
+    rescue => e
+      warn "AgentRunner fill_slots failed: #{e.class}: #{e.message}"
+    end
+
+    # Returns up to `limit` Session records the runner exclusively owns.
+    # Atomic claim: only the runner whose UPDATE flips the row from
+    # 'queued' to 'running' may execute it.
+    def claim_next(limit)
+      candidates = Session.where(mode: 'agent_api', status: 'queued')
+                          .order(:created_at)
+                          .limit(limit)
+                          .pluck(:id)
+      claimed = []
+      candidates.each do |id|
+        n = Session.where(id: id, status: 'queued', mode: 'agent_api')
+                   .update_all(status: 'running')
+        claimed << Session.find(id) if n == 1
+      end
+      claimed
+    rescue => e
+      warn "AgentRunner claim failed: #{e.class}: #{e.message}"
+      []
+    end
+
+    def spawn(session)
+      tag = "[agent/#{session.id}] @#{session.user_name || '?'}"
+      puts "#{tag} << #{session.query.to_s.strip}"
+
+      t = Thread.new do
+        Thread.current.report_on_exception = false
+        Thread.current[:log_prefix] = tag
+        begin
+          run_one(session)
+        ensure
+          ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+        end
+      end
+      @mutex.synchronize { @threads[session.id] = t }
+    end
+
+    def run_one(session)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      channel = Channel::Api.new(user_name: session.user_name)
+      sandbox_binding = Object.new.instance_eval { binding }
+      engine = ConversationEngine.new(binding_context: sandbox_binding, channel: channel)
+
+      exec_result = engine.one_shot(session.query, existing_session_id: session.id)
+      result_text = compose_result(channel.captured_output, exec_result)
+
+      SessionLogger.update(session.id, status: 'ready', result: result_text)
+
+      elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
+      preview = result_text.to_s.strip.lines.first.to_s.strip
+      preview = preview[0, 120] + '…' if preview.length > 120
+      puts ">> ready (#{elapsed}ms) #{preview}"
+    rescue => e
+      warn ">> FAILED #{e.class}: #{e.message}"
+      e.backtrace&.first(5)&.each { |line| warn "   #{line}" }
+      SessionLogger.update(session.id,
+        status: 'failed',
+        error_message: "#{e.class}: #{e.message}\n#{Array(e.backtrace).first(10).join("\n")}"
+      )
+    end
+
+    # Build the `result` payload returned via get_agent_response. The
+    # LLM's prose lands in the channel's captured_output; the value the
+    # generated code returned lands in exec_result. Without including the
+    # latter, the consumer gets only the preamble ("Let me query...")
+    # and not the actual answer.
+    def compose_result(prose, exec_result)
+      parts = []
+      trimmed = prose.to_s.strip
+      parts << trimmed unless trimmed.empty?
+      parts << "Result: #{exec_result.inspect}" unless exec_result.nil?
+      parts.empty? ? '' : (parts.join("\n\n") << "\n")
+    end
+
+    def drain
+      n = @mutex.synchronize { @threads.size }
+      return if n.zero?
+      puts "AgentRunner draining #{n} in-flight job(s)..."
+      deadline = Time.now + DRAIN_TIMEOUT
+      loop do
+        reap_finished
+        break unless @mutex.synchronize { @threads.any? }
+        break if Time.now >= deadline
+        sleep 0.5
+      end
+      stuck = @mutex.synchronize { @threads.keys }
+      stuck.each do |id|
+        SessionLogger.update(id, status: 'failed', error_message: 'Runner shut down before completion')
+      end
+    end
+  end
+end

data/lib/rails_console_ai/channel/api.rb

@@ -0,0 +1,139 @@
+require 'rails_console_ai/channel/base'
+
+module RailsConsoleAi
+  module Channel
+    # Non-interactive channel used by the AgentRunner. It owns its own
+    # buffers — there is no parent channel and no user to prompt. The
+    # runner reads `captured_output` back as the agent's `result`.
+    #
+    # Mirrors Channel::Slack's pattern of logging every display event to
+    # STDOUT (tagged) so the rake task log shows progress in real time,
+    # while ALSO buffering display output into `captured_output` for the
+    # runner to compose the final result.
+    class Api < Base
+      ANSI_REGEX = /\e\[[0-9;]*[a-zA-Z]/.freeze
+
+      attr_reader :captured_output, :status_log
+
+      def initialize(user_name: nil)
+        @user_name = user_name
+        @captured_output = +''
+        @status_log = []
+      end
+
+      def display(text)
+        stripped = strip_ansi(text)
+        @captured_output << stripped << "\n"
+        log_prefixed(">>", stripped)
+      end
+
+      def display_result(text)
+        stripped = strip_ansi(text)
+        @captured_output << stripped << "\n"
+        log_prefixed(">>", stripped)
+      end
+
+      def display_result_output(text)
+        stripped = strip_ansi(text)
+        @captured_output << stripped << "\n"
+        log_prefixed(">>", stripped)
+      end
+
+      def display_code(code)
+        # Don't add to captured_output — code itself is persisted on the
+        # session row as code_executed. But DO log it to STDOUT so the
+        # rake task log shows what was generated.
+        log_prefixed("(code)", '')
+        code.to_s.each_line { |line| log_prefixed("(code)", line.rstrip) }
+      end
+
+      def display_thinking(text)
+        stripped = strip_ansi(text).strip
+        return if stripped.empty?
+        @status_log << stripped
+        log_prefixed("(thinking)", stripped)
+      end
+
+      def display_status(text)
+        stripped = strip_ansi(text).strip
+        return if stripped.empty?
+        @status_log << stripped
+        log_prefixed("(status)", stripped)
+      end
+
+      def display_tool_call(text)
+        stripped = strip_ansi(text)
+        @status_log << stripped
+        log_prefixed("->", stripped)
+      end
+
+      def display_warning(text)
+        stripped = strip_ansi(text)
+        @status_log << "WARN: #{stripped}"
+        log_prefixed("(warn)", stripped)
+      end
+
+      def display_error(text)
+        stripped = strip_ansi(text)
+        @status_log << "ERROR: #{stripped}"
+        log_prefixed("(error)", stripped)
+      end
+
+      def prompt(_text)
+        ''  # non-interactive — no user to ask
+      end
+
+      def confirm(_text)
+        # No human present to confirm. Auto-yes matches Channel::SubAgent's
+        # behavior — actual safety comes from the safety guards plus
+        # supports_danger? = false below, not from this prompt.
+        'y'
+      end
+
+      def user_identity
+        @user_name
+      end
+
+      def mode
+        'api'
+      end
+
+      def cancelled?
+        false
+      end
+
+      def supports_danger?
+        false  # like sub_agent: never bypass safety guards without a human
+      end
+
+      def supports_editing?
+        false
+      end
+
+      def wrap_llm_call(&block)
+        yield
+      end
+
+      def system_instructions
+        nil
+      end
+
+      private
+
+      # Mirror of Channel::Slack#log_prefixed — emit each line through
+      # $stdout so PrefixedIO (installed by AgentRunner#start) adds the
+      # per-session tag from Thread.current[:log_prefix].
+      def log_prefixed(tag, text)
+        if text.to_s.strip.empty?
+          $stdout.puts(tag)
+        else
+          text.to_s.each_line { |line| $stdout.puts "#{tag} #{line.rstrip}" }
+        end
+      end
+
+      def strip_ansi(text)
+        text.to_s.gsub(ANSI_REGEX, '')
+      end
+    end
+  end
+end