rubyn-code 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a3ef81b040a1c9a75050f2545f229ba69aa88808ced47ad5cc8634ea52f115c
-  data.tar.gz: 9020382400cdf70d332858a9b85c89e5aa4a90e07965709e8520a803273d43b2
+  metadata.gz: b43dc2a8fab138bcfe303180881aa9fa23878faaa532367f07a0fee7605feb34
+  data.tar.gz: 12dffaa487a75dfe276be9d20ff8152814bd60c6b107efd9ed10d2993afd57a5
 SHA512:
-  metadata.gz: d7c2b95f2eec7e20e589c377784a2236f5ca7fa62402012358137a895f18e899e521ab2a3280854dda2376d515d906a40ad56dcc9c21d65062da6c9549a18912
-  data.tar.gz: cbb80d2749475054829c46aadd8ed5b7244d99f9d6ee05f73a0cd85618866e4e43881ae77e6718dbdcc6cced9e57222752b2a5c403185ae92a039a13da5105e1
+  metadata.gz: fcbe574a607028345e38587388a6c0bd9cdb8ab134e690d45583a1a27b4c698383bd43088eb8fa537cddba8690e77d15ab155be92fb997117c8fe62a978df211
+  data.tar.gz: 43e72475ec24edf03f21e4aafa4402de31351728a38de42e55b69db104aea1828b930a1cafb79d3065d07e16f84c8a5a5023311da5d1e40f7a667daa90ddee3c

data/README.md

@@ -22,16 +22,56 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 
 > **Rubyn is going open source.** The original [Rubyn gem](https://github.com/Rubyn-AI/rubyn) provided AI-assisted refactoring, spec generation, and code review through the Rubyn API. **Rubyn Code** is the next evolution — a complete agentic coding assistant that runs locally, thinks for itself, and learns from every session. No API keys. No separate billing. Just `gem install rubyn-code` and go.
 
+---
+
+## Table of Contents
+
+- [Why Rubyn?](#why-rubyn)
+- [Install](#install)
+- [Quick Start](#quick-start)
+- [What Can Rubyn Do?](#what-can-rubyn-do)
+- [VS Code Extension](#vs-code-extension)
+- [29 Built-in Tools](#29-built-in-tools)
+- [MCP — External Tool Servers](#mcp--external-tool-servers)
+- [Codebase Indexing](#codebase-indexing)
+- [112 Best Practice Skills](#112-best-practice-skills)
+- [Skill Packs — Registry-Backed Extensions](#skill-packs--registry-backed-extensions)
+- [Context Architecture](#context-architecture)
+- [RUBYN.md — Project Instructions](#rubynmd--project-instructions)
+- [PR Review](#pr-review)
+- [Megaplan — Phased Planning](#megaplan--phased-planning)
+- [Sub-Agents & Teams](#sub-agents--teams)
+- [GOLEM — Autonomous Daemon](#golem--autonomous-daemon)
+- [Continuous Learning](#continuous-learning)
+- [Streaming Output](#streaming-output)
+- [Search Providers](#search-providers)
+- [User Hooks](#user-hooks)
+- [CLI Reference](#cli-reference)
+- [Authentication](#authentication)
+- [Architecture](#architecture)
+- [Configuration](#configuration)
+- [Security](#security)
+- [Diagnostics](#diagnostics)
+- [Development](#development)
+- [From Rubyn to Rubyn Code](#from-rubyn-to-rubyn-code)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
 ## Why Rubyn?
 
 - **Rails-native** — understands service object extraction, RSpec conventions, ActiveRecord patterns, and Hotwire
 - **Context-aware** — automatically incorporates schema, routes, specs, factories, and models
-- **Best practices built in** — ships with 112 curated Ruby and Rails guidelines that load on demand
+- **Best practices built in** — ships with 112 curated Ruby and Rails guidelines that load on demand, plus registry-backed [skill packs](#skill-packs--registry-backed-extensions) that autoload as you need them
+- **Plans big work in phases** — [`/megaplan`](#megaplan--phased-planning) runs a read-only interview, then breaks rewrites and migrations into vertical-slice phases that ship one at a time
 - **Agentic** — doesn't just answer questions. Reads files, writes code, runs specs, commits, reviews PRs, spawns sub-agents, and remembers what it learns
+- **IDE-ready** — works in the terminal and inside VS Code with full bidirectional communication
+- **Extensible** — connect external tool servers via MCP, add custom skills, or wire up your own providers
 
 ## Install
 
-Requires **Ruby 4.0+**. Install with your latest Ruby, then pin it so it works in every project:
+Requires **Ruby 4.0.2+**. Install with your latest Ruby, then pin it so it works in every project:
 
 ```bash
 # Install the gem
@@ -46,11 +86,11 @@ That's it. `rubyn-code` now works in any project regardless of `.ruby-version`.
 <details>
 <summary>Using rbenv?</summary>
 
-If you manage multiple Rubies with rbenv, install on your latest:
+If you manage multiple Rubies with rbenv, install on your latest (run `rbenv versions` to list what you have):
 
 ```bash
-RBENV_VERSION=4.0.2 gem install rubyn-code
-RBENV_VERSION=4.0.2 rubyn-code --setup
+RBENV_VERSION=<your-ruby-version> gem install rubyn-code
+RBENV_VERSION=<your-ruby-version> rubyn-code --setup
 ```
 
 The `--setup` command creates a launcher in `~/.local/bin` that calls the gem wrapper directly, skipping rbenv's shim. As long as `~/.local/bin` is in your PATH before `~/.rbenv/shims`, you're good.
@@ -61,7 +101,7 @@ The `--setup` command creates a launcher in `~/.local/bin` that calls the gem wr
 <summary>Using rvm?</summary>
 
 ```bash
-rvm use 4.0.2
+rvm use <your-ruby-version>
 gem install rubyn-code
 rubyn-code --setup
 ```
@@ -93,6 +133,9 @@ rubyn-code --yolo
 
 # Single prompt
 rubyn-code -p "Refactor app/controllers/orders_controller.rb into service objects"
+
+# VS Code IDE mode (used by the extension)
+rubyn-code --ide
 ```
 
 ## What Can Rubyn Do?
@@ -118,7 +161,7 @@ rubyn > Write specs for the new service objects
   > write_file: path=spec/services/orders/create_service_spec.rb
   > run_specs: path=spec/services/orders/
 
-4 examples, 0 failures. All green. ✓
+4 examples, 0 failures. All green.
 ```
 
 ### Review code
@@ -142,6 +185,29 @@ Agent finished (23 tool calls).
 This is a Rails 7.1 e-commerce app with...
 ```
 
+## VS Code Extension
+
+Rubyn Code includes a VS Code extension that provides a full IDE experience with bidirectional JSON-RPC communication. The extension runs Rubyn as a subprocess and connects over stdin/stdout.
+
+**Capabilities:**
+
+- Chat panel with streaming responses and syntax-highlighted code blocks
+- Inline diffs — review and accept generated code changes directly in the editor
+- Tool approval prompts in the IDE (or skip them in YOLO mode)
+- Full session management — resume, list, fork, and reset conversations
+- Structured code review feedback with severity ratings
+- IDE config get/set for persistent settings
+- All 29 tools available, including MCP tools
+
+**Permission modes:**
+
+| Mode | Behavior |
+|------|----------|
+| `default` | Per-tool approval required |
+| `bypass` | YOLO — skip all approval prompts |
+
+The extension communicates over 19 RPC methods: `initialize`, `prompt`, `cancel`, `review`, `approveToolUse`, `acceptEdit`, `session/*`, `config/*`, `models/list`, `plan/propose`, `plan/interview/*` (chat-resident [megaplan](#megaplan--phased-planning)), `recover_ci`, and `shutdown`.
+
 ## 29 Built-in Tools
 
 | Category | Tools |
@@ -159,6 +225,58 @@ This is a Rails 7.1 e-commerce app with...
 | **Teams** | `send_message`, `read_inbox` |
 | **Interactive** | `ask_user` (ask clarifying questions mid-task) |
 
+## MCP — External Tool Servers
+
+Connect external tool servers via the [Model Context Protocol](https://modelcontextprotocol.io). MCP tools are dynamically discovered and registered as native Rubyn tools, available in the REPL, IDE, and daemon.
+
+### Configuration
+
+Create `.rubyn-code/mcp.json` in your project or `~/.rubyn-code/mcp.json` globally:
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
+    },
+    "my-api": {
+      "url": "http://localhost:3001/mcp",
+      "timeout": 30
+    }
+  }
+}
+```
+
+- **Stdio transport** — specify `command` and `args` to run a subprocess
+- **SSE transport** — specify `url` for HTTP-based servers
+- Environment variables are interpolated with `${VAR}` syntax
+
+MCP tools appear in the tool palette prefixed with `mcp_` and require confirmation before execution. Run `/doctor` to verify server connectivity.
+
+Rubyn ships with three example MCP servers: **database explorer**, **RubyGems lookup**, and **Rails routes**. See `/mcp` for documentation.
+
+## Codebase Indexing
+
+Rubyn builds a structural index of your codebase on first session and incrementally updates it as files change. The index powers smarter context injection, skill suggestions, and impact analysis.
+
+**What it tracks:**
+
+- Classes, modules, methods, callbacks, scopes, validations, associations
+- Relationships between files (associations, test coverage, caller/callee)
+- Rails patterns: `has_many`, `belongs_to`, `before_action`, `validates`, etc.
+- File classification: model, controller, service, concern, spec
+
+**How it's used:**
+
+- Injects a compact structural summary into the system prompt
+- Feeds the dynamic tool schema for smarter tool selection
+- Powers `impact_analysis(file)` to find affected tests and dependents
+- Suggests relevant skills based on the code you're working with
+
+Stored at `.rubyn-code/codebase_index.json`. The `/doctor` command flags stale indexes (>24 hours).
+
 ## 112 Best Practice Skills
 
 Rubyn ships with curated best practice documents that load on demand. Only skill names are in memory — full content loads when Rubyn needs it.
@@ -176,6 +294,17 @@ Rubyn ships with curated best practice documents that load on demand. Only skill
 | **Gems** | Sidekiq, Devise, FactoryBot, Pundit, Faraday, Stripe, RuboCop, dry-rb |
 | **Sinatra** | Application structure, middleware, testing |
 
+### Skill search & filter
+
+```
+rubyn > /skill search factory      # search by name, description, or tags
+rubyn > /skill list rails          # filter by category
+rubyn > /skill list                # show all categories
+rubyn > /skill load rspec_matchers # inject a skill into context
+```
+
+Results are relevance-ranked: name matches score highest, then description, then tags.
+
 ### Custom skills
 
 Override or extend with your own:
@@ -190,6 +319,29 @@ mkdir -p ~/.rubyn-code/skills
 echo "# Use double quotes for strings" > ~/.rubyn-code/skills/my_style.md
 ```
 
+## Skill Packs — Registry-Backed Extensions
+
+Beyond the 112 built-in skills, Rubyn can pull additional skill packs from the [rubyn.ai](https://rubyn.ai) registry. Packs are bundles of related skills published by the community or by Rubyn itself.
+
+```
+rubyn > /skills                    # list installed packs and browse the registry
+rubyn > /install-skills sidekiq    # install a pack by name
+rubyn > /install-skills graphql viewcomponent  # install multiple at once
+rubyn > /remove-skills sidekiq     # uninstall
+```
+
+Installed packs live at `~/.rubyn-code/skill-packs/<pack-name>/` and load alongside the built-in catalog.
+
+### Auto-suggest from your Gemfile
+
+On session start, Rubyn parses your `Gemfile` and quietly suggests matching packs the first time it sees a gem (e.g. detects `sidekiq` → suggests the sidekiq pack). Suggestions are recorded in `.rubyn-code/suggested.json` so you only see each one once.
+
+### Trigger-based autoload
+
+If your message mentions a topic that matches an uninstalled pack's name or tags, Rubyn fetches the pack from the registry on the fly, installs it, and feeds the relevant skills into the same turn. Registry failures are silent — the conversation continues as if the autoload weren't there.
+
+Point at a custom registry with `RUBYN_REGISTRY_URL=https://your-registry.example.com`.
+
 ## Context Architecture
 
 Rubyn automatically loads relevant context based on what you're working on:
@@ -199,6 +351,8 @@ Rubyn automatically loads relevant context based on what you're working on:
 - **Service objects** → includes referenced models and their specs
 - **Any file** → checks for `RUBYN.md`, `CLAUDE.md`, or `AGENT.md` instructions
 
+The [codebase index](#codebase-indexing) enhances this with structural awareness — Rubyn knows which files depend on each other before it reads them.
+
 ## RUBYN.md — Project Instructions
 
 Drop a `RUBYN.md` in your project root and Rubyn follows your conventions:
@@ -236,6 +390,34 @@ Focus areas: `all`, `security`, `performance`, `style`, `testing`
 
 Severity ratings: **[critical]** **[warning]** **[suggestion]** **[nitpick]**
 
+## Megaplan — Phased Planning
+
+For work too big for a single PR — rewrites, migrations, multi-feature initiatives — Rubyn ships a planning workflow that breaks the feature into vertical-slice phases before any code gets written.
+
+```
+rubyn > /megaplan extract billing into its own service
+  Megaplan mode — interviewer with read-only tools
+
+  Decisions so far: (none yet)
+
+  Q1. What triggers the extraction now — a scaling issue, a team boundary,
+      or a compliance constraint?
+        1. Scaling (recommended — billing is the hottest table)
+        2. Team boundary
+        3. Compliance
+```
+
+What happens when you run `/megaplan`:
+
+- Loads the **megaplan** skill into context.
+- Flips the agent into **plan mode** — only read-only tools (file reads, search, git status) are available. No edits, no shell mutations.
+- Conducts a one-question-at-a-time interview to lock down scope, constraints, and risk before proposing phases.
+- Outputs a numbered phase breakdown, each phase shippable on its own with the trunk staying green.
+
+Trigger phrases like "megaplan", "mega plan", "plan phases", or "phase this out" in normal conversation will surface the skill via [trigger-based autoload](#skill-packs--registry-backed-extensions) too.
+
+In the VS Code extension the same workflow runs as a chat-resident interview with structured question cards instead of free-text Q&A. Same skill driving both surfaces.
+
 ## Sub-Agents & Teams
 
 ### Sub-Agents (disposable)
@@ -259,6 +441,32 @@ rubyn > Send alice a message to write specs for the User model
 
 Teammates run in background threads with their own agent loop and mailbox.
 
+## GOLEM — Autonomous Daemon
+
+GOLEM is an always-on autonomous agent that claims tasks from a queue and works through them independently. It runs a full agent loop per task with access to all tools, MCP servers, and memory.
+
+```bash
+rubyn-code daemon \
+  --name golem-1 \
+  --role "Backend Engineer" \
+  --max-runs 100 \
+  --max-cost 10.0 \
+  --poll-interval 5 \
+  --idle-timeout 60
+```
+
+**Lifecycle:** `spawned → working ⇄ idle → shutting_down → stopped`
+
+**Safety limits:**
+
+| Guard | Description |
+|-------|-------------|
+| `--max-runs` | Auto-shutdown after N completed tasks |
+| `--max-cost` | Stop when cumulative USD spend exceeds limit |
+| **Retry backoff** | 3 retries per task before marking failed |
+| **Audit trail** | Full conversation saved per task via session persistence |
+| **Cost tracking** | Accurate per-task spend via the observability layer |
+
 ## Continuous Learning
 
 Rubyn gets smarter with every session:
@@ -310,12 +518,14 @@ post_tool_use:
 rubyn-code                    # Interactive REPL
 rubyn-code --yolo             # Auto-approve all tools
 rubyn-code -p "prompt"        # Single prompt, exit when done
+rubyn-code --ide              # IDE server mode (JSON-RPC over stdin/stdout)
 rubyn-code --resume [ID]      # Resume previous session
 rubyn-code --setup            # Pin to this Ruby (run once after install)
 rubyn-code --debug            # Enable debug output
 rubyn-code --auth             # Authenticate with Claude
 rubyn-code --version          # Show version
 rubyn-code --help             # Show help
+rubyn-code daemon [OPTIONS]   # Run GOLEM autonomous daemon
 ```
 
 ### Slash Commands
@@ -331,10 +541,12 @@ rubyn-code --help             # Show help
 | `/cost` | Show token usage and costs |
 | `/tasks` | List all tasks |
 | `/budget [amt]` | Show or set session budget |
-| `/skill [name]` | Load or list available skills |
+| `/skill [name]` | Load, search, or list available skills |
 | `/resume [id]` | Resume or list sessions |
 | `/provider` | Add or list providers |
 | `/model` | Show/switch model and provider |
+| `/doctor` | Run environment health checks |
+| `/mcp` | MCP server documentation and status |
 
 ## Authentication
 
@@ -527,9 +739,29 @@ This means:
 | `~/.rubyn-code/.encryption_salt` | `0600` | PBKDF2 salt (not secret alone, but protected) |
 | `~/.rubyn-code/config.yml` | `0600` | Provider config (no secrets) |
 
+## Diagnostics
+
+Run `/doctor` to check your environment:
+
+```
+rubyn > /doctor
+
+✓ Ruby version         4.0.2
+✓ Bundler              installed
+✓ Database             12 migrations applied
+✓ Authentication       valid (keychain)
+✓ Skills               112 available
+✓ Project detected     Rails 7.1
+✓ MCP servers          2 connected
+✓ Codebase index       fresh (2 hours ago)
+✓ Skill catalog        112 skills, 0 malformed
+```
+
+Checks Ruby version, bundler, database state, authentication, skills, project type, MCP server connectivity, codebase index freshness, and skill catalog integrity.
+
 ## Development
 
-Requires Ruby 4.0+.
+Requires Ruby 4.0.2+.
 
 ```bash
 git clone https://github.com/MatthewSuttles/rubyn-code.git
@@ -538,6 +770,12 @@ bundle install
 bundle exec rspec
 ```
 
+Quick rebuild from source:
+
+```bash
+bin/dev-install
+```
+
 ## From Rubyn to Rubyn Code
 
 If you used the original [Rubyn gem](https://github.com/Rubyn-AI/rubyn), here's what changed:

data/lib/rubyn_code/agent/conversation.rb

@@ -177,7 +177,8 @@ module RubynCode
                                      id_str_key: 'tool_use_id')
       end
 
-      def collect_block_ids(formatted, role:, type:, id_key:, id_str_key:) # rubocop:disable Metrics/CyclomaticComplexity -- iterates blocks with type+role guards
+      # -- iterates blocks with type+role guards
+      def collect_block_ids(formatted, role:, type:, id_key:, id_str_key:)
         ids = Set.new
         formatted.each do |msg|
           next unless msg[:role] == role && msg[:content].is_a?(Array)

data/lib/rubyn_code/agent/dynamic_tool_schema.rb

@@ -64,7 +64,8 @@ module RubynCode
         # @param message [String]
         # @param codebase_index [RubynCode::Index::CodebaseIndex, nil] optional index for deeper detection
         # @return [Symbol, nil]
-        def detect_context(message, codebase_index: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- context detection dispatch
+        # -- context detection dispatch
+        def detect_context(message, codebase_index: nil)
           msg = message.to_s.downcase
           return :testing if msg.match?(/\b(test|spec|rspec)\b/)
           return :git     if msg.match?(/\b(commit|push|diff|branch|merge|git)\b/)

data/lib/rubyn_code/agent/llm_caller.rb

@@ -43,7 +43,8 @@ module RubynCode
       # Only returns models from the active provider — never crosses
       # provider boundaries (e.g., won't send a GPT model to Anthropic).
       # Falls back to nil (use client's default) if routing fails.
-      def routed_model # rubocop:disable Metrics/CyclomaticComplexity -- guard clauses for provider/mode checks
+      # -- guard clauses for provider/mode checks
+      def routed_model
         return nil if manual_model_mode?
 
         last_user = last_user_message_text
@@ -76,7 +77,8 @@ module RubynCode
         content.is_a?(String) ? content : nil
       end
 
-      def log_llm_call(opts) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- safe accessor checks
+      # -- safe accessor checks
+      def log_llm_call(opts)
         default_model = @llm_client.respond_to?(:model) ? @llm_client.model : 'default'
         routed = opts[:model]
         effective = routed || default_model

data/lib/rubyn_code/agent/loop.rb

@@ -59,6 +59,7 @@ module RubynCode
         inject_skill_listing unless @skills_injected
         @decision_compactor&.detect_topic_switch(user_input)
         @skill_ttl&.tick!
+        autoload_triggered_skills(user_input)
         @conversation.add_user_message(user_input)
         reset_iteration_state
 
@@ -93,6 +94,8 @@ module RubynCode
         @background_manager = opts[:background_manager]
         @stall_detector     = opts.fetch(:stall_detector, LoopDetector.new)
         @skill_loader       = opts[:skill_loader]
+        @skill_matcher      = opts[:skill_matcher]
+        @web_skill_autoload = opts[:web_skill_autoload]
         @project_root       = opts[:project_root]
         @tool_wrapper       = opts[:tool_wrapper]
         @decision_compactor = build_decision_compactor
@@ -134,9 +137,10 @@ module RubynCode
       end
 
       def assign_callbacks(opts)
-        @on_tool_call   = opts[:on_tool_call]
-        @on_tool_result = opts[:on_tool_result]
-        @on_text        = opts[:on_text]
+        @on_tool_call          = opts[:on_tool_call]
+        @on_tool_result        = opts[:on_tool_result]
+        @on_text               = opts[:on_text]
+        @on_skills_autoloaded  = opts[:on_skills_autoloaded]
         @skills_injected = false
       end
 

data/lib/rubyn_code/agent/response_modes.rb

@@ -45,7 +45,8 @@ module RubynCode
         # @param message [String] the user's input
         # @param tool_calls [Array] recent tool calls (for context)
         # @return [Symbol] one of the MODES keys
-        def detect(message, tool_calls: []) # rubocop:disable Metrics/CyclomaticComplexity -- mode detection dispatch
+        # -- mode detection dispatch
+        def detect(message, tool_calls: [])
           return :implementing if implementation_signal?(message)
           return :debugging    if debugging_signal?(message)
           return :reviewing    if reviewing_signal?(message)

data/lib/rubyn_code/agent/system_prompt_builder.rb

@@ -123,6 +123,45 @@ module RubynCode
         @skills_injected = true
       end
 
+      # Match the current user message against every skill's :triggers and
+      # inject the body of any new match into the conversation so the LLM sees
+      # it on the next call. Per-session dedup lives in the Matcher.
+      #
+      # When the message matches a registry pack the user hasn't installed,
+      # @web_skill_autoload silently fetches it, installs it, refreshes the
+      # catalog, and surfaces any new skill matches. Web fallback failures
+      # are silent so the turn proceeds normally.
+      def autoload_triggered_skills(user_input)
+        return unless @skill_matcher && @skill_loader
+
+        matches = @skill_matcher.match(user_input)
+        matches += @web_skill_autoload.try(user_input) if @web_skill_autoload
+        return if matches.empty?
+
+        names = matches.map { |m| m[:name] }
+        bodies = names.filter_map do |name|
+          @skill_loader.load(name)
+        rescue StandardError => e
+          RubynCode::Debug.warn("Failed to autoload skill '#{name}': #{e.message}")
+          nil
+        end
+        return if bodies.empty?
+
+        inject_autoloaded_bodies(bodies)
+        @on_skills_autoloaded&.call(names)
+      end
+
+      def inject_autoloaded_bodies(bodies)
+        @conversation.add_user_message(
+          '[system] The following skills are auto-loaded based on the next user ' \
+          "message's triggers. Use them as context. Do not mention this message " \
+          "to the user.\n\n#{bodies.join("\n\n")}"
+        )
+        @conversation.add_assistant_message(
+          [{ type: 'text', text: 'Understood.' }]
+        )
+      end
+
       def append_deferred_tools(parts)
         deferred = deferred_tool_names
         return if deferred.empty?

data/lib/rubyn_code/agent/tool_processor.rb

@@ -26,7 +26,8 @@ module RubynCode
         all_tools.select { |t| core_or_discovered?(t) }
       end
 
-      def detect_task_context # rubocop:disable Metrics/CyclomaticComplexity -- safe navigation chain
+      # -- safe navigation chain
+      def detect_task_context
         last_msg = @conversation&.messages&.reverse_each&.find { |m| m[:role] == 'user' } # rubocop:disable Style/SafeNavigationChainLength
         return nil unless last_msg
 
@@ -142,7 +143,8 @@ module RubynCode
         end
       end
 
-      def signal_decision_compactor(tool_name, tool_input, result) # rubocop:disable Metrics/CyclomaticComplexity -- tool dispatch
+      # -- tool dispatch
+      def signal_decision_compactor(tool_name, tool_input, result)
         return unless @decision_compactor
 
         case tool_name