rails_console_ai 0.19.0 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fac547626547b2b99702978a38365e9877c11c3e5892be2d91004395ddfb92a4
-  data.tar.gz: f89b097e49fb3fb766bc618082ace286658dce54a496decf98251c1f3a8c6eff
+  metadata.gz: ee0daa4b9926c6df19c9e2946f019b5d17dd3bd64d4e8998e92d86ed16dff8e1
+  data.tar.gz: f336fe3abf34a513a5de12b138d69f4941e3cd65eeecaa8b548658d3da8b846e
 SHA512:
-  metadata.gz: 7e9b2488043e925762da5b442412f27b92c57facf2fd880b27bbc74314c41cc4c421e091af690b262b0b6ff965aa4ad66cd5efd0bdde6e1de08737d18e7a0411
-  data.tar.gz: fc44b20a37d2bc56254f6b4dc966225f8d7442139ae4f7270194939b5d17291e34adf4c8376edbcdbd9f6078915cdef87a293f255cb57c666213c3ad19f0d02a
+  metadata.gz: 35d266cac783a3e43a6712380085215b7ba7503874b4f7a97ce6fac30875bded29e658d52dc4d1196bcb2e907e555255538ec6563e190212ea0bbcc6c02179d4
+  data.tar.gz: 64e365d8d18a9a559bf9c8ec5b982f7ecff03d1faed9d731bc3734b6493cdeb7cab3055de5ae56da3e5d5112ccfb7b6ecf47b652a7a570c8fdb8401e0eddcf40

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.20.0]
+
+- Add per-user system prompt seeding
+- Improve explicit code execution through Slack bot
+- Show last thinking output before prompting
+- Add Skills system
+- Add `bypass_guards_for_methods` to allow specific methods to skip safety guards
+- Add `execute_code` tool for simple query execution without code fences
+- Support `<code>` tags in Slack responses
+- Improve Slack bot server logging and keepalive visibility
+- Improve database safety guards in Rails 5
+
 ## [0.19.0]
 
 - Fix duplicate tool result IDs in AWS Bedrock provider

data/README.md

@@ -97,6 +97,7 @@ Say "think harder" in any query to auto-upgrade to the thinking model for that s
 - **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
 - **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
 - **App guide** — `ai_init` generates a guide injected into every system prompt
 - **Sessions** — name, list, and resume interactive conversations (`ai_setup` to enable)
@@ -141,6 +142,74 @@ Raise `RailsConsoleAi::SafetyError` in your app code to trigger the safe mode pr
 raise RailsConsoleAi::SafetyError, "Stripe charge blocked"
 ```
 
+### Allowing Specific Methods
+
+Some operations (like admin approvals) need to write to the database even when guards are active. Use `bypass_guards_for_methods` to declare methods that should bypass all safety guards when called during an AI session:
+
+```ruby
+RailsConsoleAi.configure do |config|
+  # Global — applies to all channels
+  config.bypass_guards_for_methods = [
+    'ChangeApproval#approve_by!',
+    'ChangeApproval#reject_by!'
+  ]
+
+  # Per-channel — only active in the specified channel
+  config.channels = {
+    'slack'   => { 'bypass_guards_for_methods' => ['Deployment#promote!'] },
+    'console' => {}
+  }
+end
+```
+
+Global and channel-specific methods are merged for the active channel. These method shims are installed lazily on the first AI execution (not at boot) and are session-scoped — they only bypass guards inside `SafetyGuards#wrap`. Outside of an AI session (e.g. in normal web requests), the methods behave normally with zero overhead beyond a single thread-local read.
+
+The AI is told about these trusted methods in its system prompt and will use them directly without triggering safety errors.
+
+### Skills
+
+Skills bundle a step-by-step recipe with guard bypass declarations into a single file. Unlike `bypass_guards_for_methods` (which is always-on), skill bypasses are only active after the AI explicitly activates the skill.
+
+Create markdown files in `.rails_console_ai/skills/`:
+
+```markdown
+---
+name: Approve/Reject ChangeApprovals
+description: Approve or reject change approval records on behalf of an admin
+tags:
+  - change-approval
+  - admin
+bypass_guards_for_methods:
+  - "ChangeApproval#approve_by!"
+  - "ChangeApproval#reject_by!"
+---
+
+## When to use
+Use when the user asks to approve or reject a change approval.
+
+## Recipe
+1. Find the ChangeApproval by ID or search
+2. Confirm approve or reject
+3. Get optional review notes
+4. Determine which admin user is acting
+5. Call approve_by! or reject_by!
+
+## Code Examples
+
+    ca = ChangeApproval.find(id)
+    admin = User.find_by!(email: "admin@example.com")
+    ca.approve_by!(admin, "Approved per request")
+```
+
+**How it works:**
+
+1. Skill summaries (name + description) appear in the AI's system prompt
+2. When the user's request matches a skill, the AI calls `activate_skill` to load the full recipe
+3. The skill's `bypass_guards_for_methods` are added to the active bypass set
+4. The AI follows the recipe, executing code with the declared methods bypassing safety guards
+
+Skills and global `bypass_guards_for_methods` coexist — use config-level bypasses for simple trusted methods, and skills for operations that benefit from a documented procedure.
+
 ### Toggling Safe Mode
 
 - **`/danger`** in interactive mode toggles all guards off/on for the session

data/lib/generators/rails_console_ai/templates/initializer.rb

@@ -76,4 +76,16 @@ RailsConsoleAi.configure do |config|
   # config.safety_guard :jobs do |&execute|
   #   Sidekiq::Testing.fake! { execute.call }
   # end
+  #
+  # Bypass ALL safety guards when specific methods are called (e.g. trusted admin actions):
+  # config.bypass_guards_for_methods = [
+  #   'ChangeApproval#approve_by!',
+  #   'ChangeApproval#reject_by!'
+  # ]
+
+  # Per-channel settings (channel mode keys: 'slack', 'console'):
+  # config.channels = {
+  #   'slack'   => { 'pinned_memory_tags' => ['sharding'], 'bypass_guards_for_methods' => ['ChangeApproval#approve_by!'] },
+  #   'console' => { 'pinned_memory_tags' => [] }
+  # }
 end

data/lib/rails_console_ai/channel/base.rb

@@ -7,6 +7,7 @@ module RailsConsoleAi
       def display_error(text);      raise NotImplementedError; end
       def display_code(code);       raise NotImplementedError; end
       def display_result(text);     raise NotImplementedError; end
+      def display_tool_call(text); end  # tool call: "-> name(args)"
       def display_result_output(text); end  # stdout output from code execution
       def prompt(text);             raise NotImplementedError; end
       def confirm(text);            raise NotImplementedError; end

data/lib/rails_console_ai/channel/console.rb

@@ -18,6 +18,10 @@ module RailsConsoleAi
         $stdout.puts "\e[2m#{text}\e[0m"
       end
 
+      def display_tool_call(text)
+        $stdout.puts "\e[33m  -> #{text}\e[0m"
+      end
+
       def display_warning(text)
         $stdout.puts colorize(text, :yellow)
       end
@@ -75,7 +79,7 @@ module RailsConsoleAi
       end
 
       def mode
-        'interactive'
+        'console'
       end
 
       def supports_editing?

data/lib/rails_console_ai/channel/slack.rb

@@ -56,9 +56,16 @@ module RailsConsoleAi
         post(":x: #{strip_ansi(text)}")
       end
 
-      def display_code(_code)
+      def display_tool_call(text)
+        @output_log.write("-> #{text}\n")
+        STDOUT.puts "#{@log_prefix} -> #{text}"
+      end
+
+      def display_code(code)
         # Don't post raw code/plan steps to Slack — non-technical users don't need to see Ruby
-        nil
+        # But do log to STDOUT so server logs show what was generated/executed
+        @output_log.write("# Generated code:\n#{code}\n")
+        STDOUT.puts "#{@log_prefix} (code)\n# Generated code:\n#{code}"
       end
 
       def display_result_output(output)
@@ -108,6 +115,14 @@ module RailsConsoleAi
 
           You are responding to non-technical users in Slack. Follow these rules:
 
+          ## Code Execution
+          - ALWAYS use the `execute_code` tool to run Ruby code. Do NOT put code in markdown
+            code fences expecting it to be executed — code fences are display-only in Slack.
+          - Use `execute_code` for simple queries, and `execute_plan` for multi-step operations.
+          - If the user asks you to provide code they can run later, put it in a code fence
+            in your text response (it will be displayed but not executed).
+
+          ## Formatting
           - Slack does NOT support markdown tables. For tabular data, use `puts` to print
             a plain-text table inside a code block. Use fixed-width columns with padding so
             columns align. Example format:

data/lib/rails_console_ai/configuration.rb

@@ -28,7 +28,10 @@ module RailsConsoleAi
                   :slack_bot_token, :slack_app_token, :slack_channel_ids, :slack_allowed_usernames,
                   :local_url, :local_model, :local_api_key,
                   :bedrock_region,
-                  :code_search_paths
+                  :code_search_paths,
+                  :channels,
+                  :bypass_guards_for_methods,
+                  :user_extra_info
 
     def initialize
       @provider     = :anthropic
@@ -58,6 +61,14 @@ module RailsConsoleAi
       @local_api_key    = nil
       @bedrock_region   = nil
       @code_search_paths = %w[app]
+      @channels = {}
+      @bypass_guards_for_methods = []
+      @user_extra_info = {}
+    end
+
+    def resolve_user_extra_info(username)
+      return nil if @user_extra_info.nil? || @user_extra_info.empty? || username.nil?
+      @user_extra_info[username.to_s.downcase]
     end
 
     def safety_guards

data/lib/rails_console_ai/context_builder.rb

@@ -1,7 +1,9 @@
 module RailsConsoleAi
   class ContextBuilder
-    def initialize(config = RailsConsoleAi.configuration)
+    def initialize(config = RailsConsoleAi.configuration, channel_mode: nil, user_name: nil)
       @config = config
+      @channel_mode = channel_mode
+      @user_name = user_name
     end
 
     def build
@@ -16,6 +18,10 @@ module RailsConsoleAi
       parts << smart_system_instructions
       parts << environment_context
       parts << guide_context
+      parts << trusted_methods_context
+      parts << skills_context
+      parts << user_extra_info_context
+      parts << pinned_memory_context
       parts << memory_context
       parts.compact.join("\n\n")
     end
@@ -67,18 +73,27 @@ module RailsConsoleAi
         When you use a memory, mention it briefly (e.g. "Based on what I know about sharding...").
         When you discover important patterns about this app, save them as memories.
 
-        You have an execute_plan tool to run multi-step code. When a task requires multiple
-        sequential operations, use execute_plan with an array of steps (each with a description
-        and Ruby code). The plan is shown to the user for review before execution begins.
-        After each step runs, its return value is stored as step1, step2, etc. — use these
-        variables in later steps to reference earlier results (e.g. `api = SalesforceApi.new(step1)`).
-        For simple single-expression answers, you may respond with a ```ruby code block instead.
+        You have tools for executing Ruby code:
+        - Use execute_code for simple queries and single operations.
+        - Use execute_plan for multi-step tasks that require sequential operations. Each step
+          has a description and Ruby code. The plan is shown to the user for review before
+          execution begins. After each step runs, its return value is stored as step1, step2,
+          etc. — use these variables in later steps to reference earlier results
+          (e.g. `api = SalesforceApi.new(step1)`).
+        - If the user asks you to provide code for them to run later (not execute now), put it
+          in a ```ruby code block in your text response.
+        - Use `RailsConsoleAi.configuration.safety_guards.without_guards { }` to wrap any
+          operation that should bypass safety guards (e.g. calling a known-safe admin method).
+
+        You have skills — predefined procedures for specific operations. When a user's request
+        matches a skill, call activate_skill first to load the recipe and enable its guard
+        bypasses, then follow the recipe.
 
         RULES:
         - Give ONE concise answer. Do not offer multiple alternatives or variations.
         - For multi-step tasks, use execute_plan to break the work into small, clear steps.
-        - For simple queries, respond with a single ```ruby code block.
-        - Include a brief one-line explanation before any code block.
+        - For simple queries, use the execute_code tool.
+        - Include a brief one-line explanation before or after executing code.
         - Use the app's actual model names, associations, and schema.
         - Prefer ActiveRecord query interface over raw SQL.
         - For destructive operations, add a comment warning.
@@ -89,6 +104,19 @@ module RailsConsoleAi
       PROMPT
     end
 
+    def trusted_methods_context
+      methods = Array(@config.bypass_guards_for_methods)
+      if @channel_mode
+        channel_cfg = @config.channels[@channel_mode] || {}
+        methods = methods | Array(channel_cfg['bypass_guards_for_methods'])
+      end
+      return nil if methods.empty?
+
+      lines = ["## Trusted Methods (safety guards bypassed automatically)"]
+      methods.each { |m| lines << "- #{m}" }
+      lines.join("\n")
+    end
+
     def guide_context
       content = RailsConsoleAi.storage.read(RailsConsoleAi::GUIDE_KEY)
       return nil if content.nil? || content.strip.empty?
@@ -99,6 +127,48 @@ module RailsConsoleAi
       nil
     end
 
+    def skills_context
+      require 'rails_console_ai/skill_loader'
+      summaries = RailsConsoleAi::SkillLoader.new.skill_summaries
+      return nil if summaries.nil? || summaries.empty?
+
+      lines = ["## Skills (call activate_skill to use)"]
+      lines.concat(summaries)
+      lines.join("\n")
+    rescue => e
+      RailsConsoleAi.logger.debug("RailsConsoleAi: skills context failed: #{e.message}")
+      nil
+    end
+
+    def user_extra_info_context
+      info = @config.resolve_user_extra_info(@user_name)
+      return nil if info.nil? || info.strip.empty?
+
+      "## Current User\n\nUser: #{@user_name}\n#{info}"
+    end
+
+    def pinned_memory_context
+      return nil unless @channel_mode
+
+      channel_cfg = @config.channels[@channel_mode] || {}
+      pinned_tags = channel_cfg['pinned_memory_tags'] || []
+      return nil if pinned_tags.empty?
+
+      require 'rails_console_ai/tools/memory_tools'
+      sections = pinned_tags.filter_map do |tag|
+        content = Tools::MemoryTools.new.recall_memories(tag: tag)
+        next if content.nil? || content.include?("No memories")
+        content
+      end
+      return nil if sections.empty?
+
+      "## Pinned Memories (always available — no need to recall_memories for these)\n\n" \
+        + sections.join("\n\n")
+    rescue => e
+      RailsConsoleAi.logger.debug("RailsConsoleAi: pinned memory context failed: #{e.message}")
+      nil
+    end
+
     def memory_context
       return nil unless @config.memories_enabled
 

data/lib/rails_console_ai/conversation_engine.rb

@@ -623,7 +623,7 @@ module RailsConsoleAi
     end
 
     def context_builder
-      @context_builder ||= ContextBuilder.new
+      @context_builder ||= ContextBuilder.new(channel_mode: @channel.mode, user_name: @channel.user_identity)
     end
 
     def binding_variable_summary
@@ -768,10 +768,15 @@ module RailsConsoleAi
         result.tool_calls.each do |tc|
           break if @channel.cancelled?
           if tc[:name] == 'ask_user' || tc[:name] == 'execute_plan'
+            # Display any pending LLM text before prompting the user
+            if last_thinking
+              last_thinking.split("\n").each { |line| @channel.display_dim("  #{line}") }
+              last_thinking = nil
+            end
             tool_result = tools.execute(tc[:name], tc[:arguments])
           else
             args_display = format_tool_args(tc[:name], tc[:arguments])
-            $stdout.puts "\e[33m  -> #{tc[:name]}#{args_display}\e[0m"
+            @channel.display_tool_call("#{tc[:name]}#{args_display}")
 
             tool_result = tools.execute(tc[:name], tc[:arguments])
 

data/lib/rails_console_ai/executor.rb

@@ -54,6 +54,7 @@ module RailsConsoleAi
       @omitted_counter = 0
       @output_store = {}
       @output_counter = 0
+      @active_skill_bypass_methods = Set.new
     end
 
     def extract_code(response)
@@ -65,29 +66,33 @@ module RailsConsoleAi
     ANY_CODE_FENCE_REGEX = /```\w*\s*\n.*?```/m
 
     def display_response(response)
-      code = extract_code(response)
-      explanation = response.gsub(ANY_CODE_FENCE_REGEX, '').strip
+      # Code execution now happens via the execute_code tool, not code-fence extraction.
+      # Just display the full response text as-is.
+      text = response.to_s.strip
+      return '' if text.empty?
 
+      $stdout.puts
       if @channel
-        $stdout.puts
-        @channel.display(explanation) unless explanation.empty?
-        @channel.display_code(code) unless code.empty?
+        @channel.display(text)
       else
-        $stdout.puts
-        $stdout.puts colorize(explanation, :cyan) unless explanation.empty?
-
-        unless code.empty?
-          $stdout.puts
-          $stdout.puts colorize("# Generated code:", :yellow)
-          $stdout.puts highlight_code(code)
-          $stdout.puts
-        end
+        $stdout.puts colorize(text, :cyan)
       end
 
-      code
+      '' # No code to extract — the LLM uses execute_code tool instead
+    end
+
+    def display_code_block(code)
+      if @channel
+        @channel.display_code(code)
+      else
+        $stdout.puts
+        $stdout.puts colorize("# Generated code:", :yellow)
+        $stdout.puts highlight_code(code)
+        $stdout.puts
+      end
     end
 
-    def execute(code)
+    def execute(code, display: true)
       return nil if code.nil? || code.strip.empty?
 
       @last_error = nil
@@ -118,11 +123,11 @@ module RailsConsoleAi
       end
 
       # Send captured puts output through channel before the return value
-      if @channel && !captured_output.string.empty?
+      if display && @channel && !captured_output.string.empty?
         @channel.display_result_output(captured_output.string)
       end
 
-      display_result(result)
+      display_result(result) if display
 
       @last_output = captured_output.string
       result
@@ -317,6 +322,14 @@ module RailsConsoleAi
       nil
     end
 
+    def activate_skill_bypasses(methods)
+      guards = RailsConsoleAi.configuration.safety_guards
+      Array(methods).each do |spec|
+        @active_skill_bypass_methods << spec
+        guards.install_bypass_method!(spec)
+      end
+    end
+
     private
 
     def danger_allowed?
@@ -360,7 +373,11 @@ module RailsConsoleAi
     end
 
     def with_safety_guards(&block)
-      RailsConsoleAi.configuration.safety_guards.wrap(&block)
+      RailsConsoleAi.configuration.safety_guards.wrap(
+        channel_mode: @channel&.mode,
+        additional_bypass_methods: @active_skill_bypass_methods,
+        &block
+      )
     end
 
     # Check if an exception is or wraps a SafetyError (e.g. AR::StatementInvalid wrapping it)

data/lib/rails_console_ai/safety_guards.rb

@@ -85,12 +85,87 @@ module RailsConsoleAi
     # Compose all guards around a block of code.
     # Each guard is an around-block: guard.call { inner }
     # Result: guard_1 { guard_2 { guard_3 { yield } } }
-    def wrap(&block)
+    def wrap(channel_mode: nil, additional_bypass_methods: nil, &block)
       return yield unless @enabled && !@guards.empty?
 
-      @guards.values.reduce(block) { |inner, guard|
-        -> { guard.call(&inner) }
-      }.call
+      install_skills_once!
+      bypass_set = resolve_bypass_methods(channel_mode)
+      Array(additional_bypass_methods).each { |m| bypass_set << m }
+
+      prev_active = Thread.current[:rails_console_ai_session_active]
+      prev_bypass = Thread.current[:rails_console_ai_bypass_methods]
+      Thread.current[:rails_console_ai_session_active] = true
+      Thread.current[:rails_console_ai_bypass_methods] = bypass_set
+      begin
+        @guards.values.reduce(block) { |inner, guard|
+          -> { guard.call(&inner) }
+        }.call
+      ensure
+        Thread.current[:rails_console_ai_session_active] = prev_active
+        Thread.current[:rails_console_ai_bypass_methods] = prev_bypass
+      end
+    end
+
+    # Install a bypass shim for a single method spec (e.g. "ChangeApproval#approve_by!").
+    # Prepends a module that checks the thread-local bypass set at runtime.
+    # Idempotent: tracks which specs have been installed to avoid double-prepending.
+    def install_bypass_method!(spec)
+      @installed_bypass_specs ||= Set.new
+      return if @installed_bypass_specs.include?(spec)
+
+      class_name, method_name = spec.split('#')
+      klass = Object.const_get(class_name) rescue return
+      method_sym = method_name.to_sym
+
+      bypass_mod = Module.new do
+        define_method(method_sym) do |*args, &blk|
+          if Thread.current[:rails_console_ai_bypass_methods]&.include?(spec)
+            RailsConsoleAi.configuration.safety_guards.without_guards { super(*args, &blk) }
+          else
+            super(*args, &blk)
+          end
+        end
+      end
+      klass.prepend(bypass_mod)
+      @installed_bypass_specs << spec
+    end
+
+    private
+
+    def resolve_bypass_methods(channel_mode)
+      config = RailsConsoleAi.configuration
+      methods = Set.new(config.bypass_guards_for_methods)
+      if channel_mode
+        channel_cfg = config.channels[channel_mode] || {}
+        (channel_cfg['bypass_guards_for_methods'] || []).each { |m| methods << m }
+      end
+      methods
+    end
+
+    def install_skills_once!
+      return if @skills_installed
+      (@skills_mutex ||= Mutex.new).synchronize do
+        return if @skills_installed
+        all_methods = Set.new(RailsConsoleAi.configuration.bypass_guards_for_methods)
+        RailsConsoleAi.configuration.channels.each_value do |cfg|
+          (cfg['bypass_guards_for_methods'] || []).each { |m| all_methods << m }
+        end
+        all_methods.each { |spec| install_bypass_method!(spec) }
+        @skills_installed = true
+      end
+    end
+
+    public
+
+    # Bypass all safety guards for the duration of the block.
+    # Thread-safe: uses a thread-local flag that is restored after the block,
+    # even if the block raises an exception.
+    def without_guards
+      prev = Thread.current[:rails_console_ai_bypass_guards]
+      Thread.current[:rails_console_ai_bypass_guards] = true
+      yield
+    ensure
+      Thread.current[:rails_console_ai_bypass_guards] = prev
     end
   end
 
@@ -106,6 +181,7 @@ module RailsConsoleAi
       private
 
       def rails_console_ai_check_write!(sql)
+        return if Thread.current[:rails_console_ai_bypass_guards]
         return unless Thread.current[:rails_console_ai_block_writes] && sql.match?(WRITE_PATTERN)
 
         table = sql.match(TABLE_PATTERN)&.captures&.first
@@ -126,6 +202,16 @@ module RailsConsoleAi
         super
       end
 
+      def exec_query(sql, *args, **kwargs)
+        rails_console_ai_check_write!(sql)
+        super
+      end
+
+      def exec_insert(sql, *args, **kwargs)
+        rails_console_ai_check_write!(sql)
+        super
+      end
+
       def exec_delete(sql, *args, **kwargs)
         rails_console_ai_check_write!(sql)
         super
@@ -167,6 +253,8 @@ module RailsConsoleAi
 
       def request(req, *args, &block)
         if Thread.current[:rails_console_ai_block_http] && !SAFE_METHODS.include?(req.method)
+          return super if Thread.current[:rails_console_ai_bypass_guards]
+
           host = @address.to_s
           guards = RailsConsoleAi.configuration.safety_guards
           unless guards.allowed?(:http_mutations, host)
@@ -195,6 +283,8 @@ module RailsConsoleAi
 
     def self.mailers
       ->(&block) {
+        return block.call if Thread.current[:rails_console_ai_bypass_guards]
+
         old_value = ActionMailer::Base.perform_deliveries
         ActionMailer::Base.perform_deliveries = false
         begin

data/lib/rails_console_ai/skill_loader.rb

@@ -0,0 +1,53 @@
+require 'yaml'
+
+module RailsConsoleAi
+  class SkillLoader
+    SKILLS_DIR = 'skills'
+
+    def initialize(storage = nil)
+      @storage = storage || RailsConsoleAi.storage
+    end
+
+    def load_all_skills
+      keys = @storage.list("#{SKILLS_DIR}/*.md")
+      keys.filter_map { |key| load_skill(key) }
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load skills: #{e.message}")
+      []
+    end
+
+    def skill_summaries
+      skills = load_all_skills
+      return nil if skills.empty?
+
+      skills.map { |s|
+        tags = Array(s['tags'])
+        tag_str = tags.empty? ? '' : " [#{tags.join(', ')}]"
+        "- **#{s['name']}**#{tag_str}: #{s['description']}"
+      }
+    end
+
+    def find_skill(name)
+      skills = load_all_skills
+      skills.find { |s| s['name'].to_s.downcase == name.to_s.downcase }
+    end
+
+    private
+
+    def load_skill(key)
+      content = @storage.read(key)
+      return nil if content.nil? || content.strip.empty?
+      parse_skill(content)
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load skill #{key}: #{e.message}")
+      nil
+    end
+
+    def parse_skill(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)
+    end
+  end
+end

data/lib/rails_console_ai/slack_bot.rb

@@ -13,6 +13,7 @@ module RailsConsoleAi
   class SlackBot
     PING_INTERVAL = 30  # seconds — send ping if no data received
     PONG_TIMEOUT  = 60  # seconds — reconnect if no pong after ping
+    GREETINGS = %w[hi hey hello howdy yo sup hola].to_set.freeze
 
     def initialize
       @bot_token = RailsConsoleAi.configuration.slack_bot_token || ENV['SLACK_BOT_TOKEN']
@@ -96,25 +97,32 @@ module RailsConsoleAi
 
       # Main read loop with keepalive
       last_activity = Time.now
+      last_ping_sent_at = Time.now
       ping_sent = false
 
       loop do
         ready = IO.select([ssl.to_io], nil, nil, PING_INTERVAL)
 
-        if ready.nil?
-          # Timeout — no data received
+        # Send outbound ping on a fixed schedule, regardless of inbound activity
+        if Time.now - last_ping_sent_at >= PING_INTERVAL
           if ping_sent && (Time.now - last_activity) > PONG_TIMEOUT
-            puts "Slack connection timed out (no pong received). Reconnecting..."
+            puts "Slack connection timed out (no pong received after #{(Time.now - last_activity).round}s). Reconnecting..."
             break
           end
+          puts "Sending WebSocket ping (last activity #{(Time.now - last_activity).round}s ago)"
           send_ws_ping(ssl)
+          last_ping_sent_at = Time.now
           ping_sent = true
-          next
         end
 
+        next if ready.nil?
+
         data = read_ws_frame(ssl)
         last_activity = Time.now
-        ping_sent = false
+        if ping_sent
+          puts "Received data after ping — connection alive"
+          ping_sent = false
+        end
         next unless data
 
         begin
@@ -161,12 +169,14 @@ module RailsConsoleAi
       # Handle ping (opcode 9) → send pong (opcode 10)
       if opcode == 9
         payload = read_ws_payload(ssl)
+        puts "Received server ping, sending pong"
         send_ws_pong(ssl, payload)
         return nil
       end
       # Handle pong (opcode 10) — response to our keepalive ping
       if opcode == 0xA
         read_ws_payload(ssl) # consume payload
+        puts "Received WebSocket pong"
         return nil
       end
       # Close frame (opcode 8)
@@ -323,13 +333,17 @@ module RailsConsoleAi
         return
       end
 
-      # Direct code execution: "> User.count" runs code without LLM
-      if text.strip.start_with?('>')
-        raw_code = text.strip.sub(/\A>\s*/, '')
-        unless raw_code.empty?
-          handle_direct_code(session, channel_id, thread_ts, raw_code, user_name)
-          return
-        end
+      # Quick greeting — no need to hit the LLM
+      if !session && GREETINGS.include?(command)
+        post_message(channel: channel_id, thread_ts: thread_ts, text: ":wave: Hey @#{user_name}! What would you like to look into today?")
+        return
+      end
+
+      # Direct code execution: code blocks or "> User.count" run code without LLM
+      raw_code = extract_direct_code(text.strip)
+      if raw_code
+        handle_direct_code(session, channel_id, thread_ts, raw_code, user_name)
+        return
       end
 
       if session
@@ -440,6 +454,7 @@ module RailsConsoleAi
           unless result_value.nil?
             display_text = "=> #{result_value}"
             display_text = display_text[0, 3000] + "\n... (truncated)" if display_text.length > 3000
+            puts "#{channel.instance_variable_get(:@log_prefix)} >> #{display_text}"
             post_message(channel: channel_id, thread_ts: thread_ts, text: "```#{display_text}```")
           end
           engine.send(:log_interactive_turn)
@@ -535,11 +550,35 @@ module RailsConsoleAi
       { "ok" => false, "error" => e.message }
     end
 
+    # Extract code for direct execution from code blocks or > prefix.
+    # Returns the code string, or nil if the message is not direct code.
+    def extract_direct_code(text)
+      # ```code``` or ```ruby\ncode```
+      if text.match?(/\A```/)
+        code = text.sub(/\A```/, '').sub(/```\z/, '')
+        # Strip optional language hint only when followed by a newline (e.g. ```ruby\n)
+        code = code.sub(/\A\w+\n/, '')
+        code = code.strip
+        return code unless code.empty?
+      end
+
+      # > code
+      if text.start_with?('>')
+        code = text.sub(/\A>\s*/, '')
+        return code unless code.empty?
+      end
+
+      nil
+    end
+
     def unescape_slack(text)
       return text unless text
-      text.gsub("&amp;", "&").gsub("&lt;", "<").gsub("&gt;", ">")
-          .gsub("\u2018", "'").gsub("\u2019", "'")   # smart single quotes → straight
-          .gsub("\u201C", '"').gsub("\u201D", '"')    # smart double quotes → straight
+      text
+        .gsub(/<((?:https?|mailto):[^|>]+)\|([^>]+)>/, '\2')  # <http://url|label> → label
+        .gsub(/<((?:https?|mailto):[^>]+)>/, '\1')             # <http://url> → url
+        .gsub("&amp;", "&").gsub("&lt;", "<").gsub("&gt;", ">")
+        .gsub("\u2018", "'").gsub("\u2019", "'")   # smart single quotes → straight
+        .gsub("\u201C", '"').gsub("\u201D", '"')    # smart double quotes → straight
     end
 
     def waiting_for_reply?(channel)

data/lib/rails_console_ai/tools/registry.rb

@@ -6,7 +6,7 @@ module RailsConsoleAi
       attr_reader :definitions
 
       # Tools that should never be cached (side effects or user interaction)
-      NO_CACHE = %w[ask_user save_memory delete_memory execute_plan].freeze
+      NO_CACHE = %w[ask_user save_memory delete_memory execute_code execute_plan activate_skill].freeze
 
       def initialize(executor: nil, mode: :default, channel: nil)
         @executor = executor
@@ -216,6 +216,7 @@ module RailsConsoleAi
           )
 
           register_memory_tools
+          register_skill_tools
           register_execute_plan
         end
       end
@@ -270,9 +271,52 @@ module RailsConsoleAi
         )
       end
 
+      def register_skill_tools
+        return unless @executor
+
+        require 'rails_console_ai/skill_loader'
+        loader = RailsConsoleAi::SkillLoader.new
+
+        register(
+          name: 'activate_skill',
+          description: 'Activate a skill to load its recipe and enable its guard bypasses. Call this before following a skill\'s procedure.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'name' => { 'type' => 'string', 'description' => 'The skill name to activate' }
+            },
+            'required' => ['name']
+          },
+          handler: ->(args) {
+            skill = loader.find_skill(args['name'])
+            unless skill
+              return "Skill not found: \"#{args['name']}\". Use the skills listed in the system prompt."
+            end
+
+            bypass_methods = Array(skill['bypass_guards_for_methods'])
+            @executor.activate_skill_bypasses(bypass_methods) unless bypass_methods.empty?
+
+            skill['body']
+          }
+        )
+      end
+
       def register_execute_plan
         return unless @executor
 
+        register(
+          name: 'execute_code',
+          description: 'Execute Ruby code in the Rails console and return the result. Use this for all code execution — simple queries, data lookups, reports, etc. The output of puts/print statements is automatically shown to the user. The return value is sent back to you so you can summarize the findings.',
+          parameters: {
+            'type' => 'object',
+            'properties' => {
+              'code' => { 'type' => 'string', 'description' => 'Ruby code to execute' }
+            },
+            'required' => ['code']
+          },
+          handler: ->(args) { execute_code(args['code']) }
+        )
+
         register(
           name: 'execute_plan',
           description: 'Execute a multi-step plan. Each step has a description and Ruby code. The plan is shown to the user for approval, then each step is executed in order. After each step executes, its return value is stored as step1, step2, etc. Use these variables in later steps to reference earlier results (e.g. `token = step1`).',
@@ -298,6 +342,45 @@ module RailsConsoleAi
         )
       end
 
+      def execute_code(code)
+        return 'No code provided.' if code.nil? || code.strip.empty?
+
+        # Show the code to the user
+        @executor.display_code_block(code)
+
+        # Slack: execute directly, suppress display (output goes back to LLM as tool result).
+        # Console: show code and confirm before executing, display output directly.
+        exec_result = if @channel&.mode == 'slack'
+                        @executor.execute(code, display: false)
+                      elsif RailsConsoleAi.configuration.auto_execute
+                        @executor.execute(code, display: false)
+                      else
+                        @executor.confirm_and_execute(code)
+                      end
+
+        if @executor.last_cancelled?
+          return "User declined to execute the code."
+        end
+
+        if @executor.last_safety_error
+          if @channel && !@channel.supports_danger?
+            return "BLOCKED by safety guard: #{@executor.last_error}. Write operations are not permitted in this channel."
+          else
+            exec_result = @executor.offer_danger_retry(code)
+          end
+        end
+
+        if @executor.last_error
+          return "ERROR: #{@executor.last_error}"
+        end
+
+        output = @executor.last_output
+        parts = []
+        parts << "Output:\n#{output.strip}" if output && !output.strip.empty?
+        parts << "Return value: #{exec_result.inspect}"
+        parts.join("\n\n")
+      end
+
       def execute_plan(steps)
         return 'No steps provided.' if steps.nil? || steps.empty?
 

data/lib/rails_console_ai/version.rb

@@ -1,3 +1,3 @@
 module RailsConsoleAi
-  VERSION = '0.19.0'.freeze
+  VERSION = '0.20.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_console_ai
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.0
 platform: ruby
 authors:
 - Cortfr
@@ -119,6 +119,7 @@ files:
 - lib/rails_console_ai/repl.rb
 - lib/rails_console_ai/safety_guards.rb
 - lib/rails_console_ai/session_logger.rb
+- lib/rails_console_ai/skill_loader.rb
 - lib/rails_console_ai/slack_bot.rb
 - lib/rails_console_ai/storage/base.rb
 - lib/rails_console_ai/storage/file_storage.rb