rubyn-code 0.4.0 → 0.5.0

data/lib/rubyn_code/skills/registry_client.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'faraday'
+require 'json'
+
+module RubynCode
+  module Skills
+    # HTTP client for the rubyn.ai skill packs registry API.
+    # Supports ETag-based conditional requests for efficient cache
+    # validation and offline resilience.
+    class RegistryClient
+      LEADING_SLASHES_REGEX = %r{\A/+}
+      DEFAULT_BASE_URL = 'https://rubyn.ai'
+      TIMEOUT_SECONDS  = 10
+      USER_ACCEPT_HEADER = 'Rubyn Code'
+
+      attr_reader :base_url
+
+      def initialize(base_url: nil)
+        @base_url = base_url || ENV.fetch('RUBYN_REGISTRY_URL', DEFAULT_BASE_URL)
+      end
+
+      # List all available packs (returns flat array for CLI commands).
+      #
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Array<Hash>] array of pack metadata
+      # @raise [RegistryError] on network or parse failure
+      def list_packs(etag: nil)
+        fetch_catalog(etag: etag)[:data] || []
+      end
+
+      # Fetch the full catalog of available skill packs.
+      #
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { data: Array<Hash>, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on network or parse failure
+      def fetch_catalog(etag: nil)
+        response = conditional_get('/api/v1/skills/packs.json', etag: etag)
+        return not_modified_result if response.status == 304
+
+        data = validate_and_parse(response)
+        packs = normalize_packs(data)
+        { data: packs, etag: response.headers['etag'], not_modified: false }
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch skill catalog: #{e.message}"
+      end
+
+      # Search packs by keyword.
+      # Note: The registry API does not support server-side search.
+      # This method fetches the catalog and filters locally.
+      #
+      # @param query [String]
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { data: Array<Hash>, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on network or parse failure
+      def search_packs(query, etag: nil)
+        catalog = fetch_catalog(etag: etag)
+        return catalog if catalog[:not_modified]
+
+        q = query.to_s.downcase
+        filtered = catalog[:data].select { |pack| matches_query?(pack, q) }
+        { data: filtered, etag: catalog[:etag], not_modified: false }
+      end
+
+      # Fetch pack suggestions based on detected gems.
+      #
+      # @param gems [Array<String>] list of gem names detected in the project
+      # @return [Array<Hash>] array of { name: String, reason: String }
+      # @raise [RegistryError] on network or parse failure
+      def fetch_suggestions(gems)
+        return [] if gems.empty?
+
+        gems_param = gems.join(',')
+        response = connection.get('/api/v1/skills/packs/suggest', { gems: gems_param })
+        return [] if response.status == 404
+
+        data = validate_and_parse(response)
+        suggestions = data[:suggestions] || data['suggestions'] || []
+        suggestions.is_a?(Array) ? suggestions : []
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch suggestions: #{e.message}"
+      end
+
+      # Fetch a single pack's full content for installation.
+      # Fetches pack metadata and all skill file contents.
+      #
+      # @param name [String] pack name (validated for safe characters)
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { data: Hash, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on not found, validation, or network failure
+      def fetch_pack(name, etag: nil)
+        validate_pack_name!(name)
+        response = conditional_get("/api/v1/skills/packs/#{encode_name(name)}.json", etag: etag)
+        return not_modified_result if response.status == 304
+
+        data = validate_and_parse(response)
+        validate_pack_response!(data, name)
+
+        # Fetch individual file contents. Manifests may list files under
+        # :files (as { path: ... } hashes) or :skills (as filename strings).
+        files = fetch_key(data, :files) || fetch_key(data, :skills) || []
+        files = files.map { |f| f.is_a?(String) ? { path: f } : f }
+        data[:files] = fetch_files_with_content(name, files)
+
+        { data: data, etag: response.headers['etag'], not_modified: false }
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch pack '#{name}': #{e.message}"
+      end
+
+      # Fetch a single skill file's markdown content.
+      #
+      # @param pack_name [String]
+      # @param file_path [String]
+      # @param etag [String, nil] cached ETag for conditional request
+      # @return [Hash] { content: String, etag: String|nil, not_modified: Boolean }
+      # @raise [RegistryError] on not found or network failure
+      def fetch_file(pack_name, file_path, etag: nil)
+        validate_pack_name!(pack_name)
+        safe_path = file_path.to_s.gsub('..', '').gsub(LEADING_SLASHES_REGEX, '')
+        response = connection.get(
+          "/api/v1/skills/packs/#{encode_name(pack_name)}/files/#{ERB::Util.url_encode(safe_path)}"
+        ) do |req|
+          req.headers['If-None-Match'] = etag if etag
+        end
+
+        return { content: nil, etag: nil, not_modified: true } if response.status == 304
+        return { content: response.body, etag: response.headers['etag'], not_modified: false } if response.success?
+
+        raise RegistryError, "Failed to fetch file '#{file_path}' from pack '#{pack_name}'"
+      rescue Faraday::Error => e
+        raise RegistryError, "Failed to fetch file '#{file_path}': #{e.message}"
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: base_url) do |f|
+          f.request :url_encoded
+          f.response :raise_error
+          f.options.timeout = TIMEOUT_SECONDS
+          f.options.open_timeout = TIMEOUT_SECONDS
+          f.headers['Accept'] = 'application/json'
+          f.headers['User-Accept'] = USER_ACCEPT_HEADER
+          f.headers['User-Agent'] = "rubyn-code/#{RubynCode::VERSION}"
+        end
+      end
+
+      # Perform a GET with optional ETag-based conditional caching.
+      # Sends If-None-Match when an ETag is provided; server returns
+      # 304 Not Modified if content hasn't changed.
+      def conditional_get(path, etag: nil, params: {})
+        connection.get(path) do |req|
+          req.params.merge!(params) unless params.empty?
+          req.headers['If-None-Match'] = etag if etag
+        end
+      end
+
+      def validate_and_parse(response)
+        body = response.body.to_s.strip
+        raise RegistryError, 'Empty response from registry' if body.empty?
+
+        content_type = response.headers['content-type'].to_s
+        if !content_type.include?('json') && body.start_with?('<')
+          raise RegistryError,
+                'Registry endpoint returned HTML instead of JSON ' \
+                "(content-type: #{content_type}). The skill packs API may not be available at #{base_url}."
+        end
+
+        JSON.parse(body, symbolize_names: true)
+      rescue JSON::ParserError => e
+        raise RegistryError, "Invalid response from registry: #{e.message}"
+      end
+
+      # Normalize response into an array of pack hashes.
+      # Handles both bare arrays and { packs: [...] } wrapper shapes.
+      def normalize_packs(data)
+        return data if data.is_a?(Array)
+        return data[:packs] if data.is_a?(Hash) && data[:packs].is_a?(Array)
+
+        raise RegistryError, 'Unexpected catalog format from registry'
+      end
+
+      def validate_pack_response!(data, name)
+        return if data.is_a?(Hash) && (data[:name] || data[:files])
+
+        raise RegistryError, "Invalid pack response for '#{name}': missing name or files"
+      end
+
+      # Only allow alphanumeric, hyphens, underscores, and forward slashes in pack names.
+      # Forward slashes are required for namespaced packs like 'stripe/webhooks'.
+      def validate_pack_name!(name)
+        return if name.to_s.match?(%r{\A[a-zA-Z0-9_\-/]+\z})
+
+        raise RegistryError,
+              "Invalid pack name: '#{name}'. Only letters, numbers, hyphens, underscores, and slashes allowed."
+      end
+
+      def encode_name(name)
+        ERB::Util.url_encode(name.to_s)
+      end
+
+      def fetch_key(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+
+      def matches_query?(pack, query)
+        pack_name = pack[:name].to_s.downcase
+        pack_display = pack[:displayName].to_s.downcase
+        pack_desc = pack[:description].to_s.downcase
+        pack_tags = pack[:tags] || []
+
+        pack_name.include?(query) ||
+          pack_display.include?(query) ||
+          pack_desc.include?(query) ||
+          pack_tags.any? { |t| t.to_s.downcase.include?(query) }
+      end
+
+      # Fetch markdown content for each file in the pack and transform
+      # into the format expected by PackManager: { filename, content }
+      def fetch_files_with_content(pack_name, files)
+        return files if files.empty?
+
+        files.map do |file|
+          path = fetch_key(file, :path)
+          result = fetch_file(pack_name, path)
+          { filename: path, content: result[:content] }
+        rescue RegistryError
+          # Skip files that fail to load
+          nil
+        end.compact
+      end
+
+      def not_modified_result
+        { data: nil, etag: nil, not_modified: true }
+      end
+    end
+
+    class RegistryError < RubynCode::Error; end
+  end
+end

data/lib/rubyn_code/tools/executor.rb

@@ -16,7 +16,8 @@ module RubynCode
         Registry.load_all!
       end
 
-      def execute(tool_name, params) # rubocop:disable Metrics/AbcSize -- maps tool errors to results
+      # -- maps tool errors to results
+      def execute(tool_name, params)
         # File cache intercept: serve cached reads, invalidate on writes
         cached = try_file_cache(tool_name, params)
         return cached if cached
@@ -73,7 +74,8 @@ module RubynCode
         allowed.empty? ? symbolized : symbolized.slice(*allowed)
       end
 
-      def inject_dependencies(tool, tool_name) # rubocop:disable Metrics/CyclomaticComplexity -- tool-specific dependency injection
+      # -- tool-specific dependency injection
+      def inject_dependencies(tool, tool_name)
         case tool_name
         when 'spawn_agent', 'spawn_teammate'
           inject_agent_deps(tool)

data/lib/rubyn_code/tools/grep.rb

@@ -23,7 +23,8 @@ module RubynCode
       def self.summarize(output, args)
         pattern = args['pattern'] || args[:pattern] || ''
         count = output.to_s.lines.count
-        count.zero? || output.to_s.start_with?('No matches') ? "grep #{pattern} (0 matches)" : "grep #{pattern} (#{count} lines)"
+        no_matches = count.zero? || output.to_s.start_with?('No matches')
+        no_matches ? "grep #{pattern} (0 matches)" : "grep #{pattern} (#{count} lines)"
       end
 
       def execute(pattern:, path: nil, glob_filter: nil, max_results: 50)

data/lib/rubyn_code/tools/ide_diagnostics.rb

@@ -6,7 +6,9 @@ module RubynCode
     # via the IDE RPC bridge. Only available when running in IDE mode.
     class IdeDiagnostics < Base
       TOOL_NAME = 'ide_diagnostics'
-      DESCRIPTION = 'Get VS Code diagnostics (errors, warnings) for a file or the whole workspace. Only available in IDE mode.'
+      DESCRIPTION =
+        'Get VS Code diagnostics (errors, warnings) for a file or the whole workspace. ' \
+        'Only available in IDE mode.'
       PARAMETERS = {
         file: {
           type: 'string',

data/lib/rubyn_code/tools/ide_symbols.rb

@@ -6,7 +6,9 @@ module RubynCode
     # Only available when running in IDE mode.
     class IdeSymbols < Base
       TOOL_NAME = 'ide_symbols'
-      DESCRIPTION = 'Search workspace symbols (classes, methods, modules) via VS Code language server. Only available in IDE mode.'
+      DESCRIPTION =
+        'Search workspace symbols (classes, methods, modules) via VS Code language server. ' \
+        'Only available in IDE mode.'
       PARAMETERS = {
         query: {
           type: 'string',

data/lib/rubyn_code/tools/load_skill.rb

@@ -36,7 +36,8 @@ module RubynCode
         skills_dirs = [
           File.expand_path('../../../skills', __dir__), # bundled gem skills
           File.join(project_root, '.rubyn-code', 'skills'), # project skills
-          File.join(Dir.home, '.rubyn-code', 'skills') # global user skills
+          File.join(Dir.home, '.rubyn-code', 'skills'), # global user skills
+          File.join(Dir.home, '.rubyn-code', 'skill-packs') # registry-installed packs
         ]
         catalog = Skills::Catalog.new(skills_dirs.select { |d| Dir.exist?(d) })
         Skills::Loader.new(catalog)

data/lib/rubyn_code/tools/output_compressor.rb

@@ -103,7 +103,7 @@ module RubynCode
         failures
       end
 
-      # rubocop:disable Metrics/AbcSize -- head/tail splitting requires coordinated arithmetic
+      # -- head/tail splitting requires coordinated arithmetic
       def head_tail(output, max_chars)
         lines = output.lines
         return output if lines.size <= 10
@@ -120,9 +120,8 @@ module RubynCode
         parts << tail_lines.join
         parts.join
       end
-      # rubocop:enable Metrics/AbcSize
 
-      # rubocop:disable Metrics/AbcSize -- diff hunk iteration with header extraction
+      # -- diff hunk iteration with header extraction
       def compress_diff(output, max_chars)
         hunks = output.split(/^(?=diff --git)/)
         return head_tail(output, max_chars) if hunks.size <= 1
@@ -140,7 +139,6 @@ module RubynCode
 
         result
       end
-      # rubocop:enable Metrics/AbcSize
 
       def top_matches(output, max_chars)
         lines = output.lines
@@ -152,7 +150,7 @@ module RubynCode
         result
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity -- multi-step tree collapse
+      # -- multi-step tree collapse
       def collapse_tree(output, max_chars)
         paths = output.lines.map(&:strip).reject(&:empty?)
         return output if output.length <= max_chars
@@ -164,7 +162,6 @@ module RubynCode
 
         head_tail(result, max_chars)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
       def take_lines_up_to(lines, max_chars)
         taken = []

data/lib/rubyn_code/tools/review_pr.rb

@@ -24,7 +24,7 @@ module RubynCode
       }.freeze
       RISK_LEVEL = :read
 
-      def execute(base_branch: 'main', focus: 'all')
+      def execute(base_branch: 'main', focus: 'all', pack_context: nil)
         error = validate_git_repo
         return error if error
 
@@ -37,7 +37,7 @@ module RubynCode
         diff = run_git("diff #{base_branch}...HEAD")
         return "No changes found between #{current} and #{base_branch}." if diff.strip.empty?
 
-        build_full_review(current, base_branch, diff, focus)
+        build_full_review(current, base_branch, diff, focus, pack_context: pack_context)
       end
 
       FILE_CATEGORIES = [
@@ -80,8 +80,9 @@ module RubynCode
         [nil, "Error: Base branch '#{base_branch}' not found."]
       end
 
-      def build_full_review(current, base_branch, diff, focus)
-        review = build_review_header(current, base_branch)
+      def build_full_review(current, base_branch, diff, focus, pack_context: nil)
+        review = build_pack_context_section(pack_context)
+        review.concat(build_review_header(current, base_branch))
         review.concat(build_file_categories(base_branch))
         review.concat(build_focus_section(focus))
         review.concat(build_diff_section(diff))
@@ -158,6 +159,16 @@ module RubynCode
         ]
       end
 
+      def build_pack_context_section(pack_context)
+        return [] if pack_context.nil? || pack_context.strip.empty?
+
+        [
+          '## Skill Pack Context',
+          pack_context.strip,
+          ''
+        ]
+      end
+
       def run_git(command)
         `cd #{project_root} && git #{command} 2>/dev/null`
       end

data/lib/rubyn_code/tools/web_search.rb

@@ -85,7 +85,8 @@ module RubynCode
         html.scan(%r{<a[^>]+href="(https?://(?!lite\.duckduckgo)[^"]+)"[^>]*>(.*?)</a>}i)
       end
 
-      def build_ddg_results(links, snippets, max) # rubocop:disable Metrics/AbcSize -- HTML parsing with filtering
+      # -- HTML parsing with filtering
+      def build_ddg_results(links, snippets, max)
         results = []
         links.each_with_index do |match, idx|
           break if results.length >= max

data/lib/rubyn_code/version.rb

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

data/lib/rubyn_code.rb

@@ -137,7 +137,16 @@ module RubynCode
     autoload :Loader, 'rubyn_code/skills/loader'
     autoload :Catalog, 'rubyn_code/skills/catalog'
     autoload :Document, 'rubyn_code/skills/document'
+    autoload :Matcher, 'rubyn_code/skills/matcher'
+    autoload :RegistryAutoload, 'rubyn_code/skills/registry_autoload'
     autoload :TtlManager, 'rubyn_code/skills/ttl_manager'
+    autoload :RegistryClient, 'rubyn_code/skills/registry_client'
+    autoload :PackManager, 'rubyn_code/skills/pack_manager'
+    autoload :PackInstaller, 'rubyn_code/skills/pack_installer'
+    autoload :PackContext, 'rubyn_code/skills/pack_context'
+    autoload :GemfileParser, 'rubyn_code/skills/gemfile_parser'
+    autoload :AutoSuggest, 'rubyn_code/skills/auto_suggest'
+    autoload :RegistryError, 'rubyn_code/skills/registry_client'
   end
 
   # Layer 6: Sub-Agents
@@ -284,6 +293,9 @@ module RubynCode
       autoload :Model, 'rubyn_code/cli/commands/model'
       autoload :NewSession, 'rubyn_code/cli/commands/new_session'
       autoload :Provider, 'rubyn_code/cli/commands/provider'
+      autoload :InstallSkills, 'rubyn_code/cli/commands/install_skills'
+      autoload :RemoveSkills, 'rubyn_code/cli/commands/remove_skills'
+      autoload :Skills, 'rubyn_code/cli/commands/skills'
     end
   end
 

data/skills/rubyn_self_test.md

@@ -115,6 +115,81 @@ Score: 18/22 (82%) — 4 failures
 - **glob**: Check that all 16 layer directories exist under `lib/rubyn_code/`. PASS if at least 14 found.
 - **read_file**: Read `lib/rubyn_code.rb` and verify it has modules for Agent, Tools, Context, Skills, Memory, Observability, Learning. PASS if all 7 found.
 
+### 15. Skill-Pack Autoload — Live Registry Roundtrip
+
+End-to-end exercise of the autoload pipeline against the real registry at `rubyn.ai`: fetch the catalog, install a pack the user does **not** already have, verify it works on disk + in the catalog + through the matcher, then remove it. The user's pre-existing installed packs are not touched.
+
+- **Live roundtrip**: `bash` with the script below. PASS if the final line is `ROUNDTRIP: PASS`. SKIP if the final line starts with `SKIP:` (means every registry pack is already installed locally — rare).
+
+  ```bash
+  bundle exec ruby -e '
+    require_relative "lib/rubyn_code"
+
+    client = RubynCode::Skills::RegistryClient.new
+    pack_manager = RubynCode::Skills::PackManager.new
+
+    catalog_packs = client.fetch_catalog[:data] || []
+    abort "FAIL: empty registry catalog" if catalog_packs.empty?
+
+    already_installed = catalog_packs.map { |p| p[:name] || p["name"] }
+                                     .select { |n| pack_manager.installed?(n) }
+    target = catalog_packs.find { |p| !already_installed.include?(p[:name] || p["name"]) }
+    abort "SKIP: every registry pack is already installed" if target.nil?
+
+    name = target[:name] || target["name"]
+    puts "TEST PACK: #{name}"
+
+    success = false
+    begin
+      result = client.fetch_pack(name)
+      pack_manager.install(result[:data], etag: result[:etag])
+      raise "install did not create directory" unless pack_manager.installed?(name)
+      puts "STEP install: PASS"
+
+      catalog_obj = RubynCode::Skills::Catalog.new(
+        File.join(Dir.home, ".rubyn-code", "skill-packs")
+      )
+      skills = catalog_obj.available.select { |e| e[:path].include?("/#{name}/") }
+      raise "catalog sees no skills" if skills.empty?
+      raise "no skills have triggers" if skills.none? { |s| !s[:triggers].empty? }
+      puts "STEP catalog: PASS (#{skills.size} skills, #{skills.count { |s| !s[:triggers].empty? }} with triggers)"
+
+      sample = skills.find { |s| !s[:triggers].empty? }
+      matcher = RubynCode::Skills::Matcher.new(catalog: catalog_obj)
+      hits = matcher.match("question about #{sample[:triggers].first}")
+      raise "matcher did not hit on \"#{sample[:triggers].first}\"" if hits.none? { |h| h[:name] == sample[:name] }
+      puts "STEP matcher: PASS (hit \"#{sample[:name]}\" via \"#{sample[:triggers].first}\")"
+      success = true
+    ensure
+      pack_manager.remove(name)
+      if pack_manager.installed?(name)
+        puts "STEP cleanup: FAIL (pack still on disk)"
+      else
+        puts "STEP cleanup: PASS"
+      end
+    end
+
+    puts(success ? "ROUNDTRIP: PASS" : "ROUNDTRIP: FAIL")
+  '
+  ```
+
+  The script:
+  1. Fetches the registry catalog (proves the static API at `rubyn.ai/api/v1/skills/packs.json` is reachable).
+  2. Picks the first pack the user does **not** have installed, so we never touch their existing packs.
+  3. Installs the pack via `RegistryClient#fetch_pack` + `PackManager#install` — exactly the path the autoload pipeline uses.
+  4. Reads the disk back through a fresh `Skills::Catalog` and confirms the new skills are visible with parsed triggers.
+  5. Runs `Skills::Matcher#match` against a real trigger from one of the freshly-installed skills, confirming the matcher would have fired in a real session.
+  6. Removes the pack in an `ensure` block so a partial failure still leaves the user's system clean.
+
+  PASS criteria: `STEP install`, `STEP catalog`, `STEP matcher`, and `STEP cleanup` all `PASS`, with a final `ROUNDTRIP: PASS`.
+
+- **Live autoload notification (manual verification, not scored)**: This isn't a tool call — it's a hint to surface in the scorecard for the user. Tell them: after the self-test completes, send a follow-up prompt that includes a trigger word from any pack in the registry (e.g. `"explain turbo drive"`). The Rubyn renderer should print:
+  ```
+  📥 Fetching skill pack 'hotwire' from registry…
+  📚 Loaded: turbo-drive
+  ```
+  before the next response (the `📥` line appears only if the pack wasn't already installed). Do **not** count this as PASS/FAIL — just mention it in the scorecard so the user can verify the renderer side themselves.
+
 ## Scoring
 
 Count total PASS results out of total tests run. Report the percentage.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubyn-code
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - fadedmaturity
@@ -226,6 +226,8 @@ files:
 - lib/rubyn_code/cli/commands/diff.rb
 - lib/rubyn_code/cli/commands/doctor.rb
 - lib/rubyn_code/cli/commands/help.rb
+- lib/rubyn_code/cli/commands/install_skills.rb
+- lib/rubyn_code/cli/commands/list_skills.rb
 - lib/rubyn_code/cli/commands/mcp.rb
 - lib/rubyn_code/cli/commands/model.rb
 - lib/rubyn_code/cli/commands/new_session.rb
@@ -233,9 +235,11 @@ files:
 - lib/rubyn_code/cli/commands/provider.rb
 - lib/rubyn_code/cli/commands/quit.rb
 - lib/rubyn_code/cli/commands/registry.rb
+- lib/rubyn_code/cli/commands/remove_skills.rb
 - lib/rubyn_code/cli/commands/resume.rb
 - lib/rubyn_code/cli/commands/review.rb
 - lib/rubyn_code/cli/commands/skill.rb
+- lib/rubyn_code/cli/commands/skills.rb
 - lib/rubyn_code/cli/commands/spawn.rb
 - lib/rubyn_code/cli/commands/tasks.rb
 - lib/rubyn_code/cli/commands/tokens.rb
@@ -353,9 +357,17 @@ files:
 - lib/rubyn_code/protocols/shutdown_handshake.rb
 - lib/rubyn_code/self_test.rb
 - lib/rubyn_code/skills/RUBYN.md
+- lib/rubyn_code/skills/auto_suggest.rb
 - lib/rubyn_code/skills/catalog.rb
 - lib/rubyn_code/skills/document.rb
+- lib/rubyn_code/skills/gemfile_parser.rb
 - lib/rubyn_code/skills/loader.rb
+- lib/rubyn_code/skills/matcher.rb
+- lib/rubyn_code/skills/pack_context.rb
+- lib/rubyn_code/skills/pack_installer.rb
+- lib/rubyn_code/skills/pack_manager.rb
+- lib/rubyn_code/skills/registry_autoload.rb
+- lib/rubyn_code/skills/registry_client.rb
 - lib/rubyn_code/skills/ttl_manager.rb
 - lib/rubyn_code/sub_agents/RUBYN.md
 - lib/rubyn_code/sub_agents/runner.rb