rails_console_ai 0.19.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fac547626547b2b99702978a38365e9877c11c3e5892be2d91004395ddfb92a4
-  data.tar.gz: f89b097e49fb3fb766bc618082ace286658dce54a496decf98251c1f3a8c6eff
+  metadata.gz: 8faec693c3d3c83dafcaa65437081d5ba8e235f04527a28182104c4ecba5b80d
+  data.tar.gz: 171445a3ddc0c50093b1688260545df1558548a29cb81a6d3262d15d8ec4cf3c
 SHA512:
-  metadata.gz: 7e9b2488043e925762da5b442412f27b92c57facf2fd880b27bbc74314c41cc4c421e091af690b262b0b6ff965aa4ad66cd5efd0bdde6e1de08737d18e7a0411
-  data.tar.gz: fc44b20a37d2bc56254f6b4dc966225f8d7442139ae4f7270194939b5d17291e34adf4c8376edbcdbd9f6078915cdef87a293f255cb57c666213c3ad19f0d02a
+  metadata.gz: 1d0689ebfc82073deb58f8bd03fce39503541d63f042f531322bfc11ef0d6cf65f69fa9ae59c8b89a8a549ea9b4b7893e8505da83887ec4cbc5c1a064ffa5d99
+  data.tar.gz: e8f635c26035fcf73f2ccda5bd3d403a2ec33ef806c701c28f67ee8888a8189625a2569f45c369f7b29189fda3b162f03067be26590afbe5428be9da15487552

data/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.21.0]
+
+- Add Slack @mention support and channel name tracking
+- Stop looping after user cancels execution
+- Remove edit feature from executor
+- Include more info in tool call log line
+- Support class methods in `bypass_guards_for_methods`
+- Rename setup tasks to `ai_db_setup` and `ai_db_migrate`
+- Fix effective model resolution in multi-threaded Slack bot
+- Fix cost tracking with prompt caching through Bedrock
+- Add `/unthink` command
+- Make `!think` / `/think` thread-safe for Slack
+- Fix truncating console output
+- Reduce cost by deferring large output until LLM requests it
+- Add `!name`, `!model`, and `/model` commands to Slack and console
+
+## [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

@@ -12,7 +12,7 @@ irb> ai "find the 5 most recent orders over $100"
 
   Order.where("total > ?", 100).order(created_at: :desc).limit(5)
 
-Execute? [y/N/edit/danger] y
+Execute? [y/N/danger] y
 => [#<Order id: 4821, ...>, ...]
 ```
 
@@ -62,7 +62,8 @@ end
 | `ai!` | Enter interactive mode (multi-turn conversation) |
 | `ai? "query"` | Explain only, no execution |
 | `ai_init` | Generate app guide for better AI context |
-| `ai_setup` | Install session logging table |
+| `ai_db_setup` | Install session logging table + run migrations |
+| `ai_db_migrate` | Run pending session table migrations |
 | `ai_sessions` | List recent sessions |
 | `ai_resume` | Resume a session by name or ID |
 | `ai_memories` | Show stored memories |
@@ -97,9 +98,10 @@ 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)
+- **Sessions** — name, list, and resume interactive conversations (`ai_db_setup` to enable)
 - **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
@@ -141,10 +143,78 @@ 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
-- **`d`** at the `Execute? [y/N/edit/danger]` prompt disables guards for that single execution
+- **`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]`
 
 ## LLM Providers
@@ -227,7 +297,7 @@ Timeout is automatically raised to 300s minimum for local models to account for
 RailsConsoleAi.configure do |config|
   config.provider = :anthropic       # :anthropic, :openai, :bedrock, :local
   config.auto_execute = false         # true to skip confirmations
-  config.session_logging = true       # requires ai_setup
+  config.session_logging = true       # requires ai_db_setup
   config.temperature = 0.2
   config.timeout = 30                 # HTTP timeout in seconds
   config.max_tool_rounds = 200        # safety cap on tool-use loops
@@ -294,11 +364,14 @@ Run RailsConsoleAi as a Slack bot. Each Slack thread becomes an independent AI s
 3. **Bot Token Scopes** — OAuth & Permissions → Bot Token Scopes, add:
    - `chat:write`
    - `channels:history` (public channels)
+   - `channels:read` (channel names in logs, optional)
    - `groups:history` (private channels, optional)
+   - `groups:read` (private channel names in logs, optional)
    - `im:history` (direct messages)
    - `users:read`
 
 4. **Event Subscriptions** — Event Subscriptions → toggle ON, then under "Subscribe to bot events" add:
+   - `app_mention` (respond when @mentioned in any channel)
    - `message.channels` (public channels)
    - `message.groups` (private channels, optional)
    - `message.im` (direct messages)
@@ -330,7 +403,12 @@ end
 bundle exec rake rails_console_ai:slack
 ```
 
-This starts a long-running process (run it separately from your web server). Each new message creates a session; threaded replies continue the conversation. The bot auto-executes code with safety guards always enabled — there is no `/danger` equivalent in Slack.
+This starts a long-running process (run it separately from your web server). The bot auto-executes code with safety guards always enabled — there is no `/danger` equivalent in Slack.
+
+**@mention behavior:**
+- **DMs** — the bot responds to all messages, no @mention needed.
+- **Channels** — the bot only responds when @mentioned. @mention it in any channel message or thread to start a session. The person who first @mentions the bot owns the session — only they can continue the conversation, and they must @mention the bot on each message. Exception: when the bot asks a question, the owner can reply without @mentioning.
+- **Joining threads** — when @mentioned mid-thread, the bot reads the thread history for context so it understands what's already been discussed.
 
 ## Requirements
 

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

@@ -13,6 +13,7 @@
       <tr>
         <th>Time</th>
         <th>User</th>
+        <th>Channel</th>
         <th>Name</th>
         <th style="max-width: 400px;">Query</th>
         <th>Mode</th>
@@ -26,6 +27,7 @@
         <tr>
           <td class="mono"><%= session.created_at.strftime('%Y-%m-%d %H:%M') %></td>
           <td><%= session.user_name %></td>
+          <td><%= session.try(:slack_channel_name).presence || '-' %></td>
           <td><%= session.name.present? ? session.name : '-' %></td>
           <td class="query-cell"><a href="<%= rails_console_ai.session_path(session) %>" title="<%= h session.query.truncate(200) %>"><%= truncate(session.query.gsub(/\s+/, ' ').strip, length: 80) %></a></td>
           <td><span class="badge badge-<%= session.mode %>"><%= session.mode %></span></td>

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

@@ -30,6 +30,12 @@
       <label>User</label>
       <span><%= @session.user_name || '-' %></span>
     </div>
+    <% if @session.try(:slack_channel_name).present? %>
+      <div class="meta-item">
+        <label>Channel</label>
+        <span><%= @session.slack_channel_name %></span>
+      </div>
+    <% end %>
     <div class="meta-item">
       <label>Provider / Model</label>
       <span><%= @session.provider %> / <%= @session.model %></span>

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
@@ -33,6 +37,33 @@ module RailsConsoleAi
         $stdout.puts
       end
 
+      def display_result_output(output)
+        text = output.to_s
+        return if text.strip.empty?
+
+        lines = text.lines
+        total_lines = lines.length
+        total_chars = text.length
+
+        if total_lines <= MAX_DISPLAY_LINES && total_chars <= MAX_DISPLAY_CHARS
+          $stdout.print text
+        else
+          truncated = lines.first(MAX_DISPLAY_LINES).join
+          truncated = truncated[0, MAX_DISPLAY_CHARS] if truncated.length > MAX_DISPLAY_CHARS
+          $stdout.print truncated
+
+          omitted_lines = [total_lines - MAX_DISPLAY_LINES, 0].max
+          omitted_chars = [total_chars - truncated.length, 0].max
+          parts = []
+          parts << "#{omitted_lines} lines" if omitted_lines > 0
+          parts << "#{omitted_chars} chars" if omitted_chars > 0
+
+          @omitted_counter += 1
+          @omitted_outputs[@omitted_counter] = text
+          $stdout.puts colorize("  (output truncated, omitting #{parts.join(', ')})  /expand #{@omitted_counter} to see all", :yellow)
+        end
+      end
+
       def display_result(result)
         full = "=> #{result.inspect}"
         lines = full.lines
@@ -75,7 +106,7 @@ module RailsConsoleAi
       end
 
       def mode
-        'interactive'
+        'console'
       end
 
       def supports_editing?
@@ -251,8 +282,12 @@ module RailsConsoleAi
           @engine.display_conversation
         when '/cost'
           @engine.display_cost_summary
+        when '/model'
+          display_model_info
         when '/think'
           @engine.upgrade_to_thinking_model
+        when '/unthink'
+          @engine.downgrade_from_thinking_model
         when /\A\/expand/
           expand_id = input.sub('/expand', '').strip.to_i
           full_output = expand_output(expand_id)
@@ -316,6 +351,27 @@ module RailsConsoleAi
         end
       end
 
+      def display_model_info
+        config = RailsConsoleAi.configuration
+        model = @engine.effective_model
+        thinking = config.resolved_thinking_model
+        pricing = Configuration::PRICING[model]
+
+        @real_stdout.puts "\e[36m  Model info:\e[0m"
+        @real_stdout.puts "\e[2m    Provider:        #{config.provider}\e[0m"
+        @real_stdout.puts "\e[2m    Model:           #{model}\e[0m"
+        @real_stdout.puts "\e[2m    Thinking model:  #{thinking}\e[0m"
+        @real_stdout.puts "\e[2m    Max tokens:      #{config.resolved_max_tokens}\e[0m"
+        if pricing
+          @real_stdout.puts "\e[2m    Pricing:         $#{pricing[:input] * 1_000_000}/M in, $#{pricing[:output] * 1_000_000}/M out\e[0m"
+          if pricing[:cache_read]
+            @real_stdout.puts "\e[2m    Cache pricing:   $#{pricing[:cache_read] * 1_000_000}/M read, $#{pricing[:cache_write] * 1_000_000}/M write\e[0m"
+          end
+        end
+        @real_stdout.puts "\e[2m    Bedrock region:  #{config.bedrock_region}\e[0m" if config.provider == :bedrock
+        @real_stdout.puts "\e[2m    Local URL:       #{config.local_url}\e[0m" if config.provider == :local
+      end
+
       def handle_name_command(input)
         name = input.sub('/name', '').strip.gsub(/\A(['"])(.*)\1\z/, '\2')
         if name.empty?
@@ -340,7 +396,9 @@ module RailsConsoleAi
           @real_stdout.puts "\e[2m    /danger      Toggle safe mode (currently #{safe_status})\e[0m"
           @real_stdout.puts "\e[2m    /safe        Show safety guard status\e[0m"
         end
+        @real_stdout.puts "\e[2m    /model       Show provider, model, and pricing info\e[0m"
         @real_stdout.puts "\e[2m    /think       Switch to thinking model\e[0m"
+        @real_stdout.puts "\e[2m    /unthink     Switch back to default model\e[0m"
         @real_stdout.puts "\e[2m    /compact     Summarize conversation to reduce context\e[0m"
         @real_stdout.puts "\e[2m    /usage       Show session token totals\e[0m"
         @real_stdout.puts "\e[2m    /cost        Show cost estimate by model\e[0m"

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/console_methods.rb

@@ -130,10 +130,14 @@ module RailsConsoleAi
       nil
     end
 
-    def ai_setup
+    def ai_db_setup
       RailsConsoleAi.setup!
     end
 
+    def ai_db_migrate
+      RailsConsoleAi.migrate!
+    end
+
     def ai_init
       require 'rails_console_ai/context_builder'
       require 'rails_console_ai/providers/base'
@@ -157,7 +161,8 @@ module RailsConsoleAi
         $stderr.puts "\e[33m  ai_sessions  - list recent sessions\e[0m"
         $stderr.puts "\e[33m  ai_resume    - resume a session by name or id\e[0m"
         $stderr.puts "\e[33m  ai_name      - name a session: ai_name 42, \"my_label\"\e[0m"
-        $stderr.puts "\e[33m  ai_setup     - install session logging table\e[0m"
+        $stderr.puts "\e[33m  ai_db_setup  - install session logging table + run migrations\e[0m"
+        $stderr.puts "\e[33m  ai_db_migrate- run pending session table migrations\e[0m"
         $stderr.puts "\e[33m  ai_status    - show current configuration\e[0m"
         $stderr.puts "\e[33m  ai_memories  - show recent memories (ai_memories(n) for last n)\e[0m"
         return nil

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