pwn 0.5.686 → 0.5.688

data/lib/pwn/ai/agent/prompt_builder.rb

@@ -93,9 +93,18 @@ module PWN
               Prefer this order: use RECENT TURNS (current session already in
               context), then `memory_recall`, then `session_recall`, then
               `skills_recall`, then `pwn_eval` for PWN:: work, then `shell` for OS
-              commands. Save durable facts with `memory_remember`.
+              commands. Save durable facts with `memory_remember`. After a
+              resolved mistake or a durable procedure change, `skills_update`
+              folds that RL note into the matching skill.
               TransparentBrowser: open once, reuse browser_obj, close once.
 
+            HOST LOAD
+              #{host_load_block}
+              On pwn_eval/shell timeout: reconstruct the ruby/command for the
+              same goal first. Do not first raise timeout. Only if construction
+              is sound, raise a conservative HOST LOAD timeout (clamped).
+              Record a mistake either way.
+
             AUTONOMY
               Multi-step goals must be finished in one Loop.run. Keep calling
               CORE_TOOLS until the original request is done or truly blocked.
@@ -120,6 +129,9 @@ module PWN
               World-knowledge questions (what color is X) may be answered as a
               text final with no tools. Tools stay available; do not invent a
               host-work plan for them.
+              Which skills are installed: call `skills_recall` with no query
+              (bundled catalog). Do not recite a mixed on-disk dump as the
+              catalog. Extra files under ~/.pwn/skills are not the catalog.
               Do not treat process_sop_* or operator_pref_* memory about code
               hygiene as the current user goal unless they asked to change code.
           PROMPT
@@ -165,6 +177,21 @@ module PWN
           RUBY_PLATFORM
         end
 
+        private_class_method def self.host_load_block
+          snap = if defined?(ToolGuard) && ToolGuard.respond_to?(:host_load)
+                   ToolGuard.host_load
+                 else
+                   { ncpu: 1, load1: 0.0, mem_avail_mb: 0 }
+                 end
+          eval_s = ToolGuard.deadline_s(kind: :eval) if defined?(ToolGuard)
+          shell_s = ToolGuard.deadline_s(kind: :shell) if defined?(ToolGuard)
+          load_line = "load1=#{snap[:load1]} ncpu=#{snap[:ncpu]} mem_avail_mb=#{snap[:mem_avail_mb]}"
+          "#{load_line} pwn_eval/shell timeout = conservative seconds for this host " \
+            "(defaults eval=#{eval_s || 20}s shell=#{shell_s || 30}s, clamped)."
+        rescue StandardError
+          'load unknown — pass a conservative timeout on pwn_eval/shell anyway.'
+        end
+
         private_class_method def self.pwn_version
           defined?(PWN::VERSION) ? PWN::VERSION : '?'
         end
@@ -178,25 +205,7 @@ module PWN
           sid = opts[:session_id]
           pairs = (opts[:limit] || 2).to_i
           pairs = 1 if pairs <= 0
-          # On pure-recall / vague cues, prefer a slightly richer window if budget allows.
-          req = opts[:request].to_s
-          if req.match?(
-            /
-              \b(
-                what\s+did\s+i\s+(just\s+)?say|
-                what\s+was\s+my\s+last|
-                how\s+did\s+you\s+respond|
-                what\s+did\s+you\s+(just\s+)?(?:say|answer|reply)|
-                what\s+(?:was|is)\s+your\s+(?:last|previous)|
-                remind\s+me\s+what|
-                previous\s+(request|message|turn)|
-                last\s+(thing|request|message)\s+i
-              )\b
-            /ix
-          )
-            pairs = [pairs, 2].max
-          end
-          dialog = PWN::Memory.recent_dialog(session_id: sid, pairs: pairs, max_chars: 1_200)
+          dialog = PWN::Memory.recent_dialog(session_id: sid, pairs: pairs, max_chars: 8_000)
           return '' if dialog.nil? || dialog.empty?
 
           lines = dialog.map do |t|
@@ -237,18 +246,27 @@ module PWN
         private_class_method def self.skills_block
           return '' unless defined?(PWN::Skills) && PWN::Skills.is_a?(Hash) && !PWN::Skills.empty?
 
-          lines = PWN::Skills.map do |name, meta|
-            desc = meta[:description].to_s.strip
-            if desc.empty?
-              # legacy / stubbed entry without a parsed description — fall back
-              desc = meta[:content].to_s.lines.reject { |l| l.strip.empty? || l.start_with?('---') }.first.to_s.strip
+          catalog_names = if defined?(PWN::Config) && PWN::Config.respond_to?(:default_skill_names)
+                            Array(PWN::Config.default_skill_names)
+                          else
+                            []
+                          end
+          extra = 0
+          lines = []
+          PWN::Skills.each do |name, meta|
+            key = name.to_s
+            unless catalog_names.include?(key)
+              extra += 1
+              next
             end
+
+            desc = meta.is_a?(Hash) ? meta[:description].to_s.strip : ''
+            desc = meta[:content].to_s.lines.reject { |l| l.strip.empty? || l.start_with?('---') }.first.to_s.strip if desc.empty? && meta.is_a?(Hash)
             desc = desc[0, 100]
-            rc = Array(meta[:references]).length
-            ref_tag = rc.positive? ? " [#{rc} refs]" : ''
-            "  - #{name}: #{desc}#{ref_tag}"
+            lines << "  - #{key}: #{desc}"
           end
-          "SKILLS (call skill_view to read full body)\n#{lines.join("\n")}\n\n"
+          extra_line = extra.positive? ? "  (#{extra} additional files under ~/.pwn/skills — call skills_recall to search; they are not this catalog)\n" : ''
+          "SKILLS CATALOG (bundled pwn-ai; call skills_recall with no query to list)\n#{lines.join("\n")}\n#{extra_line}\n"
         rescue StandardError
           ''
         end

data/lib/pwn/ai/agent/registry.rb

@@ -41,7 +41,8 @@ module PWN
         )
 
         CORE_TOOLS = %w[memory_recall session_recall skills_recall pwn_eval shell
-                        mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
+                        mistakes_record mistakes_resolve learning_note_outcome
+                        memory_remember skills_update].freeze
 
         # Schema order = CORE_TOOLS. Current session is injected (RECENT TURNS).
         # Then memory / prior sessions / skills, then pwn_eval before shell.

data/lib/pwn/ai/agent/reward.rb

@@ -534,6 +534,10 @@ module PWN
             semantic = false
             shape = :invalid_payload
             err ||= 'invalid_payload'
+          elsif timeout_result?(err: err, raw: raw)
+            semantic = false
+            shape = :timeout
+            err ||= raw[/timeout after \d+s/i] || 'timeout'
           else
             semantic = ok && (exit_code.nil? || exit_code.zero? || benign)
           end
@@ -541,6 +545,11 @@ module PWN
           { ok: ok, semantic_ok: semantic, exit: exit_code, err: err, benign: benign, shape: shape }
         end
 
+        private_class_method def self.timeout_result?(opts = {})
+          blob = "#{opts[:err]} #{opts[:raw]}"
+          blob.match?(/timeout after \d+s/i) || blob.match?(/"error"\s*:\s*"timeout/i)
+        end
+
         # 2.2 — coarse recoverable shape beside the fingerprint. Paths are
         # normalised away for counting; shape stays for repair routing
         # (enoent → install/check path; exit127 → missing binary; …).

data/lib/pwn/ai/agent/swarm.rb

@@ -186,12 +186,14 @@ module PWN
           sys        = build_persona_prompt(name: name, persona: persona,
                                             swarm_id: sid, session_id: session_id)
 
+          empty_tools = opts[:text_only] == true || Array(persona[:toolsets]).empty?
           Thread.current[:pwn_swarm_depth] = depth + 1
           reply = with_persona_env(persona: persona) do
             Loop.run(
               request: opts[:request].to_s,
               session_id: session_id,
-              enabled_toolsets: persona[:toolsets],
+              enabled_toolsets: empty_tools ? [] : persona[:toolsets],
+              core_only: empty_tools ? false : true,
               system_role_content: sys,
               on_tool: opts[:on_tool]
             )

data/lib/pwn/ai/agent/task_summarizer.rb

@@ -206,7 +206,8 @@ module PWN
                 end
               when 'pwn_eval'
                 case sample
-                when /\b(write|file\.|fileutils|open\(|binwrite|puts )\b/ then 'mutate-ruby'
+                when /transparentbrowser|\.goto\b|browser_obj|dump_links|headless/ then 'browse'
+                when /\b(write|file\.|fileutils|binwrite)\b/ then 'mutate-ruby'
                 when /\b(load |require |const_get|method_list|instance_methods)\b/ then 'introspect-ruby'
                 else 'eval-ruby'
                 end
@@ -695,6 +696,17 @@ module PWN
           opts[:goal].to_s.gsub(/\s+/, ' ').strip
         end
 
+        private_class_method def self.browse_shaped?(opts = {})
+          Array(opts[:tools]).any? do |tool|
+            next unless tool.is_a?(Hash)
+
+            blob = "#{tool[:name]} #{tool[:args]}"
+            blob.match?(/transparentbrowser|\.goto\b|browser_obj|dump_links|headless/i)
+          end
+        rescue StandardError
+          false
+        end
+
         # Infer a plain-English "why" from the tool mix.
         # When a plan is active the goal is already on the plan line — keep why short
         # so each about_to batch stays distinct and is not a near-duplicate of the plan.
@@ -702,7 +714,9 @@ module PWN
           names = opts[:names]
           caps = capabilities_for(names: names)
           focus =
-            if caps.any? { |c| c.include?('shell') || c.include?('Ruby') }
+            if browse_shaped?(tools: opts[:tools])
+              'navigate and collect from the live page'
+            elsif caps.any? { |c| c.include?('shell') || c.include?('Ruby') }
               'gather evidence and apply code/host changes'
             elsif caps.any? { |c| c.include?('extro') || c.include?('verify') }
               'fact-check external state before acting'
@@ -796,6 +810,7 @@ module PWN
           why = why_bit(
             request: request,
             names: names,
+            tools: tools,
             with_goal: plan_bit.empty? && !plan_emitted
           )
 
@@ -1345,7 +1360,7 @@ module PWN
             /\b(implement\w*|fix|patch\w*|chang\w*|improv\w*|write|apply|wire|refactor\w*)\b/
           )
           return :discover if s.match?(
-            /\b(locat\w*|find|read|inspect|recon\w*|understand|decompos\w*|map|identif\w*|gather|discover|enumerat\w*|scan|probe|determin\w*|root cause|where and why|track)\b/
+            /\b(locat\w*|find|read|inspect|recon\w*|understand|decompos\w*|map|identif\w*|gather|discover|enumerat\w*|scan|probe|determin\w*|root cause|where and why|track|navigat\w*|browse|goto)\b/
           )
 
           :generic
@@ -1357,7 +1372,7 @@ module PWN
           s = opts[:intent].to_s.downcase
           return :verify if s.match?(/test|rubocop|rake|rspec|offenses|failures/)
           return :mutate if s.match?(/edit|mutate|write|patch|sed\s+-i|file.write|refactor/)
-          return :discover if s.match?(/search|read|recon|extro|sessions|memory|find|list|scan|inspect|locat/)
+          return :discover if s.match?(/search|read|recon|extro|sessions|memory|find|list|scan|inspect|locat|browse|goto|navigat/)
 
           :generic
         rescue StandardError
@@ -1437,12 +1452,14 @@ module PWN
           when :mutate, :verify
             item_covered?(item: opts[:item], blob: joined)
           when :discover, :generic, :present
+            browse_hit = joined.match?(/effect["\s:=]+browse|transparentbrowser|\.goto\b|\bbrowse\b/i)
+            min_tools = browse_hit ? 1 : DISCOVER_MIN_TOOLS
             on_task = opts[:state].is_a?(Hash) ? opts[:state][:tools_on_task].to_i : 0
-            return false if on_task < DISCOVER_MIN_TOOLS
+            return false if on_task < min_tools
             return false unless item_covered?(item: opts[:item], blob: joined)
 
             intent_s = (Array(opts[:intents]) + Array(opts[:names])).join(' ')
-            task_intent_match?(item: opts[:item], intent: intent_s) || phase == :present
+            task_intent_match?(item: opts[:item], intent: intent_s) || phase == :present || browse_hit
           else
             false
           end

data/lib/pwn/ai/agent/tool_guard.rb

@@ -94,6 +94,115 @@ module PWN
           }
         end
 
+        public_class_method def self.host_load(opts = {})
+          return { ncpu: 1, load1: 0.0, mem_avail_mb: 0 } unless opts.is_a?(Hash)
+
+          ncpu = File.readable?('/proc/cpuinfo') ? File.read('/proc/cpuinfo').scan(/^processor/).size : 0
+          ncpu = 1 if ncpu < 1
+          load1 = 0.0
+          load1 = File.read('/proc/loadavg').to_s.split[0].to_f if File.readable?('/proc/loadavg')
+          avail = 0
+          if File.readable?('/proc/meminfo')
+            File.foreach('/proc/meminfo') do |ln|
+              next unless ln.start_with?('MemAvailable:')
+
+              avail = ln.split[1].to_i / 1024
+              break
+            end
+          end
+          { ncpu: ncpu, load1: load1, mem_avail_mb: avail }
+        rescue StandardError
+          { ncpu: 1, load1: 0.0, mem_avail_mb: 0 }
+        end
+
+        # Conservative wall-clock seconds for shell / pwn_eval.
+        # Explicit model estimate is honored then clamped. Omit → host-derived
+        # default from loadavg / ncpu / MemAvailable (loaded hosts get a bit
+        # more time, still capped).
+        public_class_method def self.deadline_s(opts = {})
+          kind = opts[:kind].to_s.to_sym
+          max = kind == :shell ? 180 : 90
+          asked = opts[:timeout] || opts[:timeout_s]
+          asked_i = asked.to_i
+          if asked_i.positive?
+            lo = 1
+            hi = max
+            return asked_i.clamp(lo, hi)
+          end
+
+          snap = host_load
+          ncpu = [snap[:ncpu].to_i, 1].max
+          load1 = snap[:load1].to_f
+          mem = snap[:mem_avail_mb].to_i
+          base = kind == :shell ? 30 : 20
+          base += 15 if load1 > ncpu
+          base += 10 if load1 > (ncpu * 1.5)
+          base += 10 if mem.positive? && mem < 512
+          base.clamp(8, max)
+        end
+
+        # Two-scenario timeout policy (loop-law, not a skill):
+        # 1. First timeout → reconstruct the ruby/command for the same goal.
+        #    Do not first raise timeout.
+        # 2. A later timeout of the same tool → deadline was too short; raise
+        #    a conservative HOST LOAD timeout (still clamped).
+        public_class_method def self.timeout_lesson(opts = {})
+          return { scenario: :construction, error: '', hint: '' } unless opts.is_a?(Hash)
+
+          tool = opts[:tool].to_s
+          timeout = opts[:timeout].to_i
+          prior = timeout_prior_count(tool: tool)
+          if prior.positive?
+            {
+              scenario: :deadline,
+              error: "#{tool} timeout: deadline too short; raise conservative HOST LOAD timeout",
+              hint: "Scenario 2: the #{tool} payload already timed out once. " \
+                    "This timeout (#{timeout}s) was too short. Raise a conservative " \
+                    'timeout from HOST LOAD (clamped). Record this so it does not recur. ' \
+                    'Do not retry the identical payload at the same deadline.'
+            }
+          else
+            {
+              scenario: :construction,
+              error: "#{tool} timeout: reconstruct payload to same goal before raising timeout",
+              hint: "Scenario 1 (try first): the #{tool} ruby/command was constructed " \
+                    'improperly. Generate it differently to achieve the same goal. ' \
+                    'Do not first raise timeout. Record this so it does not recur.'
+            }
+          end
+        end
+
+        public_class_method def self.timeout_result(opts = {})
+          return { stdout: '', stderr: '', exit: nil, error: 'timeout', scenario: :construction, hint: '', shell: shell_name } unless opts.is_a?(Hash)
+
+          lesson = timeout_lesson(
+            tool: opts[:tool],
+            payload: opts[:payload],
+            timeout: opts[:timeout]
+          )
+          {
+            stdout: opts[:stdout].to_s,
+            stderr: opts[:stderr].to_s,
+            exit: nil,
+            error: "timeout after #{opts[:timeout].to_i}s",
+            scenario: lesson[:scenario],
+            hint: lesson[:hint],
+            shell: opts[:shell] || shell_name
+          }
+        end
+
+        public_class_method def self.timeout_prior_count(opts = {})
+          return 0 unless opts.is_a?(Hash)
+          return 0 unless defined?(PWN::AI::Agent::Mistakes)
+
+          tool = opts[:tool].to_s
+          PWN::AI::Agent::Mistakes.for_tool(tool: tool, unresolved_only: true).count do |m|
+            m[:shape].to_s == 'timeout' || m[:error].to_s.match?(/timeout/)
+          end
+        rescue StandardError
+          0
+        end
+
         public_class_method def self.authors
           "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
         end

data/lib/pwn/ai/agent/tools/ruby_eval.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'stringio'
+require 'timeout'
 require 'pwn/ai/agent/registry'
 require 'pwn/ai/agent/tool_guard'
 
@@ -16,12 +17,23 @@ PWN::AI::Agent::Registry.register(
     description: 'Evaluate Ruby in the live pwn REPL process with the full ' \
                  'PWN:: namespace available (PWN::Plugins::NmapIt, ' \
                  'PWN::Plugins::TransparentBrowser, PWN::Plugins::BurpSuite, ' \
-                 'PWN::SAST, PWN::Reports, PWN::AI::Agent::*, etc.). Returns ' \
-                 'captured stdout plus the inspected value of the last expression.',
+                 'PWN::SAST, PWN::Reports, PWN::AI::Agent::*, etc.). Locals ' \
+                 'persist across calls in this process — open a browser once ' \
+                 '(browser_obj = TransparentBrowser.open(...); browser = ' \
+                 'browser_obj[:browser]), then navigate via that same ' \
+                 'browser. Do not open a second browser. Close once with ' \
+                 'Close once with TransparentBrowser.close(browser_obj: browser_obj). ' \
+                 'Pass timeout as a conservative integer seconds estimate given HOST ' \
+                 'LOAD (loadavg, ncpu, mem). Omit for a host-derived default (clamped). ' \
+                 'Returns captured stdout plus the inspected value of the last expression.',
     parameters: {
       type: 'object',
       properties: {
-        code: { type: 'string', description: 'Ruby source to evaluate.' }
+        code: { type: 'string', description: 'Ruby source to evaluate.' },
+        timeout: {
+          type: 'integer',
+          description: 'Conservative seconds this eval should take given HOST LOAD. Omit for host-derived default. Clamped 1..90.'
+        }
       },
       required: %w[code]
     }
@@ -49,45 +61,57 @@ PWN::AI::Agent::Registry.register(
     old_stdout = $stdout
     buf = StringIO.new
     $stdout = buf
+    timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :eval)
     begin
       # rubocop:disable Security/Eval
-      # rubocop:disable Style/DocumentDynamicEvalDefinition
       # INTENTIONAL: this IS the pwn-ai → PWN bridge
       # As YTCracker says, "It ain't a bug, it's a featcha."
       # https://www.youtube.com/watch?v=2nALqqSqdDw
       #
       # File label '(pwn_eval)' (not __FILE__) so SyntaxError / NameError
-      # messages cite the *payload* line, not ruby_eval.rb:49 glued to source
-      # (e.g. "ruby_eval:49results = probes.map do |R|").
+      # messages cite the *payload* line, not ruby_eval.rb glued to source.
       # Rescue ScriptError (SyntaxError, LoadError, NotImplementedError) as
       # well as StandardError — Dispatch only catches StandardError, so an
       # unrescued SyntaxError previously escaped the tool loop. Returning a
       # structured error lets the model self-heal (fix code and retry).
-      # rubocop:disable Style/EvalWithLocation -- intentional file label
-      # '(pwn_eval)' so SyntaxError/NameError messages cite the payload, not
-      # this library line (specs + model self-heal depend on that string).
-      proc = eval(
-        "proc { #{code}\n}",
-        TOPLEVEL_BINDING,
-        '(pwn_eval)',
-        1
-      )
-      # rubocop:enable Style/EvalWithLocation
-      val = proc.call
+      # Evaluate in TOPLEVEL_BINDING so locals (browser_obj, browser)
+      # persist across pwn_eval calls. Wrapping in proc { } made each
+      # call a fresh scope — the next snippet hit NameError and opened
+      # another Chrome.
+      val = Timeout.timeout(timeout) do
+        eval(
+          code,
+          TOPLEVEL_BINDING,
+          '(pwn_eval)',
+          1
+        )
+      end
       # rubocop:enable Security/Eval
-      # rubocop:enable Style/DocumentDynamicEvalDefinition
-      { stdout: buf.string, value: val.inspect }
+      { stdout: buf.string, value: val.inspect, timeout: timeout }
+    rescue Timeout::Error
+      lesson = PWN::AI::Agent::ToolGuard.timeout_lesson(
+        tool: 'pwn_eval',
+        payload: code,
+        timeout: timeout
+      )
+      {
+        stdout: buf.string,
+        error: "timeout after #{timeout}s",
+        scenario: lesson[:scenario],
+        hint: lesson[:hint]
+      }
     rescue ScriptError, StandardError => e
       {
         stdout: buf.string,
         error: "#{e.class}: #{e.message}",
         backtrace: Array(e.backtrace).first(5),
-        # Hint common payload footguns the model keeps emitting
         hint: (
           if e.is_a?(SyntaxError) && e.message.match?(/formal argument cannot be a constant/)
             'Block parameters must be local variables (lowercase), e.g. |r| not |R|. Also close every do/end.'
           elsif e.is_a?(SyntaxError)
             'Payload failed to parse. Check matching do/end, braces, and that no line-number prefix was glued onto the code.'
+          elsif e.is_a?(NameError) && e.message.match?(/undefined local variable or method '(browser|browser_obj)'/)
+            'Reuse the existing browser_obj / browser from the prior pwn_eval. Do not call TransparentBrowser.open again.'
           end
         )
       }

data/lib/pwn/ai/agent/tools/shell.rb

@@ -21,12 +21,17 @@ PWN::AI::Agent::Registry.register(
     name: 'shell',
     description: 'Execute a shell command on the local pwn host and return ' \
                  'stdout/stderr/exit code. Use for OS-level work: nmap, curl, ' \
-                 'ls, git, file inspection, anything not in the PWN:: namespace.',
+                 'ls, git, file inspection, anything not in the PWN:: namespace. ' \
+                 'Pass timeout as a conservative integer seconds estimate given ' \
+                 'HOST LOAD (loadavg, ncpu, mem). Omit for a host-derived default (clamped).',
     parameters: {
       type: 'object',
       properties: {
         command: { type: 'string', description: 'The exact shell command to run.' },
-        timeout: { type: 'integer', description: 'Seconds before the command is killed.', default: 120 }
+        timeout: {
+          type: 'integer',
+          description: 'Conservative seconds this command should take given HOST LOAD. Omit for host-derived default. Clamped 1..180.'
+        }
       },
       required: %w[command]
     }
@@ -47,7 +52,7 @@ PWN::AI::Agent::Registry.register(
                         .gsub(/\\\r?\n/, ' ')
                         .gsub(/\\+\s*\z/, '')
                         .strip
-    timeout = (args[:timeout] || 120).to_i
+    timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :shell)
     if cmd.empty? || PWN::AI::Agent::ToolGuard.placeholder?(text: cmd)
       return PWN::AI::Agent::ToolGuard.invalid_payload(
         hint: 'command is required (string). Do not send ..., {...}, {…}, or empty. ' \
@@ -158,7 +163,15 @@ PWN::AI::Agent::Registry.register(
       end
     end
 
-    return { stdout: stdout, stderr: stderr, exit: nil, error: "timeout after #{timeout}s", shell: PWN::AI::Agent::ToolGuard.shell_name } if timed_out
+    if timed_out
+      return PWN::AI::Agent::ToolGuard.timeout_result(
+        tool: 'shell',
+        payload: cmd,
+        stdout: stdout,
+        stderr: stderr,
+        timeout: timeout
+      )
+    end
 
     { stdout: stdout, stderr: stderr, exit: exitstatus, shell: PWN::AI::Agent::ToolGuard.shell_name }
   }

data/lib/pwn/ai/agent/tools/skills.rb

@@ -30,8 +30,9 @@ PWN::AI::Agent::Registry.register(
     description: 'Search installed pwn-ai skills (name, description, body, ' \
                  'references) for how to do similar work. Call before ' \
                  'pwn_eval / shell when a reusable procedure may exist. ' \
-                 'The SKILLS index is already in the prompt — this loads ' \
-                 'matching full methods.',
+                 'Empty query returns the bundled pwn-ai catalog only — not ' \
+                 'a mixed ~/.pwn/skills dump. A keyword query searches the ' \
+                 'live index.',
     parameters: {
       type: 'object',
       properties: {
@@ -50,6 +51,30 @@ PWN::AI::Agent::Registry.register(
     limit = (args[:limit] || 6).to_i
     limit = 6 if limit <= 0
     trunc = 400
+    catalog_names = if defined?(PWN::Config) && PWN::Config.respond_to?(:default_skill_names)
+                      Array(PWN::Config.default_skill_names)
+                    else
+                      []
+                    end
+    if query.empty? && tokens.empty?
+      catalog = []
+      other = 0
+      PWN::Skills.each do |name, meta|
+        next unless meta.is_a?(Hash)
+
+        key = name.to_s
+        unless catalog_names.include?(key)
+          other += 1
+          next
+        end
+
+        catalog << {
+          name: key,
+          description: meta[:description].to_s
+        }
+      end
+      return { catalog: catalog, other_installed: other }
+    end
     hits = []
     PWN::Skills.each do |name, meta|
       next unless meta.is_a?(Hash)
@@ -78,6 +103,42 @@ PWN::AI::Agent::Registry.register(
   }
 )
 
+PWN::AI::Agent::Registry.register(
+  name: 'skills_update',
+  toolset: 'skills',
+  schema: {
+    name: 'skills_update',
+    description: 'Fold RL feedback (resolved mistakes, structured fixes, ' \
+                 'or an explicit lesson) into an existing skill SOP. Does ' \
+                 'not create skills and does not write loop-law. Call after ' \
+                 'mistakes_resolve / learning_note_outcome when a durable ' \
+                 'procedure should change. Omitting name ranks installed ' \
+                 'skills from query/request.',
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Existing skill to update. Ranked from query when omitted.' },
+        query: { type: 'string', description: 'Keywords to pick the skill when name is omitted.' },
+        lesson: { type: 'string', description: 'Optional explicit note to append under ## RL feedback.' },
+        signature: { type: 'string', description: 'Optional Mistakes signature to fold.' },
+        dry_run: { type: 'boolean', description: 'When true, do not write the skill file.' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Learning) && PWN::AI::Agent::Learning.respond_to?(:update_skill) },
+  handler: lambda { |args|
+    PWN::AI::Agent::Learning.update_skill(
+      name: args[:name],
+      query: args[:query],
+      lesson: args[:lesson],
+      signature: args[:signature],
+      request: args[:query],
+      dry_run: args[:dry_run]
+    )
+  }
+)
+
 PWN::AI::Agent::Registry.register(
   name: 'skill_list',
   toolset: 'skills',

data/lib/pwn/ai/anthropic.rb

@@ -409,8 +409,8 @@ module PWN
         http_body = opts[:http_body]
         http_body ||= {}
 
-        timeout = opts[:timeout]
-        timeout ||= 900
+        timeout = PWN::AI::HttpRetry.timeout_s(opts)
+        max_attempts = PWN::AI::HttpRetry.max_attempts(opts)
 
         spinner = opts[:spinner] || false
 
@@ -460,11 +460,31 @@ module PWN
 
           response.body
         rescue RestClient::TooManyRequests => e
-          retry_after = e.response.headers[:retry_after]&.to_i || (0.5 * (retry_count + 1))
-          sleep(retry_after + rand(0.3..5.0))
           retry_count += 1
-
+          if retry_count >= max_attempts
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'anthropic', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: '429 retries exhausted', error: e
+              )
+            end
+            raise "Anthropic API Error: #{e.message}: #{e.response}"
+          end
+          sleep(PWN::AI::HttpRetry.retry_after_s(response: e.response, retry_count: retry_count) + rand(0.3..5.0))
           retry
+        rescue RestClient::Exceptions::Timeout => e
+          retry_count += 1
+          unless opts[:quiet]
+            PWN::AI::HttpRetry.report_event(
+              label: 'anthropic', which_self: self, quiet: opts[:quiet],
+              http_method: http_method, rest_call: rest_call,
+              extra: "timeout=#{timeout}s attempt=#{retry_count}/#{max_attempts}", error: e
+            )
+          end
+          retry if retry_count < max_attempts
+
+          raise "Anthropic API Error: #{e.class}: #{e.message}"
         rescue RestClient::ExceptionWithResponse => e
           raise "Anthropic API Error: #{e.message}: #{e.response}"
         rescue StandardError => e