pwn 0.5.686 → 0.5.688

data/spec/lib/pwn/ai/agent/loop_spec.rb

@@ -16,22 +16,21 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
   end
 
   describe 'RL-adjacent loop contracts' do # rubocop:disable Metrics/BlockLength
-    it 'does not start a TTY spinner on engine calls (leftover spin overwrites PS1)' do
+    it 'spins on engine HTTP wait and still dispatches on_tool (debug must not hide the TUI)' do
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).not_to match(/spinner:\s*true/)
-      expect(src).to match(/spinner:\s*false/)
+      expect(src).to match(/spinner:\s*true/)
+      expect(src).to match(/on_tool&?\.call/)
+      expect(src).not_to match(/on_tool\s*=\s*nil/)
     end
 
-    it 'exhaust path still calls task_summary_flush! and auto_introspect' do
+    it 'does not treat a round cap as a finished answer' do
       src = File.read(described_class.method(:run).source_location.first)
-      # budget exhausted terminal path
-      expect(src).to match(/iteration budget exhausted/)
-      # after the exhausted final_msg, both flush and auto_introspect must appear
-      exhaust = src[/final_msg = '\[pwn-ai\] iteration budget exhausted'.*/m]
-      expect(exhaust).to match(/Learning\.auto_introspect/)
-      expect(exhaust).to match(/task_summary_flush!/)
-      # flush before return of final_msg
-      expect(exhaust).to match(/task_summary_flush!.*final_msg/m)
+      expect(src).not_to match(/iteration budget exhausted/)
+      expect(src).not_to match(/final budget_exhausted/)
+      expect(src).not_to match(/shape: :budget_exhausted/)
+      expect(src).not_to match(/max_iters\.times/)
+      expect(src).to match(/may_finalize\?/)
+      expect(src).to match(/loop do/)
     end
 
     it 'plan_first unifies ts_state plan after red_team (P2)' do
@@ -359,6 +358,128 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(described_class.needs_host_work?(request: 'Write hello into /tmp/x.txt')).to eq true
     end
 
+    it 'skips the implement compass on a browse/navigate request' do
+      req = 'Navigate to https://0dayinc.com using TransparentBrowser.open and list blog URLs'
+      expect(described_class.send(:request_need, request: req)).to eq :browse
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/skip_compass = .*browse/)
+    end
+
+    it 'does not bounce a text-only turn for missing tool evidence' do
+      req = 'Navigate to https://0dayinc.com using TransparentBrowser.open and list blog URLs'
+      expect(described_class.needs_host_work?(request: req)).to eq true
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: req,
+          messages: [{ role: 'assistant', content: 'SOUND — step 1 is the likely fail.', tool_calls: [] }]
+        )
+      ).to eq true
+      Thread.current[:pwn_loop_no_tools] = true
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: req,
+          messages: [{ role: 'assistant', content: 'SOUND — step 1 is the likely fail.', tool_calls: [] }]
+        )
+      ).to eq false
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/pwn_loop_no_tools/)
+      expect(src).to match(/skip_compass = .*no_tools/)
+    ensure
+      Thread.current[:pwn_loop_no_tools] = nil
+    end
+
+    it 'does not start post-answer review from a nested or tool-less Loop.run' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/!nested && !no_tools && should_auto_introspect\?/)
+      expect(
+        described_class.send(
+          :should_auto_introspect?,
+          local: false,
+          turn_fails: {},
+          iter: 1
+        )
+      ).to eq true
+      Thread.current[:pwn_loop_no_tools] = true
+      expect(
+        described_class.send(
+          :should_auto_introspect?,
+          local: false,
+          turn_fails: {},
+          iter: 1
+        )
+      ).to eq false
+    ensure
+      Thread.current[:pwn_loop_no_tools] = nil
+    end
+
+    it 'writes full tool request/result to the debug log and timestamps Interrupt' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/debug_tool_io!/)
+      expect(src).to match(/tool #\{name\} start/)
+      expect(src).to match(/rescue Interrupt/)
+      expect(src).to match(/note_interrupt!/)
+      expect(src).to match(/pwn_log_progress/)
+      expect(src).to match(/note_exception!/)
+      expect(src).to match(/rescue StandardError/)
+      expect(src).to include("debug_progress(msg: 'engine returned no message')")
+      expect(src).not_to match(/dispatch #\{name\} ok_len=/)
+    end
+
+    it 'records a reconstruct-first timeout mistake instead of treating success:true as ok' do
+      tmp = Dir.mktmpdir
+      stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+      raw = JSON.generate(
+        success: true,
+        result: { stdout: '', error: 'timeout after 20s', hint: 'x', scenario: 'construction' }
+      )
+      tele = described_class.send(
+        :record_metrics,
+        name: 'pwn_eval',
+        started: Time.now,
+        raw: raw,
+        args: '{"code":"sleep 3"}'
+      )
+      expect(tele[:ok]).to eq false
+      expect(tele[:mistake]).to be_a(Hash)
+      expect(tele[:mistake][:error].to_s).to match(/reconstruct/)
+      expect(tele[:mistake][:shape].to_s).to eq('timeout')
+    end
+
+    it 'treats a skills-catalog ask as recall, not trivia or host-work' do
+      req = 'what skills are available?'
+      expect(described_class.catalog_lookup?(request: req)).to eq true
+      expect(described_class.world_knowledge?(request: req)).to eq false
+      expect(described_class.needs_host_work?(request: req)).to eq false
+      expect(described_class.send(:request_need, request: req)).to eq :read
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: req,
+          messages: [{ role: 'assistant', content: '103 skills…', tool_calls: [] }]
+        )
+      ).to eq true
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: req,
+          messages: [
+            {
+              role: 'assistant',
+              content: '',
+              tool_calls: [
+                { function: { name: 'skills_recall', arguments: '{}' } }
+              ]
+            }
+          ]
+        )
+      ).to eq false
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/skip_plan.*catalog/)
+      expect(src).to match(/force_plan && cal_state\[:cal\] && !skip_plan/)
+    end
+
     it 'does not treat rspec/rubocop green as a finished write/docs ask' do
       req = 'Update all markdown files to reflect operational changes and rebuild diagrams'
       verified = [
@@ -415,7 +536,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src).not_to match(/blob\.match\?\(MUTATION_EVIDENCE_RX\)/)
     end
 
-    it 'keeps tools on last_iter for any unfinished host-work request' do
+    it 'keeps tools for any unfinished host-work request — no last-iter strip' do
       req = 'Update all markdown files and rebuild diagrams'
       verified = [
         { role: 'tool', name: 'shell', content: "12 examples, 0 failures\n" }
@@ -429,8 +550,8 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
         )
       ).to eq true
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).to match(/still_open = request_unsatisfied\?/)
-      expect(src).to match(/last_iter = want_last && !still_open/)
+      expect(src).not_to match(/last_iter = want_last && !still_open/)
+      expect(src).to match(/call_engine\(messages: messages, tools: tools/)
     end
 
     it 'never accepts a text final while the original host-work request is unsatisfied' do
@@ -546,9 +667,9 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       ).to eq false
     end
 
-    it 'last-iter strips tools only on the true last slot; leftover English tasks do not force required' do
+    it 'does not strip tools on a last slot; leftover English tasks do not force required' do
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).to match(/text_only_iters = 1/)
+      expect(src).not_to match(/text_only_iters = 1/)
       expect(src).not_to match(/english_open && hot/)
       expect(src).to match(/has_tool_result \|\| !need_tools \? 'auto' : 'required'/)
       expect(src).not_to match(/still_acting/)
@@ -671,6 +792,37 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       FileUtils.rm_rf(sess_tmp) if sess_tmp
     end
 
+    it 'sends this session conversation as LLM messages without a recall-cue regex' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/to_llm_messages|session_chat_history/)
+      expect(src).not_to match(/VAGUE_MEMORY_RX.*?to_llm_messages/m)
+      sess_tmp = Dir.mktmpdir('pwn-sess-hist')
+      stub_const('PWN::Sessions::SESSIONS_DIR', sess_tmp)
+      sid = 'hist_run_spec'
+      PWN::Sessions.create(id: sid, title: 'hist-run')
+      PWN::Sessions.append(session_id: sid, role: 'user', content: 'where is OpenGoal implemented?')
+      PWN::Sessions.append(session_id: sid, role: 'assistant', content: 'lib/pwn/ai/agent/open_goal.rb')
+      seen = []
+      allow(described_class).to receive(:should_auto_introspect?).and_return(false)
+      allow(described_class).to receive(:plan_first).and_return(nil)
+      allow(PWN::AI::Agent::TaskSummarizer).to receive(:enabled?).and_return(false) if defined?(PWN::AI::Agent::TaskSummarizer)
+      allow(described_class).to receive(:call_engine) do |opts|
+        seen = Array(opts[:messages])
+        { role: 'assistant', content: 'in loop.rb Loop.run', tool_calls: [] }
+      end
+      out = described_class.run(
+        request: 'where is this logic implemented in /opt/pwn when using pwn-ai',
+        session_id: sid,
+        system_role_content: 'test system'
+      )
+      expect(out).to include('in loop.rb Loop.run')
+      expect(seen.map { |m| m[:content].to_s }).to include('where is OpenGoal implemented?')
+      expect(seen.map { |m| m[:content].to_s }).to include('lib/pwn/ai/agent/open_goal.rb')
+      expect(seen.map { |m| m[:content].to_s }).to include('where is this logic implemented in /opt/pwn when using pwn-ai')
+    ensure
+      FileUtils.rm_rf(sess_tmp) if sess_tmp
+    end
+
     it 'classifies pure prior-turn recall and vague memory cues as :recall' do
       expect(described_class.request_intent(request: 'what did I just say?')).to eq(:recall)
       expect(described_class.request_intent(request: 'What did I just say')).to eq(:recall)
@@ -720,14 +872,14 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
     it 'answer_howto does not register shell tool use in source path' do
       src = File.read(described_class.method(:run).source_location.first)
       # how-to return happens before task_summary_plan!
-      expect(src).to match(/if intent == :howto.*?return answer_howto/m)
+      expect(src).to match(/if intent == :howto.*?txt = answer_howto/m)
     end
 
     it 'run short-circuits pure recall via answer_recall before plan_first' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/RECALL_RX/)
       expect(src).to match(/answer_recall/)
-      expect(src).to match(/intent == :recall.*?return answer_recall/m)
+      expect(src).to match(/intent == :recall.*?txt = answer_recall/m)
       expect(src).to match(/skip_plan/)
       expect(src).not_to match(/request_kind/)
     end
@@ -736,7 +888,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/GREETING_RX/)
       expect(src).to match(/answer_greeting/)
-      expect(src).to match(/intent == :greeting.*?return answer_greeting/m)
+      expect(src).to match(/intent == :greeting.*?txt = answer_greeting/m)
       expect(src).to match(/skip_plan/)
       expect(src).not_to match(/request_kind/)
     end
@@ -1013,6 +1165,14 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
   it 'streams request-processing progress through PWN::Plugins::Log when debug is on' do
     src = File.read(described_class.method(:run).source_location.first)
     expect(src).to match(/PWN::Plugins::Log\.start_debug/)
+    expect(src).to match(/next_request_log!/)
+    expect(src).to match(/finish_request_log!/)
+    expect(src).to match(/skip_roll|user_path\?/)
+    expect(src).to match(/bounce /)
+    expect(src).to match(/plan_first=/)
+    expect(src).to match(/final text/)
+    expect(src).to match(/debug_tools_line|tools=.*\[/)
+    expect(src).to match(/debug_msgs_line|msgs=.*\[/)
     expect(src).to match(/PWN::Plugins::Log\.progress/)
     expect(src).to match(/quiet_debug_tui!/)
     expect(described_class).to respond_to(:debug_on?)

data/spec/lib/pwn/ai/agent/prompt_builder_spec.rb

@@ -73,6 +73,9 @@ describe PWN::AI::Agent::PromptBuilder do
       expect(src).to match(/learning_block/)
       expect(src).to match(/KNOWN MISTAKES|mistakes_block/)
       expect(src).to match(/skills_recall/)
+      expect(src).to match(/default_skill_names|SKILLS CATALOG/)
+      expect(src).to match(/HOST LOAD/)
+      expect(src).to match(/host_load|deadline_s/)
     end
   end
 end

data/spec/lib/pwn/ai/agent/registry_spec.rb

@@ -16,7 +16,7 @@ describe PWN::AI::Agent::Registry do
   it 'CORE_TOOLS is recall-then-act including skills_recall before pwn_eval' do
     expect(described_class.const_defined?(:ACT_PREFERENCE)).to eq false
     expect(described_class::CORE_TOOLS).to eq(
-      %w[memory_recall session_recall skills_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember]
+      %w[memory_recall session_recall skills_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember skills_update]
     )
     expect(described_class::DEFAULT_PREFERENCE).to eq(described_class::CORE_TOOLS)
     expect(described_class::DEFAULT_PREFERENCE).not_to include('sessions_view')

data/spec/lib/pwn/ai/agent/reward_spec.rb

@@ -68,6 +68,19 @@ describe PWN::AI::Agent::Reward do
     expect(r[:benign]).to be false
   end
 
+  it 'treats handler timeout after Ns as not semantic_ok even when success is true' do
+    raw = '{"success":true,"result":{"stdout":"","error":"timeout after 20s","exit":null}}'
+    r = described_class.semantic_ok(name: 'pwn_eval', raw: raw)
+    expect(r[:semantic_ok]).to be false
+    expect(r[:shape]).to eq(:timeout)
+    r2 = described_class.semantic_ok(
+      name: 'shell',
+      raw: '{"success":true,"result":{"stdout":"","stderr":"","exit":null,"error":"timeout after 30s"}}'
+    )
+    expect(r2[:semantic_ok]).to be false
+    expect(r2[:shape]).to eq(:timeout)
+  end
+
   it 'recoverable_shape classifies common failure classes (2.2)' do
     expect(described_class.recoverable_shape(exit_code: 127, err: 'nmap: command not found')).to eq :exit127
     expect(described_class.recoverable_shape(err: 'No such file or directory')).to eq :enoent

data/spec/lib/pwn/ai/agent/swarm_spec.rb

@@ -31,4 +31,10 @@ describe PWN::AI::Agent::Swarm do
   ensure
     Thread.current[:pwn_swarm_depth] = nil
   end
+
+  it 'text_only / empty toolsets strip tools so a reviewer cannot open browsers' do
+    src = File.read(described_class.method(:ask).source_location.first)
+    expect(src).to match(/text_only/)
+    expect(src).to match(/core_only:\s*empty_tools/)
+  end
 end

data/spec/lib/pwn/ai/agent/task_summarizer_spec.rb

@@ -104,6 +104,42 @@ describe PWN::AI::Agent::TaskSummarizer do
       expect(line).not_to match(/about to run shell:/i)
     end
 
+    it 'does not label a TransparentBrowser navigate as apply code/host changes' do
+      line = described_class.about_to(
+        tools: [
+          {
+            name: 'pwn_eval',
+            args: {
+              'code' => "$browser_obj = PWN::Plugins::TransparentBrowser.open(browser_type: :chrome); $browser.goto('https://example.com')"
+            }
+          }
+        ],
+        state: state,
+        request: 'Navigate to https://example.com and list blog URLs'
+      )
+      expect(line).to be_a(String)
+      expect(line).not_to match(%r{apply code/host changes}i)
+      expect(line).to match(/navigate|collect|browse|page/i)
+    end
+
+    it 'advances off a Navigate task after one successful browse eval' do
+      st = described_class.fresh(request: 'Navigate to https://example.com and list posts')
+      st[:plan] = [
+        'Understand the request',
+        'Navigate to the example.com website',
+        'Collect every blog post URL',
+        'Close the browser'
+      ]
+      st[:plan_idx] = 1
+      described_class.record!(
+        state: st,
+        name: 'pwn_eval',
+        args: { 'code' => "browser.goto('https://example.com')" },
+        result: '{"success":true,"result":{"value":"{url: \\"https://example.com/\\"}"},"effect":"browse"}'
+      )
+      expect(st[:plan_idx]).to be > 1
+    end
+
     it 'keeps single-tool legacy about_to(name:, args:) as a high-level brief' do
       line = described_class.about_to(
         name: 'shell',

data/spec/lib/pwn/ai/agent/tool_guard_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tmpdir'
 
 describe PWN::AI::Agent::ToolGuard do
   it 'should display information for authors' do
@@ -58,4 +59,49 @@ describe PWN::AI::Agent::ToolGuard do
       expect(out[:stderr]).to include('missing required command')
     end
   end
+
+  describe '.host_load / .deadline_s' do
+    it 'reports load1, ncpu, and mem_avail_mb' do
+      snap = described_class.host_load
+      expect(snap[:ncpu].to_i).to be >= 1
+      expect(snap[:load1]).to be_a(Numeric)
+      expect(snap[:mem_avail_mb].to_i).to be >= 0
+    end
+
+    it 'clamps an explicit timeout and derives a default when omitted' do
+      expect(described_class.deadline_s(timeout: 1, kind: :eval)).to eq(1)
+      expect(described_class.deadline_s(timeout: 9_999, kind: :eval)).to eq(90)
+      expect(described_class.deadline_s(timeout: 9_999, kind: :shell)).to eq(180)
+      omitted = described_class.deadline_s(kind: :eval)
+      expect(omitted).to be_between(8, 90)
+    end
+  end
+
+  describe '.timeout_lesson' do
+    it 'prefers reconstruct-the-payload before raising timeout' do
+      tmp = Dir.mktmpdir
+      stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+      first = described_class.timeout_lesson(tool: 'pwn_eval', payload: 'sleep 3', timeout: 1)
+      expect(first[:scenario]).to eq(:construction)
+      expect(first[:hint]).to match(/reconstruct|generated differently|improperly/i)
+      expect(first[:hint]).to match(/do not first raise timeout/i)
+      expect(first[:error]).to match(/reconstruct/)
+    end
+
+    it 'switches to deadline-too-short only after a prior timeout mistake' do
+      tmp = Dir.mktmpdir
+      stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+      PWN::AI::Agent::Mistakes.record(
+        tool: 'shell',
+        error: 'shell timeout: reconstruct payload to same goal before raising timeout',
+        args: 'sleep 3',
+        source: :tool,
+        shape: :timeout
+      )
+      second = described_class.timeout_lesson(tool: 'shell', payload: 'sleep 3', timeout: 1)
+      expect(second[:scenario]).to eq(:deadline)
+      expect(second[:hint]).to match(/timeout was too short|deadline too short|raise a conservative/i)
+      expect(second[:error]).to match(/too short/)
+    end
+  end
 end

data/spec/lib/pwn/ai/agent/tools/ruby_eval_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'json'
+require 'tmpdir'
 
 describe 'PWN::AI::Agent::Tools ruby_eval' do
   before(:all) do
@@ -29,6 +30,29 @@ describe 'PWN::AI::Agent::Tools ruby_eval' do
     expect(result[:value]).to eq('2')
   end
 
+  it 'keeps locals across pwn_eval calls so a browser_obj can be reused' do
+    entry = PWN::AI::Agent::Registry.lookup(name: 'pwn_eval')
+    first = entry.handler.call(code: 'pwn_eval_persist_probe = 41')
+    expect(first[:error]).to be_nil
+    second = entry.handler.call(code: 'pwn_eval_persist_probe + 1')
+    expect(second[:error]).to be_nil
+    expect(second[:value]).to eq('42')
+  end
+
+  it 'enforces a timeout on pwn_eval and reports timeout after Ns' do
+    tmp = Dir.mktmpdir
+    stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+    entry = PWN::AI::Agent::Registry.lookup(name: 'pwn_eval')
+    schema = entry.schema
+    expect(schema.dig(:parameters, :properties, :timeout)).not_to be_nil
+    t0 = Time.now
+    result = entry.handler.call(code: 'sleep 3', timeout: 1)
+    expect(Time.now - t0).to be < 2.5
+    expect(result[:error].to_s).to match(/timeout after 1s/)
+    expect(result[:hint].to_s).to match(/reconstruct|generated differently|improperly/i)
+    expect(result[:scenario].to_s).to eq('construction')
+  end
+
   it 'Dispatch.call JSON-wraps syntax errors instead of raising' do
     out = PWN::AI::Agent::Dispatch.call(
       tool_call: {

data/spec/lib/pwn/ai/agent/tools/shell_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tmpdir'
 
 describe 'PWN::AI::Agent::Tools shell' do
   before(:all) do
@@ -58,4 +59,13 @@ describe 'PWN::AI::Agent::Tools shell' do
     expect(r[:error]).not_to eq('unauthorized_recon_blocked')
     expect(r[:exit]).to eq(0)
   end
+
+  it 'on timeout prefers reconstruct-the-command before raising timeout' do
+    tmp = Dir.mktmpdir
+    stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+    r = handler.call(command: 'sleep 3', timeout: 1)
+    expect(r[:error].to_s).to match(/timeout after 1s/)
+    expect(r[:hint].to_s).to match(/reconstruct|generated differently|improperly/i)
+    expect(r[:scenario].to_s).to eq('construction')
+  end
 end

data/spec/lib/pwn/ai/agent/tools/skills_spec.rb

@@ -14,6 +14,10 @@ describe 'PWN::AI::Agent::Tools skills' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'skills_recall')).not_to be_nil
   end
 
+  it 'registers the skills_update tool' do
+    expect(PWN::AI::Agent::Registry.lookup(name: 'skills_update')).not_to be_nil
+  end
+
   it 'registers the skill_migrate_legacy tool' do
     expect(PWN::AI::Agent::Registry.lookup(name: 'skill_migrate_legacy')).not_to be_nil
   end
@@ -37,6 +41,7 @@ describe 'PWN::AI::Agent::Tools skills' do
     let(:list)   { PWN::AI::Agent::Registry.lookup(name: 'skill_list')[:handler] }
     let(:view)   { PWN::AI::Agent::Registry.lookup(name: 'skill_view')[:handler] }
     let(:recall) { PWN::AI::Agent::Registry.lookup(name: 'skills_recall')[:handler] }
+    let(:update) { PWN::AI::Agent::Registry.lookup(name: 'skills_update')[:handler] }
 
     it 'skills_recall ranks matching skills by query and skips non-matches' do
       create.call(name: 'browser-dump', description: 'Dump links via TransparentBrowser.', content: "open once, dump_links, close once\n")
@@ -49,6 +54,30 @@ describe 'PWN::AI::Agent::Tools skills' do
       expect(names).not_to include('unrelated')
     end
 
+    it 'skills_recall with no query returns the bundled catalog, not a mixed dump' do
+      create.call(name: 'osint', description: 'Drive extro_osint.', content: "osint body\n")
+      create.call(name: 'third-party-dump', description: 'Not the pwn-ai catalog.', content: "dump\n")
+      hits = recall.call(query: '', limit: 50)
+      expect(hits).to be_a(Hash)
+      names = Array(hits[:catalog]).map { |h| h[:name].to_s }
+      expect(names).to include('osint')
+      expect(names).not_to include('third-party-dump')
+      expect(hits[:other_installed].to_i).to be >= 1
+    end
+
+    it 'skills_update folds an RL lesson into an existing skill without creating one' do
+      create.call(name: 'osint', description: 'Drive extro_osint.', content: "# OSINT\nCollect from public sources.\n")
+      out = update.call(name: 'osint', lesson: 'Prefer sitemap.xml over infinite scroll for Wix blogs.')
+      expect(out[:updated]).to eq true
+      body = File.read(out[:path])
+      expect(body).to include('## RL feedback')
+      expect(body).to include('Prefer sitemap.xml over infinite scroll')
+      expect(body).to include('Collect from public sources')
+      again = update.call(name: 'osint', lesson: 'Prefer sitemap.xml over infinite scroll for Wix blogs.')
+      expect(again[:updated]).to eq false
+      expect(again[:reason]).to eq('already folded')
+    end
+
     it 'skill_create writes <name>/SKILL.md with required name+description frontmatter' do
       out = create.call(name: 'Recon Quick_Scan', description: 'Fast host triage.', content: "# Recon\nnmap -T4 -F {t}\n", references: ['T1046'])
       expect(out[:saved]).to be true

data/spec/lib/pwn/ai/grok_spec.rb

@@ -45,4 +45,26 @@ describe PWN::AI::Grok do
     expect(src).to include('PWN::Plugins::TTYSpinner.stop(spin: spin)')
     expect(src).not_to match(/spin\.stop if spinner/)
   end
+
+  it 'does not nil+ on 429 without Retry-After and does not retry 429 forever' do
+    src = File.read(described_class.method(:chat_with_tools).source_location.first)
+    expect(src).not_to match(/headers\[:retry_after\]&.to_i\s*\|\|=/)
+    expect(src).to match(/HttpRetry\.retry_after_s|headers\[:retry_after\]\.to_i/)
+    expect(src).to match(/HttpRetry\.max_attempts|max_attempts/)
+  end
+
+  it 'defaults chat REST timeout to 180s and retries ReadTimeout up to 5 times' do
+    src = File.read(described_class.method(:chat_with_tools).source_location.first)
+    expect(src).to match(/HttpRetry|timeout \|\|= 180/)
+    expect(src).not_to match(/timeout \|\|= 900/)
+    expect(src).to match(/HttpRetry\.max_attempts|max_attempts/)
+    inner = src[/retry_count = 0.*?rescue RestClient::Exceptions::Timeout/m]
+    expect(inner).to include('TooManyRequests')
+    expect(inner).to include('Exceptions::Timeout')
+  end
+
+  it 'tees grok timeout/429 warnings into the debug request log' do
+    src = File.read(described_class.method(:chat_with_tools).source_location.first)
+    expect(src).to match(/HttpRetry\.report_event|Log\.progress/)
+  end
 end

data/spec/lib/pwn/ai/http_retry_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'stringio'
+
+describe PWN::AI::HttpRetry do
+  it 'defaults timeout to 180 and max_attempts to 5' do
+    expect(described_class.timeout_s).to eq(180)
+    expect(described_class.timeout_s(timeout: nil)).to eq(180)
+    expect(described_class.timeout_s(timeout: 60)).to eq(60)
+    expect(described_class.max_attempts).to eq(5)
+    expect(described_class.max_attempts(quiet: true)).to eq(1)
+    expect(described_class.max_attempts(timeout: 12)).to eq(1)
+    expect(described_class.max_attempts(max_attempts: 3)).to eq(3)
+  end
+
+  it 'tees emit lines into the open debug request log' do
+    path = PWN::Plugins::Log.start_debug(
+      tee: StringIO.new,
+      path: "/tmp/pwn-ai-DEBUG-#{Process.pid}-httpretry.log"
+    )
+    err = RestClient::Exceptions::ReadTimeout.new('Timed out reading data from server')
+    described_class.report_event(
+      label: 'openai',
+      error: err,
+      http_method: :post,
+      rest_call: 'chat/completions',
+      extra: 'timeout=180s attempt=1/5',
+      quiet: true
+    )
+    body = File.read(path)
+    expect(body).to include('[pwn-ai/openai]')
+    expect(body).to include('Timed out reading data from server')
+    expect(body).to include('timeout=180s')
+  ensure
+    PWN::Plugins::Log.stop_debug if defined?(PWN::Plugins::Log)
+  end
+
+  {
+    'PWN::AI::Grok' => '/opt/pwn/lib/pwn/ai/grok.rb',
+    'PWN::AI::OpenAI' => '/opt/pwn/lib/pwn/ai/open_ai.rb',
+    'PWN::AI::Anthropic' => '/opt/pwn/lib/pwn/ai/anthropic.rb',
+    'PWN::AI::Gemini' => '/opt/pwn/lib/pwn/ai/gemini.rb',
+    'PWN::AI::Ollama' => '/opt/pwn/lib/pwn/ai/ollama.rb',
+    'PWN::AI::OpenWebUI' => '/opt/pwn/lib/pwn/ai/open_web_ui.rb'
+  }.each do |name, path|
+    it "#{name} uses HttpRetry 180s / max_attempts and retries ReadTimeout" do
+      src = File.read(path)
+      expect(src).to include('HttpRetry')
+      expect(src).not_to match(/timeout \|\|= 900/)
+      expect(src).to match(/Exceptions::Timeout/)
+      expect(src).to match(/HttpRetry\.report_event/)
+    end
+  end
+end