rubyn-code 0.5.1 → 0.8.0

data/lib/rubyn_code/tools/executor.rb

@@ -5,7 +5,7 @@ module RubynCode
     class Executor
       attr_reader :project_root, :output_compressor, :file_cache
       attr_accessor :llm_client, :background_worker, :on_agent_status, :db, :ask_user_callback,
-                    :codebase_index, :ide_client
+                    :codebase_index, :ide_client, :todo_store
 
       def initialize(project_root:, ide_client: nil)
         @project_root = File.expand_path(project_root)
@@ -56,12 +56,17 @@ module RubynCode
 
       def build_tool(tool_name)
         tool_class = Registry.get(tool_name)
-        # IDE-aware tools accept an ide_client parameter.
-        if @ide_client && tool_class.method(:new).parameters.any? { |_, name| name == :ide_client }
+        # IDE-aware tools accept an ide_client parameter. Inspect #initialize,
+        # not .method(:new) — the latter reports Class#new's own [[:rest]]
+        # signature and never forwards to the constructor.
+        if @ide_client && tool_class.instance_method(:initialize).parameters.any? { |_, name| name == :ide_client }
           tool = tool_class.new(project_root: project_root, ide_client: @ide_client)
         else
           tool = tool_class.new(project_root: project_root)
         end
+        if @todo_store && tool_class.instance_method(:initialize).parameters.any? { |_, name| name == :store }
+          tool.instance_variable_set(:@store, @todo_store)
+        end
         inject_dependencies(tool, tool_name)
         tool
       end
@@ -140,7 +145,7 @@ module RubynCode
         path = resolve_cache_path(params)
         return unless path&.end_with?('.rb')
 
-        @codebase_index.update!
+        @codebase_index.update_file!(path)
       rescue StandardError => e
         RubynCode::Debug.warn("CodebaseIndex incremental update failed: #{e.message}")
       end

data/lib/rubyn_code/tools/spawn_agent.rb

@@ -9,8 +9,9 @@ module RubynCode
       TOOL_NAME = 'spawn_agent'
       DESCRIPTION = 'Spawn an isolated sub-agent to handle a task. The sub-agent gets its own ' \
                     "fresh context, works independently, and returns only a summary. Use 'explore' " \
-                    "type for research/reading, 'worker' type for writing code/files. The sub-agent " \
-                    'shares the filesystem but not your conversation.'
+                    "type for research/reading, 'worker' type for writing code/files, or the name " \
+                    'of any custom agent defined in .rubyn-code/agents/. The sub-agent shares the ' \
+                    'filesystem but not your conversation.'
       PARAMETERS = {
         prompt: {
           type: :string,
@@ -19,76 +20,73 @@ module RubynCode
         },
         agent_type: {
           type: :string,
-          description: "Type of agent: 'explore' (read-only) or 'worker' (full write access). Default: explore",
-          required: false,
-          enum: %w[explore worker]
+          description: "Agent type: 'explore' (read-only), 'worker' (full write access), or a " \
+                       'custom agent name from .rubyn-code/agents/. Default: explore',
+          required: false
         }
       }.freeze
       RISK_LEVEL = :execute
 
+      READ_TOOLS = %w[read_file glob grep bash load_skill memory_search].freeze
+      BLOCKED_TOOLS = %w[spawn_agent send_message read_inbox compact memory_write].freeze
+
       # These get injected by the executor or the REPL
       attr_writer :llm_client, :on_status
 
       def execute(prompt:, agent_type: 'explore')
-        type = agent_type.to_sym
+        agent = resolve_agent(agent_type)
         callback = @on_status || method(:default_status)
         @tool_count = 0
 
-        callback.call(:started, "Spawning #{type} agent...")
+        callback.call(:started, "Spawning #{agent.name} agent...")
 
-        tools = tools_for_type(type)
-        result, hit_limit = run_sub_agent(
-          prompt: prompt, tools: tools, type: type, callback: callback
-        )
+        tools = tools_for(agent)
+        result, hit_limit = run_sub_agent(prompt: prompt, tools: tools, agent: agent, callback: callback)
 
         callback.call(:done, "Agent finished (#{@tool_count} tool calls).")
 
         summary = RubynCode::SubAgents::Summarizer.call(result, max_length: 3000)
-        format_agent_result(type, summary, hit_limit)
+        format_agent_result(agent.name, summary, hit_limit)
       end
 
       private
 
-      def format_agent_result(type, summary, hit_limit)
+      # Resolve the requested type via the catalog, falling back to explore
+      # for an unknown name so a typo degrades gracefully instead of erroring.
+      def resolve_agent(agent_type)
+        catalog = RubynCode::SubAgents::Catalog.new(project_root: project_root)
+        catalog.get(agent_type) || catalog.get('explore')
+      end
+
+      def format_agent_result(name, summary, hit_limit)
         if hit_limit
-          "## Sub-Agent Result (#{type}) — INCOMPLETE (reached #{@tool_count} tool calls)\n\n" \
+          "## Sub-Agent Result (#{name}) — INCOMPLETE (reached #{@tool_count} tool calls)\n\n" \
             'The sub-agent ran out of turns before finishing. Here is what it accomplished so far:' \
             "\n\n#{summary}"
         else
-          "## Sub-Agent Result (#{type})\n\n#{summary}"
-        end
-      end
-
-      def max_iterations_for(type)
-        if type == :explore
-          Config::Defaults::MAX_EXPLORE_AGENT_ITERATIONS
-        else
-          Config::Defaults::MAX_SUB_AGENT_ITERATIONS
+          "## Sub-Agent Result (#{name})\n\n#{summary}"
         end
       end
 
       # Returns [result_text, hit_limit] tuple
-      def run_sub_agent(prompt:, tools:, type:, callback:)
+      def run_sub_agent(prompt:, tools:, agent:, callback:)
         conversation = RubynCode::Agent::Conversation.new
         conversation.add_user_message(prompt)
 
-        max_iterations = max_iterations_for(type)
         iteration = 0
         last_text = nil
 
         loop do
-          return finish_at_limit(conversation, type, last_text) if iteration >= max_iterations
+          return finish_at_limit(conversation, agent, last_text) if iteration >= agent.max_iterations
 
-          last_text, done = process_iteration(
-            conversation, tools, type, callback, last_text
-          )
+          last_text, done = process_iteration(conversation, tools, agent, callback, last_text)
           return [last_text || '', false] if done
 
           iteration += 1
         end
       end
 
-      def finish_at_limit(conversation, type, last_text)
+      def finish_at_limit(conversation, agent, last_text)
         conversation.add_user_message(
           'You have reached your turn limit. Summarize everything you found or ' \
           'accomplished so far. Be thorough — this is your last chance to report back.'
@@ -96,17 +94,17 @@ module RubynCode
         response = @llm_client.chat(
           messages: conversation.to_api_format,
           tools: [],
-          system: sub_agent_system_prompt(type)
+          system: agent.system_prompt
         )
         summary = extract_text(response)
         [summary.empty? ? (last_text || '') : summary, true]
       end
 
-      def process_iteration(conversation, tools, type, callback, last_text)
+      def process_iteration(conversation, tools, agent, callback, last_text)
         response = @llm_client.chat(
           messages: conversation.to_api_format,
           tools: tools,
-          system: sub_agent_system_prompt(type)
+          system: agent.system_prompt
         )
 
         content = response_content(response)
@@ -117,22 +115,22 @@ module RubynCode
         conversation.add_assistant_message(content)
         return [last_text, true] if tool_calls.empty?
 
-        execute_sub_agent_tools(tool_calls, conversation, type, callback)
+        execute_sub_agent_tools(tool_calls, conversation, agent, callback)
         [last_text, false]
       end
 
-      def execute_sub_agent_tools(tool_calls, conversation, type, callback)
+      def execute_sub_agent_tools(tool_calls, conversation, agent, callback)
         tool_calls.each do |tc|
           name, input, id = extract_tool_call(tc)
           @tool_count += 1
           callback.call(:tool, name.to_s)
 
-          run_single_tool(name, input, id, conversation, type)
+          run_single_tool(name, input, id, conversation, agent)
         end
       end
 
-      def run_single_tool(name, input, id, conversation, type)
-        if %w[spawn_agent].include?(name)
+      def run_single_tool(name, input, id, conversation, agent)
+        if name == 'spawn_agent'
           conversation.add_tool_result(
             id, name, 'Error: Sub-agents cannot spawn other agents.', is_error: true
           )
@@ -140,9 +138,9 @@ module RubynCode
         end
 
         tool_class = RubynCode::Tools::Registry.get(name)
-        if type == :explore && tool_class.risk_level != :read
+        if agent.read_only? && tool_class.risk_level != :read
           conversation.add_tool_result(
-            id, name, 'Error: Explore agents can only use read-only tools.', is_error: true
+            id, name, "Error: #{agent.name} agents can only use read-only tools.", is_error: true
           )
           return
         end
@@ -154,31 +152,18 @@ module RubynCode
         conversation.add_tool_result(id, name, "Error: #{e.message}", is_error: true)
       end
 
-      def tools_for_type(type)
+      # The tool allowlist: explicit list from a custom agent, else the
+      # access-based default (read-only set or everything-minus-blocked).
+      def tools_for(agent)
         all_tools = RubynCode::Tools::Registry.tool_definitions
-        blocked = %w[spawn_agent send_message read_inbox compact memory_write]
-
-        if type == :explore
-          read_tools = %w[read_file glob grep bash load_skill memory_search]
-          all_tools.select { |t| read_tools.include?(t[:name]) }
-        else
-          all_tools.reject { |t| blocked.include?(t[:name]) }
-        end
-      end
 
-      def sub_agent_system_prompt(type)
-        base = 'You are a Rubyn sub-agent. Complete your task efficiently and ' \
-               'return a clear summary of what you found or did.'
-
-        case type
-        when :explore
-          "#{base}\nYou have read-only access. Search, read files, and analyze. " \
-          'Do NOT attempt to write or modify anything.'
-        when :worker
-          "#{base}\nYou have full read/write access. Make the changes needed, " \
-          'run tests if appropriate, and report what you did.'
+        if agent.tool_names && !agent.tool_names.empty?
+          allowed = agent.tool_names - BLOCKED_TOOLS
+          all_tools.select { |t| allowed.include?(t[:name]) }
+        elsif agent.read_only?
+          all_tools.select { |t| READ_TOOLS.include?(t[:name]) }
         else
-          base
+          all_tools.reject { |t| BLOCKED_TOOLS.include?(t[:name]) }
         end
       end
 

data/lib/rubyn_code/tools/spawn_teammate.rb

@@ -25,13 +25,18 @@ module RubynCode
           type: :string,
           description: 'Initial task or instruction for the teammate',
           required: true
+        },
+        parent_agent_id: {
+          type: :string,
+          description: 'ID of the parent agent spawning this teammate (for lineage tracking)',
+          required: false
         }
       }.freeze
       RISK_LEVEL = :execute
 
       attr_writer :llm_client, :on_status, :db
 
-      def execute(name:, role:, prompt:)
+      def execute(name:, role:, prompt:, parent_agent_id: nil)
         callback = @on_status || method(:default_status)
 
         raise Error, 'LLM client not available' unless @llm_client
@@ -40,7 +45,7 @@ module RubynCode
         mailbox = Teams::Mailbox.new(@db)
         manager = Teams::Manager.new(@db, mailbox: mailbox)
 
-        teammate = manager.spawn(name: name, role: role)
+        teammate = manager.spawn(name: name, role: role, parent_agent_id: parent_agent_id)
         callback.call(:started, "Spawning teammate '#{name}' as #{role}...")
 
         Thread.new do

data/lib/rubyn_code/tools/todo_store.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module Tools
+    # Shared, thread-safe checklist store. The Agent::Loop owns one instance and
+    # exposes it to (a) the renderer so the user sees what's in flight, and
+    # (b) the TodoWrite tool so the model can mutate it.
+    class TodoStore
+      include MonitorMixin
+
+      Item = Data.define(:content, :status, :active_form)
+
+      def initialize
+        super
+        @items = []
+      end
+
+      def replace(items)
+        synchronize do
+          @items = items.map do |item|
+            Item.new(
+              content: item['content'] || item[:content],
+              status: item['status'] || item[:status],
+              active_form: (item['active_form'] || item[:active_form]).to_s
+            )
+          end
+        end
+      end
+
+      def current
+        synchronize { @items.map(&:to_h) }
+      end
+
+      def clear
+        synchronize { @items = [] }
+      end
+
+      def empty?
+        current.empty?
+      end
+
+      def render
+        current.map do |item|
+          mark =
+            case item[:status]
+            when 'completed' then '☑'
+            when 'in_progress' then '[~]'
+            else '[ ]'
+            end
+          "#{mark} #{item[:content]}"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/rubyn_code/tools/todo_write.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative 'registry'
+
+module RubynCode
+  module Tools
+    # Update the in-turn task checklist. The model uses this to keep the user
+    # informed of progress while it works. The store is shared between the
+    # Agent::Loop (which exposes it for the renderer) and this tool.
+    class TodoWrite < Base
+      TOOL_NAME = 'TodoWrite'
+      DESCRIPTION = 'Update the in-turn task checklist. ' \
+                    'Use this to keep the user informed of what you plan to do, ' \
+                    'what you are currently working on, and what you have finished.'
+      PARAMETERS = {
+        todos: { type: :array, required: true,
+                 description: 'The full set of tasks currently on the checklist. ' \
+                              'Replace the existing list with this. Each task is ' \
+                              '{ "content": "...", "status": "pending|in_progress|completed", ' \
+                              '"active_form": "..." }.' }
+      }.freeze
+      RISK_LEVEL = :read
+      REQUIRES_CONFIRMATION = false
+
+      VALID_STATUS = %w[pending in_progress completed].freeze
+
+      def initialize(project_root:, store: nil)
+        super(project_root: project_root)
+        @store = store
+      end
+
+      def execute(todos:)
+        items = Array(todos)
+        validated = []
+
+        items.each_with_index do |item, i|
+          return "TodoWrite: item #{i} is not a hash — got #{item.class}" unless item.is_a?(Hash)
+
+          content = item[:content] || item['content']
+          status  = (item[:status] || item['status']).to_s
+          active_form = item[:active_form] || item['active_form']
+
+          return "TodoWrite: item #{i} missing 'content'" if content.to_s.empty?
+          unless VALID_STATUS.include?(status)
+            return "TodoWrite: item #{i} status must be one of #{VALID_STATUS.join('/')} (got #{status.inspect})"
+          end
+
+          validated << {
+            'content' => content.to_s,
+            'status' => status,
+            'active_form' => active_form.to_s.empty? ? content.to_s : active_form.to_s
+          }
+        end
+
+        @store&.replace(validated)
+        format(validated)
+      end
+
+      def self.summarize(_output, args)
+        count = Array(args[:todos] || args['todos']).size
+        if count.zero?
+          'cleared checklist'
+        else
+          "checklist: #{count} item#{'s' unless count == 1}"
+        end
+      end
+
+      private
+
+      def format(items)
+        return 'Checklist cleared.' if items.empty?
+
+        items.map do |item|
+          mark =
+            case item['status']
+            when 'completed' then '[x]'
+            when 'in_progress' then '[~]'
+            else '[ ]'
+            end
+          "#{mark} #{item['content']}"
+        end.join("\n")
+      end
+    end
+
+    Registry.register(TodoWrite)
+  end
+end

data/lib/rubyn_code/tools/web_fetch.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'faraday'
 require_relative 'base'
 require_relative 'registry'
 
@@ -76,6 +75,7 @@ module RubynCode
       end
 
       def build_connection
+        require 'faraday'
         Faraday.new do |f|
           f.options.timeout = 30
           f.options.open_timeout = 10

data/lib/rubyn_code/tools/web_search.rb

@@ -3,7 +3,6 @@
 require 'open3'
 require 'cgi'
 require 'json'
-require 'faraday'
 require_relative 'base'
 require_relative 'registry'
 
@@ -112,6 +111,7 @@ module RubynCode
       end
 
       def brave_request(query, num_results)
+        require 'faraday'
         Faraday.get('https://api.search.brave.com/res/v1/web/search') do |req|
           req.params['q'] = query
           req.params['count'] = num_results
@@ -135,6 +135,7 @@ module RubynCode
       end
 
       def tavily_request(query, num_results)
+        require 'faraday'
         Faraday.post('https://api.tavily.com/search') do |req|
           req.headers['Content-Type'] = 'application/json'
           req.body = JSON.generate(
@@ -156,6 +157,7 @@ module RubynCode
       end
 
       def serpapi_request(query, num_results)
+        require 'faraday'
         Faraday.get('https://serpapi.com/search.json') do |req|
           req.params['q'] = query
           req.params['num'] = num_results
@@ -175,6 +177,7 @@ module RubynCode
       end
 
       def google_request(query, num_results)
+        require 'faraday'
         Faraday.get('https://www.googleapis.com/customsearch/v1') do |req|
           req.params['q'] = query
           req.params['num'] = [num_results, 10].min

data/lib/rubyn_code/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubynCode
-  VERSION = '0.5.1'
+  VERSION = '0.8.0'
 end

data/lib/rubyn_code.rb

@@ -16,11 +16,16 @@ module RubynCode
   # rather than a successful tool call returning a string like "denied".
   class UserDeniedError < Error; end
 
-  # Infrastructure
-  autoload :Config, 'rubyn_code/config/settings'
+  # Chisel — opt-in "write the minimum that works" enforcement (off by default)
+  autoload :Chisel, 'rubyn_code/chisel'
 
+  # Infrastructure
   module Config
+    autoload :Settings, 'rubyn_code/config/settings'
+    autoload :Defaults, 'rubyn_code/config/defaults'
+    autoload :ProjectConfig, 'rubyn_code/config/project_config'
     autoload :ProjectProfile, 'rubyn_code/config/project_profile'
+    autoload :Validator, 'rubyn_code/config/validator'
   end
 
   # Database
@@ -42,6 +47,11 @@ module RubynCode
   module LLM
     autoload :Client, 'rubyn_code/llm/client'
     autoload :MessageBuilder, 'rubyn_code/llm/message_builder'
+    autoload :TextBlock,     'rubyn_code/llm/message_builder'
+    autoload :ThinkingBlock, 'rubyn_code/llm/message_builder'
+    autoload :ImageBlock,    'rubyn_code/llm/message_builder'
+    autoload :ToolUseBlock,  'rubyn_code/llm/message_builder'
+    autoload :ImageReader, 'rubyn_code/llm/image_reader'
     autoload :ModelRouter, 'rubyn_code/llm/model_router'
 
     # Adapters (provider-specific implementations)
@@ -57,9 +67,6 @@ module RubynCode
       autoload :OpenAICompatible, 'rubyn_code/llm/adapters/openai_compatible'
       autoload :OpenAIMessageTranslator, 'rubyn_code/llm/adapters/openai_message_translator'
     end
-
-    # Backward-compat: LLM::Streaming → Adapters::AnthropicStreaming
-    autoload :Streaming, 'rubyn_code/llm/streaming'
   end
 
   # Layer 1: Agent Loop
@@ -75,6 +82,7 @@ module RubynCode
   module Tools
     autoload :Base, 'rubyn_code/tools/base'
     autoload :Registry, 'rubyn_code/tools/registry'
+    autoload :TodoStore, 'rubyn_code/tools/todo_store'
     autoload :Schema, 'rubyn_code/tools/schema'
     autoload :Executor, 'rubyn_code/tools/executor'
     autoload :ReadFile, 'rubyn_code/tools/read_file'
@@ -82,6 +90,7 @@ module RubynCode
     autoload :EditFile, 'rubyn_code/tools/edit_file'
     autoload :Glob, 'rubyn_code/tools/glob'
     autoload :Grep, 'rubyn_code/tools/grep'
+    autoload :CodeGraph, 'rubyn_code/tools/code_graph'
     autoload :Bash, 'rubyn_code/tools/bash'
     autoload :RailsGenerate, 'rubyn_code/tools/rails_generate'
     autoload :DbMigrate, 'rubyn_code/tools/db_migrate'
@@ -89,6 +98,7 @@ module RubynCode
     autoload :BundleInstall, 'rubyn_code/tools/bundle_install'
     autoload :BundleAdd, 'rubyn_code/tools/bundle_add'
     autoload :Compact, 'rubyn_code/tools/compact'
+    autoload :TodoWrite, 'rubyn_code/tools/todo_write'
     autoload :LoadSkill, 'rubyn_code/tools/load_skill'
     autoload :Task, 'rubyn_code/tools/task'
     autoload :MemorySearch, 'rubyn_code/tools/memory_search'
@@ -127,8 +137,6 @@ module RubynCode
     autoload :AutoCompact, 'rubyn_code/context/auto_compact'
     autoload :ManualCompact, 'rubyn_code/context/manual_compact'
     autoload :ContextCollapse, 'rubyn_code/context/context_collapse'
-    autoload :ContextBudget, 'rubyn_code/context/context_budget'
-    autoload :SchemaFilter, 'rubyn_code/context/schema_filter'
     autoload :DecisionCompactor, 'rubyn_code/context/decision_compactor'
   end
 
@@ -153,6 +161,14 @@ module RubynCode
   module SubAgents
     autoload :Runner, 'rubyn_code/sub_agents/runner'
     autoload :Summarizer, 'rubyn_code/sub_agents/summarizer'
+    autoload :AgentType, 'rubyn_code/sub_agents/agent_type'
+    autoload :Catalog, 'rubyn_code/sub_agents/catalog'
+  end
+
+  # Checkpoints (/rewind)
+  module Checkpoint
+    autoload :Manager, 'rubyn_code/checkpoint/manager'
+    autoload :Hook, 'rubyn_code/checkpoint/hook'
   end
 
   # Layer 7: Tasks
@@ -181,12 +197,12 @@ module RubynCode
     autoload :Manager, 'rubyn_code/teams/manager'
     autoload :Mailbox, 'rubyn_code/teams/mailbox'
     autoload :Teammate, 'rubyn_code/teams/teammate'
+    autoload :AgentRegistry, 'rubyn_code/teams/agent_registry'
   end
 
   # Layer 10: Protocols
   module Protocols
     autoload :ShutdownHandshake, 'rubyn_code/protocols/shutdown_handshake'
-    autoload :PlanApproval, 'rubyn_code/protocols/plan_approval'
     autoload :InterruptHandler, 'rubyn_code/protocols/interrupt_handler'
   end
 
@@ -222,6 +238,17 @@ module RubynCode
     autoload :Runner, 'rubyn_code/hooks/runner'
     autoload :BuiltIn, 'rubyn_code/hooks/built_in'
     autoload :UserHooks, 'rubyn_code/hooks/user_hooks'
+    autoload :GoalHook, 'rubyn_code/hooks/goal_hook'
+    autoload :EventMap, 'rubyn_code/hooks/event_map'
+    autoload :Response, 'rubyn_code/hooks/response'
+    autoload :SettingsJsonLoader, 'rubyn_code/hooks/settings_json_loader'
+    autoload :SubprocessExecutor, 'rubyn_code/hooks/subprocess_executor'
+    autoload :ExternalDispatcher, 'rubyn_code/hooks/external_dispatcher'
+  end
+
+  # Session goals (/goal)
+  module Goal
+    autoload :Evaluator, 'rubyn_code/goal/evaluator'
   end
 
   # Layer 15: MCP
@@ -230,7 +257,9 @@ module RubynCode
     autoload :StdioTransport, 'rubyn_code/mcp/stdio_transport'
     autoload :SSETransport, 'rubyn_code/mcp/sse_transport'
     autoload :ToolBridge, 'rubyn_code/mcp/tool_bridge'
+    autoload :ServerExtrasBridge, 'rubyn_code/mcp/server_extras_bridge'
     autoload :Config, 'rubyn_code/mcp/config'
+    autoload :Discovery, 'rubyn_code/mcp/discovery'
   end
 
   # Layer 16: Learning
@@ -239,7 +268,7 @@ module RubynCode
     autoload :Instinct, 'rubyn_code/learning/instinct'
     autoload :InstinctMethods, 'rubyn_code/learning/instinct'
     autoload :Injector, 'rubyn_code/learning/injector'
-    autoload :Shortcut, 'rubyn_code/learning/shortcut'
+    autoload :Porter, 'rubyn_code/learning/porter'
   end
 
   # IDE (VS Code extension server)
@@ -258,6 +287,7 @@ module RubynCode
   # Codebase Index
   module Index
     autoload :CodebaseIndex, 'rubyn_code/index/codebase_index'
+    autoload :PrismExtractor, 'rubyn_code/index/prism_extractor'
   end
 
   # CLI
@@ -271,6 +301,8 @@ module RubynCode
     autoload :Setup, 'rubyn_code/cli/setup'
     autoload :FirstRun, 'rubyn_code/cli/first_run'
     autoload :DaemonRunner, 'rubyn_code/cli/daemon_runner'
+    autoload :LoopRunner, 'rubyn_code/cli/loop_runner'
+    autoload :MentionExpander, 'rubyn_code/cli/mention_expander'
     autoload :VersionCheck, 'rubyn_code/cli/version_check'
 
     # Slash Command System
@@ -304,6 +336,22 @@ module RubynCode
       autoload :RemoveSkills, 'rubyn_code/cli/commands/remove_skills'
       autoload :Skills, 'rubyn_code/cli/commands/skills'
       autoload :Megaplan, 'rubyn_code/cli/commands/megaplan'
+      autoload :Goal, 'rubyn_code/cli/commands/goal'
+      autoload :Loop, 'rubyn_code/cli/commands/loop'
+      autoload :Agents, 'rubyn_code/cli/commands/agents'
+      autoload :CommandTemplate, 'rubyn_code/cli/commands/command_template'
+      autoload :CustomCommand, 'rubyn_code/cli/commands/custom_command'
+      autoload :CustomLoader, 'rubyn_code/cli/commands/custom_loader'
+      autoload :Learning, 'rubyn_code/cli/commands/learning'
+      autoload :Rewind, 'rubyn_code/cli/commands/rewind'
+      autoload :Chisel, 'rubyn_code/cli/commands/chisel'
+      autoload :ChiselReview, 'rubyn_code/cli/commands/chisel_review'
+      autoload :ChiselAudit, 'rubyn_code/cli/commands/chisel_audit'
+      autoload :ChiselDebt, 'rubyn_code/cli/commands/chisel_debt'
+      autoload :ChiselGain, 'rubyn_code/cli/commands/chisel_gain'
+      autoload :Think, 'rubyn_code/cli/commands/think'
+      autoload :Effort, 'rubyn_code/cli/commands/effort'
+      autoload :Export, 'rubyn_code/cli/commands/export'
     end
   end