pwn 0.5.684 → 0.5.686

data/lib/pwn/ai/anthropic.rb

@@ -490,122 +490,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Anthropic.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Admin Usage API (organizations/usage_report/messages) yields tokens
-      # used; organizations/rate_limits yields the configured ceiling so the
-      # PS1 can show a percent. Individual accounts without an Admin key
-      # return {available:false}. Never prompts for credentials.
-      public_class_method def self.get_plan_usage(opts = {})
-        timeout = opts[:timeout] || 8
-        return { available: false, engine: :anthropic } unless plan_usage_credentials?
-
-        now = Time.now.utc
-        start_of_month = Time.utc(now.year, now.month, 1)
-        report = parse_plan_usage_json(
-          raw: anthropic_rest_call(
-            rest_call: 'organizations/usage_report/messages',
-            params: {
-              starting_at: start_of_month.strftime('%Y-%m-%dT00:00:00Z'),
-              ending_at: now.strftime('%Y-%m-%dT%H:%M:%SZ'),
-              bucket_width: '1d'
-            },
-            timeout: timeout,
-            spinner: false,
-            non_interactive: true
-          )
-        )
-        used_tokens = sum_usage_tokens(report: report)
-
-        limits = parse_plan_usage_json(
-          raw: anthropic_rest_call(
-            rest_call: 'organizations/rate_limits',
-            timeout: timeout,
-            spinner: false,
-            non_interactive: true
-          )
-        )
-        limit_tokens = first_rate_limit(limits: limits)
-
-        normalized = PWN::AI.normalize_plan_usage(
-          used: used_tokens,
-          limit: limit_tokens,
-          source: 'organizations/usage_report',
-          engine: :anthropic
-        )
-        return normalized if normalized[:available]
-
-        { available: false, engine: :anthropic }
-      rescue StandardError
-        { available: false, engine: :anthropic }
-      end
-
-      private_class_method def self.plan_usage_credentials?
-        engine = PWN::Env.dig(:ai, :anthropic) || {}
-        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
-        real_config_value?(value: engine[:key]) ||
-          real_config_value?(value: oauth[:bearer_token]) ||
-          real_config_value?(value: oauth[:refresh_token])
-      end
-
-      private_class_method def self.parse_plan_usage_json(opts = {})
-        raw = opts[:raw]
-        return nil if raw.nil?
-
-        parsed = JSON.parse(raw.to_s, symbolize_names: true)
-        parsed.is_a?(Hash) ? parsed : nil
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-
-      private_class_method def self.sum_usage_tokens(opts = {})
-        report = opts[:report]
-        return nil unless report.is_a?(Hash)
-
-        buckets = report[:data] || report[:usage] || []
-        total = 0
-        Array(buckets).each do |bucket|
-          next unless bucket.is_a?(Hash)
-
-          results = bucket[:results] || bucket[:usage] || [bucket]
-          Array(results).each do |row|
-            next unless row.is_a?(Hash)
-
-            %i[
-              uncached_input_tokens
-              input_tokens
-              cache_read_input_tokens
-              cache_creation_input_tokens
-              output_tokens
-            ].each { |k| total += row[k].to_i }
-          end
-        end
-        total.positive? ? total : nil
-      end
-
-      private_class_method def self.first_rate_limit(opts = {})
-        limits = opts[:limits]
-        return nil unless limits.is_a?(Hash)
-
-        Array(limits[:data]).each do |group|
-          next unless group.is_a?(Hash)
-
-          Array(group[:limits]).each do |lim|
-            next unless lim.is_a?(Hash)
-
-            type = lim[:type].to_s
-            next unless type.match?(/tokens_per|input_tokens|output_tokens/)
-
-            v = lim[:value].to_f
-            return v if v.positive?
-          end
-        end
-        nil
-      end
-
       # ----------------------------------------------------------------------
       # Native tool-calling adapter for PWN::AI::Agent::Loop.
       #
@@ -960,8 +844,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           # One-time Claude Pro/Max OAuth enrollment (PKCE paste flow):
           bearer = #{self}.obtain_oauth_bearer_token
           # Subsequent runs silently refresh via ai.anthropic.oauth.refresh_token

data/lib/pwn/ai/gemini.rb

@@ -114,19 +114,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Gemini.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Gemini Generative Language has no subscription-usage endpoint that
-      # returns used-vs-limit for an API key. Cached-miss / unavailable so
-      # the PS1 shows ∞ unless the operator later injects used/limit.
-      public_class_method def self.get_plan_usage(opts = {})
-        _timeout = opts[:timeout] || 8
-        { available: false, engine: :gemini }
-      end
-
       # ----------------------------------------------------------------------
       # Native tool-calling adapter for PWN::AI::Agent::Loop.
       #
@@ -449,8 +436,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Gemini',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:gemini][:model])',

data/lib/pwn/ai/grok.rb

@@ -505,162 +505,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Grok.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Subscription / team usage for the PS1 percent suffix.
-      # GET /v1/api-key yields team_id; then billing preview /
-      # spending-limits / prepaid balance compute used vs limit.
-      # GET /v1/me is also tried (OAuth personal-team payload).
-      public_class_method def self.get_plan_usage(opts = {})
-        timeout = opts[:timeout] || 8
-        return { available: false, engine: :grok } unless plan_usage_credentials?
-
-        me = parse_plan_usage_json(
-          raw: grok_rest_call(rest_call: 'me', timeout: timeout, spinner: false, quiet: true, non_interactive: true)
-        )
-        if me.is_a?(Hash)
-          used = first_numeric(src: me, keys: %i[used usage spend spent used_usd usage_usd])
-          limit = first_numeric(src: me, keys: %i[limit quota allowance hard_limit spending_limit])
-          normalized = PWN::AI.normalize_plan_usage(
-            used: used,
-            limit: limit,
-            source: 'me',
-            engine: :grok
-          )
-          return normalized if normalized[:available]
-        end
-
-        key_info = parse_plan_usage_json(
-          raw: grok_rest_call(rest_call: 'api-key', timeout: timeout, spinner: false, quiet: true, non_interactive: true)
-        )
-        team_id = key_info.is_a?(Hash) ? key_info[:team_id] : nil
-        team_id ||= me.is_a?(Hash) ? (me[:team_id] || me.dig(:team, :id)) : nil
-
-        if team_id.to_s.strip != ''
-          preview = parse_plan_usage_json(
-            raw: grok_rest_call(
-              rest_call: "billing/teams/#{team_id}/postpaid/invoice/preview",
-              timeout: timeout,
-              spinner: false,
-              quiet: true,
-              non_interactive: true
-            )
-          )
-          limits = parse_plan_usage_json(
-            raw: grok_rest_call(
-              rest_call: "billing/teams/#{team_id}/postpaid/spending-limits",
-              timeout: timeout,
-              spinner: false,
-              quiet: true,
-              non_interactive: true
-            )
-          )
-          balance = parse_plan_usage_json(
-            raw: grok_rest_call(
-              rest_call: "billing/teams/#{team_id}/prepaid/balance",
-              timeout: timeout,
-              spinner: false,
-              quiet: true,
-              non_interactive: true
-            )
-          )
-
-          used = nil
-          limit = nil
-          if preview.is_a?(Hash)
-            core = preview[:coreInvoice] || preview[:core_invoice] || {}
-            used_cents = cents_val(src: core, key: :prepaidCreditsUsed) ||
-                         cents_val(src: core, key: :prepaid_credits_used) ||
-                         core[:amountAfterVat] ||
-                         core[:amount_after_vat]
-            prepaid_cents = cents_val(src: core, key: :prepaidCredits) ||
-                            cents_val(src: core, key: :prepaid_credits)
-            spend_limit_cents = preview[:effectiveSpendingLimit] || preview[:effective_spending_limit]
-            used = to_f_or_nil(value: used_cents)
-            limit = to_f_or_nil(value: spend_limit_cents)
-            limit = to_f_or_nil(value: prepaid_cents).abs if (limit.nil? || limit <= 0) && prepaid_cents
-          end
-          used = to_f_or_nil(value: cents_val(src: balance, key: :total)).to_f.abs if (used.nil? || used <= 0) && balance.is_a?(Hash)
-          if (limit.nil? || limit <= 0) && limits.is_a?(Hash)
-            sl = limits[:spendingLimits] || limits[:spending_limits] || {}
-            limit = to_f_or_nil(value: cents_val(src: sl, key: :effectiveSl)) ||
-                    to_f_or_nil(value: cents_val(src: sl, key: :effectiveHardSl)) ||
-                    to_f_or_nil(value: cents_val(src: sl, key: :softSl))
-          end
-
-          normalized = PWN::AI.normalize_plan_usage(
-            used: used,
-            limit: limit,
-            source: 'billing/teams',
-            engine: :grok
-          )
-          return normalized if normalized[:available]
-        end
-
-        { available: false, engine: :grok }
-      rescue StandardError
-        { available: false, engine: :grok }
-      end
-
-      private_class_method def self.plan_usage_credentials?
-        engine = PWN::Env.dig(:ai, :grok) || {}
-        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
-        real_config_value?(value: engine[:key]) ||
-          real_config_value?(value: oauth[:bearer_token]) ||
-          real_config_value?(value: oauth[:refresh_token])
-      end
-
-      private_class_method def self.parse_plan_usage_json(opts = {})
-        raw = opts[:raw]
-        return nil if raw.nil?
-
-        parsed = JSON.parse(raw.to_s, symbolize_names: true)
-        parsed.is_a?(Hash) ? parsed : nil
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-
-      private_class_method def self.cents_val(opts = {})
-        src = opts[:src]
-        key = opts[:key]
-        return nil unless src.is_a?(Hash)
-
-        v = src[key]
-        return v[:val] if v.is_a?(Hash) && v.key?(:val)
-        return v['val'] if v.is_a?(Hash) && v.key?('val')
-
-        v
-      end
-
-      private_class_method def self.to_f_or_nil(opts = {})
-        val = opts.is_a?(Hash) && opts.key?(:value) ? opts[:value] : opts
-        return nil if val.nil?
-        return val.to_f if val.respond_to?(:to_f)
-
-        nil
-      rescue StandardError
-        nil
-      end
-
-      private_class_method def self.first_numeric(opts = {})
-        src = opts[:src]
-        keys = Array(opts[:keys])
-        return nil unless src.is_a?(Hash)
-
-        keys.each do |k|
-          v = src[k]
-          next if v.nil?
-          next if v.is_a?(Hash)
-
-          f = v.to_f
-          return f if f.positive? || v.to_s.strip.match?(/\A-?\d/)
-        end
-        nil
-      end
-
       # Supported Method Parameters::
       # response = PWN::AI::Grok.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -845,8 +689,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Grok',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:grok][:model])',

data/lib/pwn/ai/ollama.rb

@@ -370,16 +370,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Ollama.get_plan_usage
-      #
-      # Local Ollama has no subscription / plan-usage endpoint. Always
-      # unavailable so the PS1 shows the infinity glyph.
-      public_class_method def self.get_plan_usage(opts = {})
-        _unused = opts
-        { available: false, engine: :ollama, unlimited: true }
-      end
-
       # Coerce OpenAI-wire message history into Ollama-native shapes before
       # POST /api/chat (or Open WebUI /ollama/api/chat):
       # - function.arguments must be a Hash/Array object, not a JSON string
@@ -652,8 +642,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Ollama',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:ollama][:model])',

data/lib/pwn/ai/open_ai.rb

@@ -544,114 +544,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::OpenAI.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Subscription / billing usage for the PS1 percent suffix.
-      # Tries (1) dashboard billing hard-limit vs month-to-date spend,
-      # then (2) Admin organization costs. Returns {available:false}
-      # when neither yields used+limit (never prompts for credentials).
-      public_class_method def self.get_plan_usage(opts = {})
-        timeout = opts[:timeout] || 8
-        return { available: false, engine: :openai } unless plan_usage_credentials?
-
-        now = Time.now.utc
-        start_of_month = Time.utc(now.year, now.month, 1)
-
-        sub = parse_plan_usage_json(
-          raw: open_ai_rest_call(
-            rest_call: 'dashboard/billing/subscription',
-            timeout: timeout,
-            spinner: false,
-            quiet: true,
-            non_interactive: true
-          )
-        )
-        usage = parse_plan_usage_json(
-          raw: open_ai_rest_call(
-            rest_call: 'dashboard/billing/usage',
-            params: {
-              start_date: start_of_month.strftime('%Y-%m-%d'),
-              end_date: now.strftime('%Y-%m-%d')
-            },
-            timeout: timeout,
-            spinner: false,
-            quiet: true,
-            non_interactive: true
-          )
-        )
-
-        if sub.is_a?(Hash) && usage.is_a?(Hash)
-          limit_usd = (
-            sub[:hard_limit_usd] ||
-            sub[:system_hard_limit_usd] ||
-            sub[:soft_limit_usd] ||
-            sub[:system_soft_limit_usd]
-          ).to_f
-          used_usd = usage[:total_usage].to_f / 100.0
-          normalized = PWN::AI.normalize_plan_usage(
-            used: used_usd,
-            limit: limit_usd,
-            source: 'dashboard/billing',
-            engine: :openai
-          )
-          return normalized if normalized[:available]
-        end
-
-        costs = parse_plan_usage_json(
-          raw: open_ai_rest_call(
-            rest_call: 'organization/costs',
-            params: { start_time: start_of_month.to_i },
-            timeout: timeout,
-            spinner: false,
-            quiet: true,
-            non_interactive: true
-          )
-        )
-        if costs.is_a?(Hash)
-          spent = Array(costs[:data]).sum do |row|
-            amt = row.is_a?(Hash) ? (row[:amount] || row[:results] || {}) : {}
-            if amt.is_a?(Hash)
-              (amt[:value] || amt[:amount] || 0).to_f
-            else
-              amt.to_f
-            end
-          end
-          limit_usd = sub.is_a?(Hash) ? (sub[:hard_limit_usd] || sub[:system_hard_limit_usd]).to_f : 0.0
-          normalized = PWN::AI.normalize_plan_usage(
-            used: spent,
-            limit: limit_usd,
-            source: 'organization/costs',
-            engine: :openai
-          )
-          return normalized if normalized[:available]
-        end
-
-        { available: false, engine: :openai }
-      rescue StandardError
-        { available: false, engine: :openai }
-      end
-
-      private_class_method def self.plan_usage_credentials?
-        engine = PWN::Env.dig(:ai, :openai) || {}
-        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
-        real_config_value?(value: engine[:key]) ||
-          real_config_value?(value: oauth[:bearer_token]) ||
-          real_config_value?(value: oauth[:refresh_token])
-      end
-
-      private_class_method def self.parse_plan_usage_json(opts = {})
-        raw = opts[:raw]
-        return nil if raw.nil?
-
-        parsed = JSON.parse(raw.to_s, symbolize_names: true)
-        parsed.is_a?(Hash) ? parsed : nil
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-
       # Supported Method Parameters::
       # response = PWN::AI::OpenAI.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -1287,8 +1179,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           # One-time ChatGPT/Codex OAuth enrollment (device-code flow):
           bearer = #{self}.obtain_oauth_bearer_token
           # Subsequent runs silently refresh via ai.openai.oauth.refresh_token

data/lib/pwn/ai/open_web_ui.rb

@@ -413,16 +413,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::OpenWebUI.get_plan_usage
-      #
-      # Open WebUI is a local gateway with no subscription / plan-usage
-      # endpoint. Always unavailable so the PS1 shows the infinity glyph.
-      public_class_method def self.get_plan_usage(opts = {})
-        _unused = opts
-        { available: false, engine: :openwebui, unlimited: true }
-      end
-
       # Coerce OpenAI-wire message history into Ollama-native shapes before
       # POST /api/chat (or Open WebUI /ollama/api/chat):
       # - function.arguments must be a Hash/Array object, not a JSON string
@@ -693,8 +683,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Open WebUI',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:openwebui][:model])',

data/lib/pwn/ai.rb

@@ -14,92 +14,6 @@ module PWN
     autoload :OpenWebUI, 'pwn/ai/open_web_ui'
     autoload :RedTeam, 'pwn/ai/red_team'
 
-    PLAN_USAGE_CACHE_TTL = 60
-    PLAN_USAGE_INFINITY = "\u221E"
-    ENGINE_MODULES = {
-      openai: 'PWN::AI::OpenAI',
-      grok: 'PWN::AI::Grok',
-      ollama: 'PWN::AI::Ollama',
-      openwebui: 'PWN::AI::OpenWebUI',
-      anthropic: 'PWN::AI::Anthropic',
-      gemini: 'PWN::AI::Gemini'
-    }.freeze
-
-    # Supported Method Parameters::
-    # usage = PWN::AI.normalize_plan_usage(
-    #   used: 'required - numeric used amount',
-    #   limit: 'required - numeric limit / allowance',
-    #   source: 'optional - endpoint / origin label',
-    #   engine: 'optional - engine symbol'
-    # )
-    public_class_method def self.normalize_plan_usage(opts = {})
-      used = opts[:used]
-      limit = opts[:limit]
-      used_f = used&.to_f
-      limit_f = limit&.to_f
-      available = !used_f.nil? && !limit_f.nil? && limit_f.positive?
-      percent = available ? ((used_f / limit_f) * 100.0).round : nil
-      percent = 0 if percent && percent.negative?
-      percent = 100 if percent && percent > 100
-      {
-        available: available,
-        used: used_f,
-        limit: limit_f,
-        percent: percent,
-        source: opts[:source],
-        engine: opts[:engine]
-      }
-    end
-
-    # Supported Method Parameters::
-    # usage = PWN::AI.plan_usage(
-    #   engine: 'optional - engine symbol (defaults to PWN::Env[:ai][:active])',
-    #   ttl: 'optional - cache seconds (default 60)',
-    #   force: 'optional - bypass cache (default false)'
-    # )
-    public_class_method def self.plan_usage(opts = {})
-      engine = (opts[:engine] || PWN::Env.dig(:ai, :active)).to_s.downcase.to_sym
-      ttl = (opts[:ttl] || PLAN_USAGE_CACHE_TTL).to_i
-      ttl = PLAN_USAGE_CACHE_TTL if ttl <= 0
-      cache = (@plan_usage_cache ||= {})
-      now = Time.now.to_i
-      hit = cache[engine]
-      return hit[:value] if !opts[:force] && hit.is_a?(Hash) && (now - hit[:at].to_i) < ttl
-
-      klass_name = ENGINE_MODULES[engine]
-      value = { available: false, engine: engine }
-      if klass_name
-        begin
-          klass = Object.const_get(klass_name)
-          value = klass.get_plan_usage if klass.respond_to?(:get_plan_usage)
-          value = { available: false, engine: engine } unless value.is_a?(Hash)
-          value[:engine] ||= engine
-        rescue StandardError
-          value = { available: false, engine: engine }
-        end
-      end
-      cache[engine] = { at: now, value: value }
-      value
-    end
-
-    # Supported Method Parameters::
-    # glyph = PWN::AI.plan_usage_glyph(
-    #   engine: 'optional - engine symbol (defaults to PWN::Env[:ai][:active])',
-    #   usage: 'optional - precomputed usage hash'
-    # )
-    #
-    # Returns "19%" when used/limit are known, otherwise the infinity glyph.
-    # Local engines (ollama / openwebui) always return infinity.
-    public_class_method def self.plan_usage_glyph(opts = {})
-      engine = (opts[:engine] || PWN::Env.dig(:ai, :active)).to_s.downcase.to_sym
-      return PLAN_USAGE_INFINITY if %i[ollama openwebui].include?(engine)
-
-      usage = opts[:usage] || plan_usage(engine: engine)
-      return PLAN_USAGE_INFINITY unless usage.is_a?(Hash) && usage[:available] && !usage[:percent].nil?
-
-      "#{usage[:percent].to_i}%"
-    end
-
     # Display a List of Every PWN::AI Module
 
     # Author(s):: 0day Inc. <support@0dayinc.com>

data/lib/pwn/config.rb

@@ -309,6 +309,7 @@ module PWN
 
       Pry.config.refresh_pwn_env = false if defined?(Pry)
       env[:pwn_skills_path] = pwn_skills_path
+      PWN::Config.install_default_skills(pwn_skills_path: pwn_skills_path)
       PWN::Config.load_skills(pwn_skills_path: pwn_skills_path)
 
       # pwn-ai agent: memory/sessions/cron paths
@@ -559,7 +560,10 @@ module PWN
 
       # Make pwn-ai aware of the skills folder in pwn_env parent (before freeze)
       env[:pwn_skills_path] = pwn_skills_path if defined?(pwn_skills_path)
-      PWN::Config.load_skills(pwn_skills_path: pwn_skills_path) if defined?(pwn_skills_path)
+      if defined?(pwn_skills_path)
+        PWN::Config.install_default_skills(pwn_skills_path: pwn_skills_path)
+        PWN::Config.load_skills(pwn_skills_path: pwn_skills_path)
+      end
 
       # pwn-ai agent: memory, sessions, cron paths (before freeze)
       env[:pwn_memory_path] = PWN::Memory::MEMORY_FILE if defined?(PWN::Memory)
@@ -802,6 +806,60 @@ module PWN
       { migrated: migrated.length, details: migrated }
     end
 
+    DEFAULT_SKILLS_DIR = File.expand_path('../../etc/default_skills', __dir__)
+    DEFAULT_SKILL_NAMES = %w[
+      vulnerability-research-fundamentals
+      deep-exploitation
+      bug-bounty-hunting
+      sast-code-scans
+      reverse-engineering-binaries
+      penetration-testing
+      web-application-penetration-testing
+      red-teaming
+      hardware-and-firmware-testing
+      social-engineering
+      osint
+    ].freeze
+
+    public_class_method def self.default_skill_names(opts = {})
+      return DEFAULT_SKILL_NAMES.dup if opts.is_a?(Hash)
+
+      DEFAULT_SKILL_NAMES.dup
+    end
+
+    public_class_method def self.default_skills_dir(opts = {})
+      return DEFAULT_SKILLS_DIR if opts.is_a?(Hash)
+
+      DEFAULT_SKILLS_DIR
+    end
+
+    # Seed bundled skills into ~/.pwn/skills (or pwn_skills_path:).
+    # Missing names are copied from etc/default_skills. Existing SKILL.md
+    # files are left alone so operator edits survive upgrades.
+    public_class_method def self.install_default_skills(opts = {})
+      root = opts[:pwn_skills_path] || pwn_skills_path
+      src_root = opts[:source] || default_skills_dir
+      return [] if root.to_s.empty? || !Dir.exist?(src_root.to_s)
+
+      FileUtils.mkdir_p(root)
+      seeded = []
+      default_skill_names.each do |name|
+        dest = File.join(root, name, SKILL_ENTRY)
+        next if File.file?(dest)
+
+        src = File.join(src_root, name, SKILL_ENTRY)
+        next unless File.file?(src)
+
+        FileUtils.mkdir_p(File.dirname(dest))
+        FileUtils.cp(src, dest)
+        seeded << { name: name, path: dest }
+      end
+      seeded
+    rescue StandardError => e
+      warn "[PWN::Config] install_default_skills failed: #{e.class}: #{e.message}"
+      []
+    end
+
     # Supported Method Parameters::
     # skills = PWN::Config.load_skills(
     #   pwn_skills_path: 'optional - Path to skills folder.  Defaults to ~/.pwn/skills'
@@ -955,6 +1013,9 @@ module PWN
 
         #{self}.migrate_legacy_skills(pwn_skills_path: 'optional', delete_legacy: true)
 
+        #{self}.install_default_skills(pwn_skills_path: 'optional')
+        #{self}.default_skill_names
+
         #{self}.refresh_env(
           pwn_env_path: 'optional - Path to pwn.yaml file.  Defaults to ~/.pwn/pwn.yaml',
         pwn_dec_path: 'optional - Path to pwn.yaml.decryptor file.  Defaults to ~/.pwn/pwn.yaml.decryptor'