rubyn-code 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 342d51b0944ce35908b8fd56f52b0321cf698ea01ec3cc8fa572d92b9c332b22
-  data.tar.gz: '033868c98fedc4814cb9e8c94eb8f013b15641d5a3e7cecf7e819d3d3b57f771'
+  metadata.gz: b43dc2a8fab138bcfe303180881aa9fa23878faaa532367f07a0fee7605feb34
+  data.tar.gz: 12dffaa487a75dfe276be9d20ff8152814bd60c6b107efd9ed10d2993afd57a5
 SHA512:
-  metadata.gz: 283cff44827418497c9ed9d27e4331d8fdf24c04825ee3f28e46a33da28bf61f65d0a2b85173187947393856053fad5466dce5782fcef3d0e1dcce68d37e00eb
-  data.tar.gz: 6c96e7beba37f74c0fe947470a1a37d50b521087b573407d6ba7d0d0649d71385b263b70b126fe9c2b7da3c910a233862fdbfb8c1d7c534db6f6cc1d813ec305
+  metadata.gz: fcbe574a607028345e38587388a6c0bd9cdb8ab134e690d45583a1a27b4c698383bd43088eb8fa537cddba8690e77d15ab155be92fb997117c8fe62a978df211
+  data.tar.gz: 43e72475ec24edf03f21e4aafa4402de31351728a38de42e55b69db104aea1828b930a1cafb79d3065d07e16f84c8a5a5023311da5d1e40f7a667daa90ddee3c

data/README.md

@@ -35,9 +35,11 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 - [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)
@@ -61,14 +63,15 @@ Refactor controllers, generate idiomatic RSpec, catch N+1 queries, review code f
 
 - **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
@@ -83,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.
@@ -98,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
 ```
@@ -203,7 +206,7 @@ Rubyn Code includes a VS Code extension that provides a full IDE experience with
 | `default` | Per-tool approval required |
 | `bypass` | YOLO — skip all approval prompts |
 
-The extension communicates over 14 RPC methods: `initialize`, `prompt`, `cancel`, `review`, `approveToolUse`, `acceptEdit`, `session/*`, `config/*`, `models/list`, and `shutdown`.
+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
 
@@ -316,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:
@@ -364,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)
@@ -707,7 +761,7 @@ Checks Ruby version, bundler, database state, authentication, skills, project ty
 
 ## Development
 
-Requires Ruby 4.0+.
+Requires Ruby 4.0.2+.
 
 ```bash
 git clone https://github.com/MatthewSuttles/rubyn-code.git

data/lib/rubyn_code/cli/app.rb

@@ -64,7 +64,7 @@ module RubynCode
         '--auth' => :auth, '--setup' => :setup
       }.freeze
       BOOLEAN_FLAGS = { '--yolo' => :yolo, '--debug' => :debug, '--skip-setup' => :skip_setup, '--ide' => :ide }.freeze
-      VALUE_FLAGS = { '--permission-mode' => :permission_mode }.freeze
+      VALUE_FLAGS = { '--permission-mode' => :permission_mode, '--dir' => :workspace_dir }.freeze
       DAEMON_INT_FLAGS = { '--max-runs' => :max_runs, '--idle-timeout' => :idle_timeout,
                            '--poll-interval' => :poll_interval }.freeze
       DAEMON_STR_FLAGS = { '--name' => :agent_name, '--role' => :role }.freeze
@@ -209,7 +209,7 @@ module RubynCode
 
       def run_ide
         mode = resolve_permission_mode
-        IDE::Server.new(permission_mode: mode).run
+        IDE::Server.new(permission_mode: mode, workspace_path: @options[:workspace_dir]).run
       end
 
       def run_daemon

data/lib/rubyn_code/cli/commands/megaplan.rb

@@ -0,0 +1,50 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      # `/megaplan` REPL command — mirrors the VS Code chat's chat-resident
+      # megaplan entry. Loads the megaplan skill (from the shared
+      # skills catalog) into the conversation, flips plan mode ON so the
+      # agent is restricted to read-only tools, and kicks off a
+      # conversational interview.
+      #
+      # The interview itself is chat-style here (multi-turn natural-
+      # language Q&A), not the structured question-card UI the VS Code
+      # extension uses. Same skill content driving both surfaces.
+      class Megaplan < Base
+        def self.command_name = '/megaplan'
+        def self.description  = 'Plan a feature in phases (interview, then numbered phase docs)'
+        def self.aliases      = ['/mega-plan'].freeze
+
+        def execute(args, ctx)
+          content = ctx.skill_loader.load('megaplan')
+          ctx.conversation.add_user_message("<skill>#{content}</skill>")
+          ctx.renderer.info('Megaplan mode — interviewer with read-only tools 🧠')
+
+          ctx.send_message(build_prompt(args.join(' ').strip))
+
+          { action: :set_plan_mode, enabled: true }
+        rescue StandardError => e
+          ctx.renderer.error("Megaplan error: #{e.message}")
+          nil
+        end
+
+        private
+
+        def build_prompt(feature)
+          base = <<~PROMPT.strip
+            Conduct a megaplan interview, following the megaplan skill loaded above.
+            Stay strictly read-only: you may inspect files, search code, and check
+            git state, but do NOT edit, write, run shell mutations, or call any
+            destructive tool. Ask ONE question at a time. When you have enough,
+            output the final phase breakdown as a numbered outline.
+          PROMPT
+          return base if feature.empty?
+
+          "#{base}\n\nThe feature to plan: #{feature}"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/repl_commands.rb

@@ -23,7 +23,8 @@ module RubynCode
           Commands::Plan, Commands::ContextInfo, Commands::Diff,
           Commands::Model, Commands::NewSession, Commands::Mcp,
           Commands::Provider, Commands::InstallSkills,
-          Commands::RemoveSkills, Commands::Skills
+          Commands::RemoveSkills, Commands::Skills,
+          Commands::Megaplan
         ].each { |cmd| @command_registry.register(cmd) }
       end
 

data/lib/rubyn_code/cli/setup.rb

@@ -95,6 +95,19 @@ module RubynCode
           #
           # To regenerate: rubyn-code --setup
           # To remove:     rm #{path}
+          if [ ! -x "#{pinned_ruby}" ] || [ ! -f "#{gem_wrapper}" ]; then
+            echo "rubyn-code: launcher target missing" >&2
+            [ ! -x "#{pinned_ruby}" ] && echo "  pinned Ruby: #{pinned_ruby}" >&2
+            [ ! -f "#{gem_wrapper}" ] && echo "  gem wrapper: #{gem_wrapper}" >&2
+            echo >&2
+            echo "The Ruby that 'rubyn-code --setup' was pinned against (or the gem" >&2
+            echo "itself) was removed. To recover under your current Ruby:" >&2
+            echo >&2
+            echo "  rm '$0'" >&2
+            echo "  gem install rubyn-code" >&2
+            echo "  rubyn-code --setup" >&2
+            exit 127
+          fi
           exec "#{pinned_ruby}" "#{gem_wrapper}" "$@"
         BASH
       end

data/lib/rubyn_code/ide/handlers/plan_interview_answer_handler.rb

@@ -0,0 +1,65 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/answer" — feeds the user's answer into the
+      # active InterviewSession, emits the next question OR the final plan
+      # via notifications, and returns an empty ack to the extension.
+      class PlanInterviewAnswerHandler
+        SESSION_NOT_FOUND_CODE = -32_011
+        INVALID_INTERVIEW_CODE = -32_010
+
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id  = params['sessionId'].to_s
+          question_id = params['questionId'].to_s
+          answer      = params['answer'].to_s
+
+          session = @server.lookup_interview_session(session_id)
+          unless session
+            raise Protocol::JsonRpcError.new(SESSION_NOT_FOUND_CODE,
+                                              "Unknown interview session: #{session_id}")
+          end
+
+          outcome = session.answer(question_id, answer)
+          emit_outcome(session, outcome)
+          {}
+        rescue Megaplan::InterviewSession::InvalidAnswerError => e
+          raise Protocol::JsonRpcError.new(Protocol::INVALID_PARAMS, e.message)
+        rescue Megaplan::InterviewSession::MalformedResponseError,
+               Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanInterviewAnswerHandler] interview failed: #{e.message}"
+          @server.notify('plan/interview/error', {
+            'sessionId' => params['sessionId'],
+            'message' => e.message
+          })
+          @server.drop_interview_session(params['sessionId'].to_s)
+          raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
+        end
+
+        private
+
+        def emit_outcome(session, outcome)
+          if outcome.is_a?(Megaplan::InterviewSession::Question)
+            @server.notify('plan/interview/question', {
+              'sessionId' => session.session_id,
+              'questionId' => outcome.id,
+              'text' => outcome.text,
+              'options' => outcome.options
+            })
+          else
+            @server.notify('plan/interview/done', {
+              'sessionId' => session.session_id,
+              'plan' => outcome
+            })
+            @server.drop_interview_session(session.session_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_interview_cancel_handler.rb

@@ -0,0 +1,22 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/cancel" — drops the named InterviewSession.
+      # Notification handler (no id), so it never sends a response. Unknown
+      # sessionIds are no-ops; the extension treats cancel as best-effort.
+      class PlanInterviewCancelHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId'].to_s
+          @server.drop_interview_session(session_id)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_interview_start_handler.rb

@@ -0,0 +1,53 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/start" — kicks off a megaplan interview
+      # session. Creates the InterviewSession, fires the first LLM turn,
+      # and emits either a plan/interview/question or plan/interview/done
+      # notification before returning the new sessionId to the extension.
+      class PlanInterviewStartHandler
+        INVALID_INTERVIEW_CODE = -32_010
+
+        def initialize(server, factory: nil)
+          @server = server
+          @factory = factory || ->(workspace_path:) {
+            Megaplan::InterviewSession.new(workspace_path: workspace_path)
+          }
+        end
+
+        def call(_params)
+          session = @factory.call(workspace_path: @server.workspace_path || Dir.pwd)
+          @server.register_interview_session(session)
+          outcome = session.start
+          emit_outcome(session, outcome)
+          { 'sessionId' => session.session_id }
+        rescue Megaplan::InterviewSession::MalformedResponseError,
+               Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanInterviewStartHandler] interview failed: #{e.message}"
+          raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
+        end
+
+        private
+
+        def emit_outcome(session, outcome)
+          if outcome.is_a?(Megaplan::InterviewSession::Question)
+            @server.notify('plan/interview/question', {
+              'sessionId' => session.session_id,
+              'questionId' => outcome.id,
+              'text' => outcome.text,
+              'options' => outcome.options
+            })
+          else
+            @server.notify('plan/interview/done', {
+              'sessionId' => session.session_id,
+              'plan' => outcome
+            })
+            @server.drop_interview_session(session.session_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_propose_handler.rb

@@ -0,0 +1,41 @@
+  # frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "plan/propose" JSON-RPC request.
+      #
+      # Synchronous: blocks until the LLM returns a structured plan or
+      # raises. The extension shows a progress spinner during the call;
+      # plan generation typically takes 5-30s.
+      #
+      # Response shape mirrors what the extension's PlanManager.toPlan
+      # expects: { slug, feature, phases: [{ number, name, slug, summary,
+      # requirements_md, design_md, tasks_md }] }.
+      class PlanProposeHandler
+        # JSON-RPC error code: a clear signal to the extension that the
+        # LLM produced an unparseable / malformed plan_proposal. The
+        # extension surfaces this with the actual error message.
+        INVALID_PROPOSAL_CODE = -32_001
+
+        def initialize(server, proposer: nil)
+          @server = server
+          @proposer = proposer
+        end
+
+        def call(params)
+          feature = params['feature'].to_s.strip
+          raise Protocol::JsonRpcError.new(Protocol::INVALID_PARAMS, 'feature is required') if feature.empty?
+
+          proposer = @proposer || Megaplan::PlanProposer.new
+          proposer.propose(feature)
+        rescue Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanProposeHandler] invalid proposal: #{e.message}"
+          raise Protocol::JsonRpcError.new(INVALID_PROPOSAL_CODE, e.message)
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/recover_ci_handler.rb

@@ -0,0 +1,132 @@
+  # frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "recover_ci" JSON-RPC request.
+      #
+      # Takes the recovery context the extension packaged (failing log,
+      # phase docs, branch, attempt counts) and runs the agent against
+      # it. Returns the recovery_outcome { kind, commit_sha?, summary? }.
+      #
+      # The handler spawns the actual agent work in a background thread
+      # so the JSON-RPC reply can include a sessionId immediately. The
+      # extension watches the session via the existing agent/status
+      # notifications + a terminal recovery/outcome notification carrying
+      # the structured result.
+      class RecoverCiHandler
+        def initialize(server, recovery: nil)
+          @server = server
+          @recovery = recovery
+        end
+
+        def call(params)
+          context = normalize_params(params)
+          return error_response('context required') if context.nil?
+
+          session_id = params['sessionId'] || SecureRandom.uuid
+          Thread.new do
+            run_recovery(session_id, context)
+          end
+          { 'accepted' => true, 'sessionId' => session_id }
+        end
+
+        private
+
+        def run_recovery(session_id, context)
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'recovering',
+                           'phaseNumber' => context['phase_number'],
+                           'attemptNumber' => context['attempt_number']
+                         })
+
+          recovery = @recovery || Megaplan::CiRecovery.new(
+            agent_invoker: build_invoker(session_id)
+          )
+          outcome = recovery.recover(context)
+
+          @server.notify('recovery/outcome', {
+                           'sessionId' => session_id,
+                           'planId' => context['plan_id'],
+                           'phaseNumber' => context['phase_number'],
+                           'kind' => outcome['kind'],
+                           'commitSha' => outcome['commit_sha'],
+                           'summary' => outcome['summary']
+                         })
+
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'done',
+                           'summary' => outcome['summary']
+                         })
+        rescue StandardError => e
+          warn "[RecoverCiHandler] error: #{e.message}"
+          @server.notify('recovery/outcome', {
+                           'sessionId' => session_id,
+                           'planId' => context['plan_id'],
+                           'phaseNumber' => context['phase_number'],
+                           'kind' => 'errored',
+                           'summary' => e.message
+                         })
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'error',
+                           'error' => e.message
+                         })
+        end
+
+        # Build an agent invoker that routes the recovery prompt through
+        # the same Agent::Loop the existing PromptHandler uses, but with
+        # the streaming text wired back as agent/status notifications
+        # tagged with the recovery session id.
+        def build_invoker(session_id)
+          lambda do |prompt, _context|
+            llm_client = LLM::Client.new
+            response = llm_client.chat(
+              messages: [{ role: 'user', content: prompt }],
+              on_text: ->(text) {
+                @server.notify('stream/text', {
+                                 'sessionId' => session_id,
+                                 'text' => text,
+                                 'final' => false
+                               })
+              }
+            )
+            response.is_a?(Hash) ? response : { 'text' => response.to_s }
+          end
+        end
+
+        def normalize_params(params)
+          return nil unless params.is_a?(Hash)
+
+          # Accept both snake_case and camelCase keys — the extension
+          # produces camelCase, but the LLM-side service uses snake_case
+          # internally. Normalize once at the boundary.
+          mapping = {
+            'planId' => 'plan_id',
+            'phaseNumber' => 'phase_number',
+            'prNumber' => 'pr_number',
+            'failingCheckName' => 'failing_check_name',
+            'fullLog' => 'full_log',
+            'trimmedLog' => 'trimmed_log',
+            'commitSha' => 'commit_sha',
+            'attemptNumber' => 'attempt_number',
+            'maxAttempts' => 'max_attempts'
+          }
+          out = params.dup
+          mapping.each do |camel, snake|
+            out[snake] = out.delete(camel) if out.key?(camel) && !out.key?(snake)
+          end
+          out
+        end
+
+        def error_response(message, code: -32_602)
+          { 'error' => { 'code' => code, 'message' => message } }
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers.rb

@@ -14,6 +14,11 @@ require_relative 'handlers/session_reset_handler'
 require_relative 'handlers/session_list_handler'
 require_relative 'handlers/session_resume_handler'
 require_relative 'handlers/session_fork_handler'
+require_relative 'handlers/plan_propose_handler'
+require_relative 'handlers/plan_interview_start_handler'
+require_relative 'handlers/plan_interview_answer_handler'
+require_relative 'handlers/plan_interview_cancel_handler'
+require_relative 'handlers/recover_ci_handler'
 
 module RubynCode
   module IDE
@@ -33,7 +38,12 @@ module RubynCode
         'session/reset' => SessionResetHandler,
         'session/list' => SessionListHandler,
         'session/resume' => SessionResumeHandler,
-        'session/fork' => SessionForkHandler
+        'session/fork' => SessionForkHandler,
+        'plan/propose' => PlanProposeHandler,
+        'plan/interview/start' => PlanInterviewStartHandler,
+        'plan/interview/answer' => PlanInterviewAnswerHandler,
+        'plan/interview/cancel' => PlanInterviewCancelHandler,
+        'recover_ci' => RecoverCiHandler
       }.freeze
 
       # Short name => method name mapping (for handler_instance lookups).
@@ -51,7 +61,12 @@ module RubynCode
         session_reset: 'session/reset',
         session_list: 'session/list',
         session_resume: 'session/resume',
-        session_fork: 'session/fork'
+        session_fork: 'session/fork',
+        plan_propose: 'plan/propose',
+        plan_interview_start: 'plan/interview/start',
+        plan_interview_answer: 'plan/interview/answer',
+        plan_interview_cancel: 'plan/interview/cancel',
+        recover_ci: 'recover_ci'
       }.freeze
 
       # Register all handlers on the given server instance.

data/lib/rubyn_code/ide/protocol.rb

@@ -21,6 +21,21 @@ module RubynCode
       SESSION_NOT_FOUND = -2
       BUDGET_EXCEEDED   = -3
 
+      # Raise from a handler to emit a JSON-RPC error response with a
+      # specific code. The dispatcher catches this and converts it to a
+      # proper `error` envelope — handlers don't have to know how to write
+      # to the wire. Use this instead of returning `{ 'error' => ... }` as
+      # the handler result, which the dispatcher would otherwise serialize
+      # as a successful `result` payload (the very bug this class fixes).
+      class JsonRpcError < StandardError
+        attr_reader :code
+
+        def initialize(code, message)
+          super(message)
+          @code = code
+        end
+      end
+
       module_function
 
       # Parse a JSON string into a request hash.