pwn 0.5.704 → 0.5.706

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bd3437e2c7ee97e783659b63d69dd21368ce47a284c29f97b6d8ddd64631134
-  data.tar.gz: 9e71c1bbabee3abd02f3d4f252fa1eed48854f2c2379b2df914515ed2a593775
+  metadata.gz: f9233042c1c9518d8cfdcbfe6499eb521cb0348384554e03ab6641abdda253b9
+  data.tar.gz: 51b81fd36f292bc54e762d4bb47f5641c9b263addf9f37997aaa4c2f6a00c49f
 SHA512:
-  metadata.gz: ffb5ae45ac796c161ab9fa29816c823e1f937404f845a23bf3757d412f82a5ccbe950d93bfe6b1771af1ee8ffefd9b8374fbda07024bec7278195c969a04f0be
-  data.tar.gz: 649a698b9da06319331c4d3289c603c0907e763f6a4a2a508f6c1a97426a969483fea38766002dbf364830a574cc0b5012d44ae8ea1881303c61acae4eb427b7
+  metadata.gz: 370d8b9305f7dcd2a692061b6708feca282546109533131d244cd97d207d1b216afac16baf44847a8a098c9847467208dd30e81084729f79ee7e3c16c050ae32
+  data.tar.gz: 97725299f78baef12d73614b7258ebf5cc3664316c82d2bf53d6a82e3d9e0e0d2542a3143cbc686fc75b46b6883fb8edc0174cfd38ce74b88a0c908ab4864642

data/Gemfile

@@ -89,8 +89,8 @@ gem 'ruby-nmap', '1.0.3'
 gem 'ruby-saml', '1.18.1'
 gem 'rvm', '1.11.3.9'
 gem 'savon', '2.17.4'
-gem 'selenium-devtools', '0.151.0'
-gem 'selenium-webdriver', '4.47.0'
+gem 'selenium-devtools', '0.152.0'
+gem 'selenium-webdriver', '4.48.0'
 gem 'slack-ruby-client', '3.2.0'
 gem 'socksify', '1.8.1'
 gem 'spreadsheet', '1.3.5'

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

@@ -584,6 +584,10 @@ module PWN
           live = effects.reject { |fx| %i[recall store].include?(fx) }
           return true if live.empty?
           return true if duration_unsatisfied?(request: request)
+          return true if declared_contract_unsatisfied?(
+            request: request,
+            messages: opts[:messages]
+          )
           return true if need == :write && !write_verified?(effects: effects)
           return true if need == :browse && !effects.include?(:browse)
           return true if need == :any && !effects.intersect?(%i[write browse eval])
@@ -613,23 +617,157 @@ module PWN
         }.freeze
 
         private_class_method def self.duration_unsatisfied?(opts = {})
-          req = opts[:request].to_s
-          hours = nil
-          if (m = req.match(/\b(\d+)\s*(?:hours?|hrs?)\b/i))
-            hours = m[1].to_i
-          elsif (m = req.match(/\b(twenty-four|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*(?:hours?|hrs?)\b/i))
-            hours = HOUR_WORDS[m[1].downcase]
+          secs = declared_min_seconds(request: opts[:request])
+          if secs <= 0
+            req = opts[:request].to_s
+            hours = nil
+            if (m = req.match(/\b(\d+)\s*(?:hours?|hrs?)\b/i))
+              hours = m[1].to_i
+            elsif (m = req.match(/\b(twenty-four|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*(?:hours?|hrs?)\b/i))
+              hours = HOUR_WORDS[m[1].downcase]
+            end
+            secs = hours.to_i * 3600
           end
-          return false if hours.to_i <= 0
+          return false if secs <= 0
 
           t0 = Thread.current[:pwn_loop_t0]
           return false unless t0
 
-          (Time.now - t0) < (hours * 3600)
+          (Time.now - t0) < secs
+        rescue StandardError
+          false
+        end
+
+        EMPTY_CONTRACT = {
+          paths: [],
+          min_seconds: 0,
+          skills: [],
+          proofs: [],
+          hosts: []
+        }.freeze
+
+        private_class_method def self.declared_min_seconds(opts = {})
+          declared_contract(request: opts[:request])[:min_seconds].to_i
+        end
+
+        private_class_method def self.declared_contract_unsatisfied?(opts = {})
+          contract = declared_contract(request: opts[:request])
+          files = Array(contract[:paths]) + Array(contract[:proofs])
+          return true if files.any? { |path| deliverable_missing?(path: path) }
+          return true if declared_skills_missing?(skills: contract[:skills])
+          return true if declared_hosts_missing?(hosts: contract[:hosts], messages: opts[:messages])
+
+          false
         rescue StandardError
           false
         end
 
+        private_class_method def self.declared_skills_missing?(opts = {})
+          names = Array(opts[:skills]).map(&:to_s).reject(&:empty?)
+          return false if names.empty?
+          return true unless defined?(PWN::Skills) && PWN::Skills.is_a?(Hash)
+
+          have = PWN::Skills.keys.map(&:to_s)
+          names.any? { |name| !have.include?(name) }
+        end
+
+        private_class_method def self.declared_hosts_missing?(opts = {})
+          hosts = Array(opts[:hosts]).map(&:to_s).reject(&:empty?)
+          return false if hosts.empty?
+
+          blob = Array(opts[:messages]).select { |msg| msg.is_a?(Hash) && msg[:role].to_s == 'tool' }
+                                       .map { |msg| msg[:content].to_s }
+                                       .join("\n")
+                                       .downcase
+          hosts.any? { |host| !blob.include?(host.to_s.downcase) }
+        end
+
+        private_class_method def self.declared_deliverables(opts = {})
+          Array(declared_contract(request: opts[:request])[:paths])
+        end
+
+        private_class_method def self.declared_contract(opts = {})
+          cached = Thread.current[:pwn_loop_deliverables]
+          return normalize_contract(raw: cached) if cached.is_a?(Array) || cached.is_a?(Hash)
+          return EMPTY_CONTRACT.dup unless Thread.current[:pwn_loop_active]
+
+          contract = infer_deliverables(request: opts[:request])
+          Thread.current[:pwn_loop_deliverables] = contract
+          contract
+        end
+
+        private_class_method def self.normalize_contract(opts = {})
+          raw = opts[:raw]
+          return EMPTY_CONTRACT.merge(paths: raw.map(&:to_s).select { |p| p.start_with?('/') }) if raw.is_a?(Array)
+          return EMPTY_CONTRACT.dup unless raw.is_a?(Hash)
+
+          hours = raw[:hours] || raw['hours']
+          secs = (raw[:min_seconds] || raw['min_seconds']).to_i
+          secs = hours.to_i * 3600 if secs <= 0 && hours.to_i.positive?
+          {
+            paths: abs_paths(rows: raw[:paths] || raw['paths']),
+            min_seconds: secs,
+            skills: Array(raw[:skills] || raw['skills']).map(&:to_s).reject(&:empty?).uniq,
+            proofs: abs_paths(rows: raw[:proofs] || raw['proofs']),
+            hosts: Array(raw[:hosts] || raw['hosts']).map(&:to_s).reject(&:empty?).uniq
+          }
+        end
+
+        private_class_method def self.abs_paths(opts = {})
+          Array(opts[:rows]).map(&:to_s).select { |path| path.start_with?('/') }.uniq
+        end
+
+        private_class_method def self.infer_deliverables(opts = {})
+          request = opts[:request].to_s
+          return EMPTY_CONTRACT.dup if request.strip.empty?
+
+          reply = call_engine(
+            messages: [
+              {
+                role: 'system',
+                content: 'Reply with JSON only. No markdown. No tools.'
+              },
+              {
+                role: 'user',
+                content: "Operator request:\n#{request}\n\n" \
+                         'When that request is complete, what must be true on this host? ' \
+                         'JSON only: {"paths":["/abs/file"],"min_seconds":0,"skills":["name"],' \
+                         '"proofs":["/abs/poc"],"hosts":["ip-or-hostname"]}. ' \
+                         'Use [] or 0 when a field is not required. Do not invent work. Paths must be absolute.'
+              }
+            ],
+            tools: nil
+          )
+          text = reply.is_a?(Hash) ? (reply[:content] || reply['content']).to_s : reply.to_s
+          parse_contract(text: text)
+        rescue StandardError
+          EMPTY_CONTRACT.dup
+        end
+
+        private_class_method def self.parse_contract(opts = {})
+          text = opts[:text].to_s
+          json = nil
+          begin
+            json = JSON.parse(text, symbolize_names: true)
+          rescue JSON::ParserError
+            start = text.index('{')
+            stop = text.rindex('}')
+            return EMPTY_CONTRACT.dup unless start && stop && stop > start
+
+            json = JSON.parse(text[start..stop], symbolize_names: true)
+          end
+          normalize_contract(raw: json)
+        rescue StandardError
+          EMPTY_CONTRACT.dup
+        end
+
+        private_class_method def self.deliverable_missing?(opts = {})
+          path = opts[:path].to_s
+          path.empty? || !File.file?(path) || File.size(path) <= 0
+        rescue StandardError
+          true
+        end
+
         private_class_method def self.may_finalize?(opts = {})
           return false if incomplete_final?(text: opts[:text], last_iter: false)
           return false if request_unsatisfied?(
@@ -2434,6 +2572,10 @@ module PWN
           Thread.current[:pwn_extinguished] = {}
           Thread.current[:pwn_same_payload] = Hash.new(0)
           Thread.current[:pwn_loop_t0] = Time.now unless nested
+          unless nested
+            Thread.current[:pwn_loop_active] = true
+            Thread.current[:pwn_loop_deliverables] = nil
+          end
           debug_progress(msg: "intent=#{intent} engine=#{engine}", debug: opts[:debug])
           expose_current_session(session_id: session_id)
           Mistakes.check_user_correction(request: request, session_id: session_id) if defined?(Mistakes)
@@ -2672,12 +2814,20 @@ module PWN
             # commit that as the answer; drop the empty assistant turn,
             # inject a one-shot nudge, and keep iterating.
             if calls.empty? && text.strip.empty?
+              unsat = request_unsatisfied?(request: request, messages: messages)
               warn "[pwn-ai/loop] empty final from #{engine} on iter=#{i}; nudging" if local
+              empty_nudge = if unsat
+                              'Your previous reply was empty (no tool_calls and no content). ' \
+                                'The original request is not evidenced yet. Emit NATIVE tool_calls NOW. ' \
+                                'Do not write a final answer until that request is done or a tool returned failure evidence.'
+                            else
+                              'Your previous reply was empty (no tool_calls and no content). ' \
+                                'Either call a tool now, or write the final answer for the user as plain text. ' \
+                                'Do not reply with an empty message.'
+                            end
               messages << {
                 role: 'user',
-                content: 'Your previous reply was empty (no tool_calls and no content). ' \
-                         'Either call a tool now, or write the final answer for the user as plain text. ' \
-                         'Do not reply with an empty message.'
+                content: empty_nudge
               }
               turn_fails['empty_final'] += 1
               debug_progress(msg: "bounce empty_final snippet=#{debug_snippet(text: text)}")
@@ -2830,6 +2980,10 @@ module PWN
           end
           raise
         ensure
+          unless nested
+            Thread.current[:pwn_loop_active] = nil
+            Thread.current[:pwn_loop_deliverables] = nil
+          end
           Thread.current[:pwn_loop_no_tools] = nil
           finish_debug_request!(
             iter: i,

data/lib/pwn/config.rb

@@ -819,27 +819,12 @@ module PWN
     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
-      cwe
-      capec
-      att&ck
-    ].freeze
 
     public_class_method def self.default_skill_names(opts = {})
-      return DEFAULT_SKILL_NAMES.dup if opts.is_a?(Hash)
-
-      DEFAULT_SKILL_NAMES.dup
+      root = opts[:source] || opts[:root] || default_skills_dir
+      names = []
+      each_skill_md(root: root) { |_path, rel_dir| names << rel_dir }
+      names.sort
     end
 
     public_class_method def self.default_skills_dir(opts = {})

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.704'
+  VERSION = '0.5.706'
 end

data/spec/integration/config_spec.rb

@@ -71,7 +71,7 @@ RSpec.describe 'PWN::Config / etc/*.EXAMPLE hygiene', :aggregate_failures do
       expect(PWN::Config).to respond_to(:install_default_skills)
       expect(PWN::Config).to respond_to(:default_skill_names)
       names = PWN::Config.default_skill_names
-      expect(names).to eq %w[
+      sops = %w[
         vulnerability-research-fundamentals
         deep-exploitation
         bug-bounty-hunting
@@ -87,9 +87,16 @@ RSpec.describe 'PWN::Config / etc/*.EXAMPLE hygiene', :aggregate_failures do
         capec
         att&ck
       ]
+      expect(names).to include(*sops)
+      expect(names).to include('pwn/www/youtube')
+      expect(names).to include('pwn/plugins/google_workspace')
+      expect(names.none? { |n| n.include?('/references/') }).to eq(true)
+      expect(names).to eq(names.sort)
+      expect(names.length).to be > sops.length
+      sop_seeded = names.reject { |n| n == 'pwn' || n.start_with?('pwn/') }
       seeded = PWN::Config.install_default_skills(pwn_skills_path: dir)
-      expect(seeded.map { |r| r[:name] }).to match_array(names)
-      names.each do |name|
+      expect(seeded.map { |r| r[:name] }).to match_array(sop_seeded)
+      sops.each do |name|
         path = File.join(dir, name, 'SKILL.md')
         expect(File.file?(path)).to eq(true), path
         body = File.read(path)
@@ -157,4 +164,18 @@ RSpec.describe 'PWN::Config / etc/*.EXAMPLE hygiene', :aggregate_failures do
       PWN.const_set(:Skills, prev.freeze) if prev
     end
   end
+
+  it 'default_skill_names recursively lists SKILL.md dirs under the default_skills tree' do
+    Dir.mktmpdir('pwn_skill_names') do |dir|
+      FileUtils.mkdir_p(File.join(dir, 'research', 'nested-probe'))
+      File.write(File.join(dir, 'research', 'nested-probe', 'SKILL.md'), "# nested\n")
+      FileUtils.mkdir_p(File.join(dir, 'osint'))
+      File.write(File.join(dir, 'osint', 'SKILL.md'), "# osint\n")
+      FileUtils.mkdir_p(File.join(dir, 'osint', 'references'))
+      File.write(File.join(dir, 'osint', 'references', 'note.md'), "# note\n")
+      FileUtils.mkdir_p(File.join(dir, 'empty-dir'))
+      names = PWN::Config.default_skill_names(source: dir)
+      expect(names).to eq(%w[osint research/nested-probe])
+    end
+  end
 end

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

@@ -910,6 +910,113 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       Thread.current[:pwn_loop_t0] = nil
     end
 
+    it 'keeps LLM-declared deliverable paths unsatisfied until those files exist' do
+      path = "/tmp/pwn-deliv-#{Process.pid}.bin"
+      FileUtils.rm_f(path)
+      Thread.current[:pwn_loop_deliverables] = [path]
+      req = 'Exhaustively analyze the docker app. 100% coverage. Store the PDF in /tmp/container_pentest-p4-PWN-122B.pdf'
+      recap = 'Good! Let me continue the penetration test with more aggressive testing now.'
+      msgs = [
+        { role: 'user', content: req },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'pwn_eval', arguments: '{"code":"File.write(\"/tmp/pentest_report.json\",\"x\")"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'pwn_eval',
+          content: '{"success":true,"result":{"stdout":"Report saved to /tmp/pentest_report.json"},"effect":"write"}'
+        },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'shell', arguments: '{"command":"curl -s http://127.0.0.1:5000/auth/login"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'shell',
+          content: '{"success":true,"result":{"stdout":"<form>"},"effect":"read"}'
+        },
+        { role: 'assistant', content: recap }
+      ]
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      expect(described_class.send(:may_finalize?, request: req, messages: msgs, text: recap)).to eq(false)
+      File.write(path, 'any bytes')
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(false)
+    ensure
+      FileUtils.rm_f(path)
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
+    it 'parses a full acceptance contract from one engine JSON hop' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).not_to match(/NAMED_PATH_RX/)
+      expect(src).not_to include('%PDF')
+      expect(src).to match(/infer_deliverables|pwn_loop_deliverables/)
+      payload = {
+        paths: ['/tmp/out.json'],
+        min_seconds: 28_800,
+        skills: ['penetration-testing'],
+        proofs: ['/tmp/poc.sh'],
+        hosts: ['127.0.0.1']
+      }
+      allow(described_class).to receive(:call_engine).and_return(payload.to_json)
+      Thread.current[:pwn_loop_active] = true
+      Thread.current[:pwn_loop_deliverables] = nil
+      paths = described_class.send(:declared_deliverables, request: 'write a report somewhere')
+      expect(paths).to eq(['/tmp/out.json'])
+      contract = described_class.send(:declared_contract, request: 'write a report somewhere')
+      expect(contract[:min_seconds]).to eq(28_800)
+      expect(contract[:skills]).to eq(['penetration-testing'])
+      expect(contract[:proofs]).to eq(['/tmp/poc.sh'])
+      expect(contract[:hosts]).to eq(['127.0.0.1'])
+      expect(described_class).to have_received(:call_engine).once
+    ensure
+      Thread.current[:pwn_loop_active] = nil
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
+    it 'verifies LLM-declared duration, skills, proofs, and hosts in the world' do
+      proof = "/tmp/pwn-proof-#{Process.pid}.txt"
+      FileUtils.rm_f(proof)
+      req = 'black-box test 127.0.0.1 using penetration-testing'
+      recap = 'done'
+      msgs = [
+        { role: 'user', content: req },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'pwn_eval', arguments: '{"code":"1"}' } }]
+        },
+        {
+          role: 'tool',
+          name: 'pwn_eval',
+          content: '{"success":true,"result":{"value":"1","stdout":"scanned 10.0.0.1"},"effect":"eval"}'
+        },
+        { role: 'assistant', content: recap }
+      ]
+      Thread.current[:pwn_loop_t0] = Time.now
+      Thread.current[:pwn_loop_deliverables] = {
+        paths: [],
+        min_seconds: 60,
+        skills: ['no-such-bundled-skill'],
+        proofs: [proof],
+        hosts: ['127.0.0.1']
+      }
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      Thread.current[:pwn_loop_deliverables][:min_seconds] = 0
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      Thread.current[:pwn_loop_deliverables][:skills] = []
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      File.write(proof, 'poc')
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      msgs[2][:content] = '{"success":true,"result":{"value":"1","stdout":"open 127.0.0.1:5000"},"effect":"eval"}'
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(false)
+      expect(described_class.send(:may_finalize?, request: req, messages: msgs, text: recap)).to eq(true)
+    ensure
+      FileUtils.rm_f(proof)
+      Thread.current[:pwn_loop_t0] = nil
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
     it 'forces tool_choice required on host-work before any tool result, for every engine' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/tool_choice/)

data/third_party/pwn_rdoc.jsonl

@@ -309,6 +309,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.update_skill Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.update_skill`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.verdict_for_score Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.verdict_for_score`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Learning.weighted_judge_mean Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Learning.weighted_judge_mean`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.abs_paths Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.abs_paths`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.active_engine Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.active_engine`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.agent_flag Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.agent_flag`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.answer_greeting Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.answer_greeting`: "}]}
@@ -335,8 +336,15 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.debug_snippet Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.debug_snippet`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.debug_tool_io! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.debug_tool_io!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.debug_tools_line Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.debug_tools_line`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_contract Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_contract`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_contract_unsatisfied? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_contract_unsatisfied?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_deliverables Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_deliverables`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_hosts_missing? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_hosts_missing?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_min_seconds Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_min_seconds`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.declared_skills_missing? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.declared_skills_missing?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.default_interactive_toolsets Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.default_interactive_toolsets`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.degrade_text_only Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.degrade_text_only`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.deliverable_missing? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.deliverable_missing?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.dispatch_fail_n Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.dispatch_fail_n`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.duration_unsatisfied? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.duration_unsatisfied?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.emit_task_summary Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.emit_task_summary`: "}]}
@@ -349,6 +357,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.guard_repeated_failure Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.guard_repeated_failure`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.incomplete_final? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.incomplete_final?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.infer_deliverables Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.infer_deliverables`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.inject_task_focus! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.inject_task_focus!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.local_engine? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.local_engine?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.loud_debug_tui! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.loud_debug_tui!`: "}]}
@@ -361,12 +370,14 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.mistake_ts Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.mistake_ts`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.needs_host_work? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.needs_host_work?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.no_progress_result Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.no_progress_result`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.normalize_contract Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.normalize_contract`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.normalize_llm Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.normalize_llm`: Supported Method Parameters\n\nmsg = PWN::AI::Agent::Loop.normalize_llm(\n\nresponse: 'required - chat_with_tools response Hash from any provider'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.note_same_payload! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.note_same_payload!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.ollama_wire_messages Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.ollama_wire_messages`: Supported Method Parameters\n\nwire = PWN::AI::Agent::Loop.ollama_wire_messages(\n\nmessages: 'required - in-memory OpenAI-ish messages (may have String args)'\n\n)\n\nReturns a deep-copied array safe for Ollama / Open WebUI ollama/api/chat:\n\nparses JSON-string function.arguments into Hash/Array objects\n\ncoerces nil assistant content to ” when tool_calls present (Open WebUI GenerateChatCompletionForm rejects content:null alone)\n\ndrops _native_content / _text_tool_coerced / thinking private keys\n\nstringifies Hash/Array message content (tool results) to JSON text\n\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.ollama_wire_tool_call Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.ollama_wire_tool_call`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.openai_wire_messages Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.openai_wire_messages`: Supported Method Parameters\n\nwire = PWN::AI::Agent::Loop.openai_wire_messages(\n\nmessages: 'required - in-memory OpenAI-ish messages (may have Hash args / internal keys)'\n\n)\n\nReturns a deep-copied array safe for OpenAI / xAI chat.completions:\n\ndrops _native_content / _text_tool_coerced / thinking private keys\n\nstringifies function.arguments maps\n\ncoerces Hash/non-string content to JSON/string (nil kept for assistant tool turns)\n\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.openai_wire_tool_call Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.openai_wire_tool_call`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.parse_contract Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.parse_contract`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.parse_tool_arguments Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.parse_tool_arguments`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.payload_sig Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.payload_sig`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.plan_first Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.plan_first`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.704
+  version: 0.5.706
 platform: ruby
 authors:
 - 0day Inc.
@@ -1051,28 +1051,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.151.0
+        version: 0.152.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.151.0
+        version: 0.152.0
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.47.0
+        version: 4.48.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.47.0
+        version: 4.48.0
 - !ruby/object:Gem::Dependency
   name: slack-ruby-client
   requirement: !ruby/object:Gem::Requirement