pwn 0.5.705 → 0.5.707

data/lib/pwn/reports/html.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module PWN
+  module Reports
+    # Generic HTML report writer for pentest / findings payloads.
+    module HTML
+      public_class_method def self.generate(opts = {})
+        out = PWN::Reports.resolve_path(opts.merge(ext: 'html'))
+        payload = PWN::Reports.report_payload(opts)
+        rows = payload[:findings].map do |row|
+          "<tr><td>#{h(text: row['id'])}</td><td>#{h(text: row['title'])}</td><td>#{h(text: row['severity'])}</td><td>#{h(text: row['cvss'])}</td><td>#{h(text: row['description'])}</td><td>#{h(text: row['poc'])}</td><td>#{h(text: row['recommendation'])}</td></tr>"
+        end
+        body = <<~HTML
+          <!DOCTYPE html>
+          <html lang="en">
+          <head>
+            <meta charset="utf-8">
+            <title>#{h(text: payload[:title])}</title>
+          </head>
+          <body>
+            <h1>#{h(text: payload[:title])}</h1>
+            #{summary_html(text: payload[:executive_summary])}
+            <table>
+              <thead>
+                <tr><th>id</th><th>title</th><th>severity</th><th>cvss</th><th>description</th><th>poc</th><th>recommendation</th></tr>
+              </thead>
+              <tbody>
+                #{rows.join("\n")}
+              </tbody>
+            </table>
+          </body>
+          </html>
+        HTML
+        File.write(out, body)
+        out
+      end
+
+      private_class_method def self.summary_html(opts = {})
+        text = opts[:text].to_s
+        return if text.empty?
+
+        "<p>#{h(text: text)}</p>"
+      end
+
+      private_class_method def self.h(opts = {})
+        opts[:text].to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:\n  #{self}.generate(\n    path: '/tmp/report.html',\n    results_hash: {}\n  )\n\n  #{self}.authors\n"
+      end
+    end
+  end
+end

data/lib/pwn/reports/json.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PWN
+  module Reports
+    # Generic JSON report writer for pentest / findings payloads.
+    module JSON
+      public_class_method def self.generate(opts = {})
+        out = PWN::Reports.resolve_path(opts.merge(ext: 'json'))
+        payload = PWN::Reports.report_payload(opts)
+        File.write(
+          out,
+          ::JSON.pretty_generate(
+            'title' => payload[:title],
+            'executive_summary' => payload[:executive_summary],
+            'findings' => payload[:findings]
+          )
+        )
+        out
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:\n  #{self}.generate(\n    path: '/tmp/report.json',\n    results_hash: {}\n  )\n\n  #{self}.authors\n"
+      end
+    end
+  end
+end

data/lib/pwn/reports/markdown.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module PWN
+  module Reports
+    # Generic Markdown report writer for pentest / findings payloads.
+    module Markdown
+      public_class_method def self.generate(opts = {})
+        out = PWN::Reports.resolve_path(opts.merge(ext: 'md'))
+        payload = PWN::Reports.report_payload(opts)
+        lines = ["# #{payload[:title]}", '']
+        lines += ['## Executive summary', '', payload[:executive_summary].to_s, ''] unless payload[:executive_summary].to_s.empty?
+        lines += ['## Findings', '']
+        if payload[:findings].empty?
+          lines << '_No findings._'
+        else
+          payload[:findings].each do |row|
+            lines << "### #{row['id'].to_s.empty? ? row['title'] : "#{row['id']}: #{row['title']}"}"
+            lines << ''
+            row.each do |key, val|
+              next if %w[id title].include?(key.to_s)
+
+              lines << "- **#{key}**: #{val}"
+            end
+            lines << ''
+          end
+        end
+        File.write(out, "#{lines.join("\n").rstrip}\n")
+        out
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:\n  #{self}.generate(\n    path: '/tmp/report.md',\n    results_hash: {}\n  )\n\n  #{self}.authors\n"
+      end
+    end
+  end
+end

data/lib/pwn/reports/pdf.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module PWN
+  module Reports
+    # Generic PDF report writer for pentest / findings payloads.
+    # Emits a minimal PDF 1.4 document (no wkhtmltopdf).
+    module PDF
+      public_class_method def self.generate(opts = {})
+        out = PWN::Reports.resolve_path(opts.merge(ext: 'pdf'))
+        payload = PWN::Reports.report_payload(opts)
+        File.binwrite(out, render_pdf(payload: payload))
+        out
+      end
+
+      private_class_method def self.render_pdf(opts = {})
+        payload = opts[:payload]
+        lines = [payload[:title].to_s]
+        lines << ''
+        unless payload[:executive_summary].to_s.empty?
+          lines << 'Executive summary'
+          lines.concat(wrap_line(text: payload[:executive_summary].to_s))
+          lines << ''
+        end
+        payload[:findings].each do |row|
+          heading = [row['id'], row['title']].compact.map(&:to_s).reject(&:empty?).join(': ')
+          lines.concat(wrap_line(text: heading))
+          row.each do |key, val|
+            next if %w[id title].include?(key.to_s)
+
+            lines.concat(wrap_line(text: "#{key}: #{val}"))
+          end
+          lines << ''
+        end
+        content = pdf_stream(lines: lines)
+        objects = [
+          '<< /Type /Catalog /Pages 2 0 R >>',
+          '<< /Type /Pages /Kids [3 0 R] /Count 1 >>',
+          '<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R /Resources << /Font << /F1 5 0 R >> >> >>',
+          "<< /Length #{content.bytesize} >>\nstream\n#{content}\nendstream",
+          '<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>'
+        ]
+        assemble_pdf(objects: objects)
+      end
+
+      private_class_method def self.pdf_stream(opts = {})
+        lines = Array(opts[:lines])
+        chunks = ['BT', '/F1 11 Tf', '72 720 Td']
+        lines.each_with_index do |line, idx|
+          chunks << '0 -14 Td' unless idx.zero?
+          chunks << "(#{pdf_escape(text: line)}) Tj"
+        end
+        chunks << 'ET'
+        "#{chunks.join("\n")}\n"
+      end
+
+      private_class_method def self.pdf_escape(opts = {})
+        opts[:text].to_s.encode('UTF-8', invalid: :replace, undef: :replace).gsub('\\', '\\\\').gsub('(', '\\(').gsub(')', '\\)')
+      end
+
+      private_class_method def self.wrap_line(opts = {})
+        text = opts[:text].to_s.tr("\r", '')
+        return [''] if text.empty?
+
+        text.scan(/.{1,90}(?:\s+|$)|.{1,90}/).map(&:strip)
+      end
+
+      private_class_method def self.assemble_pdf(opts = {})
+        objects = Array(opts[:objects])
+        out = +"%PDF-1.4\n"
+        offsets = [0]
+        objects.each_with_index do |body, idx|
+          offsets << out.bytesize
+          out << "#{idx + 1} 0 obj\n#{body}\nendobj\n"
+        end
+        xref_at = out.bytesize
+        out << "xref\n0 #{objects.length + 1}\n"
+        out << "0000000000 65535 f \n"
+        offsets[1..].each { |off| out << format("%010d 00000 n \n", off) }
+        out << "trailer\n<< /Size #{objects.length + 1} /Root 1 0 R >>\n"
+        out << "startxref\n#{xref_at}\n%%EOF\n"
+        out
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:\n  #{self}.generate(\n    path: '/tmp/report.pdf',\n    results_hash: {}\n  )\n\n  #{self}.authors\n"
+      end
+    end
+  end
+end

data/lib/pwn/reports/phone.rb

@@ -21,7 +21,7 @@ module PWN
 
         File.write(
           "#{dir_path}/#{report_name}.json",
-          JSON.pretty_generate(results_hash)
+          ::JSON.pretty_generate(results_hash)
         )
 
         html_report = %{<!DOCTYPE HTML>

data/lib/pwn/reports/sast.rb

@@ -26,7 +26,7 @@ module PWN
         report_name = opts[:report_name] ||= File.basename(Dir.pwd)
         File.write(
           "#{dir_path}/#{report_name}.json",
-          JSON.pretty_generate(results_hash)
+          ::JSON.pretty_generate(results_hash)
         )
 
         column_names = [

data/lib/pwn/reports/uri_buster.rb

@@ -21,7 +21,7 @@ module PWN
 
         File.write(
           "#{dir_path}/#{report_name}.json",
-          JSON.pretty_generate(results_hash)
+          ::JSON.pretty_generate(results_hash)
         )
 
         html_report = %{<!DOCTYPE HTML>

data/lib/pwn/reports/xml.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module PWN
+  module Reports
+    # Generic XML report writer for pentest / findings payloads.
+    module XML
+      public_class_method def self.generate(opts = {})
+        out = PWN::Reports.resolve_path(opts.merge(ext: 'xml'))
+        payload = PWN::Reports.report_payload(opts)
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+        root = doc.add_element('report')
+        root.add_element('title').text = payload[:title]
+        root.add_element('executive_summary').text = payload[:executive_summary]
+        findings = root.add_element('findings')
+        payload[:findings].each do |row|
+          node = findings.add_element('finding')
+          row.each do |key, val|
+            node.add_element(safe_tag(name: key)).text = val.to_s
+          end
+        end
+        File.open(out, 'w') { |io| doc.write(io, 2) }
+        out
+      end
+
+      private_class_method def self.safe_tag(opts = {})
+        name = opts[:name].to_s
+        name = 'field' if name.empty?
+        name = "f_#{name}" unless name.match?(/\A[A-Za-z_]/)
+        name.gsub(/[^A-Za-z0-9_\-.]/, '_')
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:\n  #{self}.generate(\n    path: '/tmp/report.xml',\n    results_hash: {}\n  )\n\n  #{self}.authors\n"
+      end
+    end
+  end
+end

data/lib/pwn/reports.rb

@@ -1,25 +1,73 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+
 module PWN
   # This file, using the autoload directive loads Report modules
   # into memory only when they're needed. For more information, see:
   # http://www.rubyinside.com/ruby-techniques-revealed-autoload-1652.html
   module Reports
-    # autoload :HTML, 'pwn/reports/html'
-    # autoload :JSON, 'pwn/reports/json'
-    # autoload :PDF, 'pwn/reports/pdf'
     autoload :AIRedTeam, 'pwn/reports/ai_red_team'
+    autoload :CSV, 'pwn/reports/csv'
     autoload :Fuzz, 'pwn/reports/fuzz'
+    autoload :HTML, 'pwn/reports/html'
     autoload :HTMLFooter, 'pwn/reports/html_footer'
     autoload :HTMLHeader, 'pwn/reports/html_header'
+    autoload :JSON, 'pwn/reports/json'
+    autoload :Markdown, 'pwn/reports/markdown'
+    autoload :PDF, 'pwn/reports/pdf'
     autoload :Phone, 'pwn/reports/phone'
     autoload :SAST, 'pwn/reports/sast'
     autoload :URIBuster, 'pwn/reports/uri_buster'
-    # autoload :XML, 'pwn/reports/xml'
+    autoload :XML, 'pwn/reports/xml'
+
+    public_class_method def self.resolve_path(opts = {})
+      path = opts[:path].to_s
+      ext = opts[:ext].to_s.sub(/\A\./, '')
+      unless path.empty?
+        FileUtils.mkdir_p(File.dirname(path)) unless File.dirname(path).to_s.empty? || File.dirname(path) == '.'
+        return path
+      end
 
-    # Display a List of Every PWN::Reports Module
+      dir = opts[:dir_path].to_s
+      dir = '.' if dir.empty?
+      FileUtils.mkdir_p(dir)
+      name = opts[:report_name].to_s
+      name = File.basename(Dir.pwd) if name.empty?
+      File.join(dir, "#{name}.#{ext}")
+    end
 
-    # Author(s):: 0day Inc. <support@0dayinc.com>
+    public_class_method def self.report_payload(opts = {})
+      raw = opts[:results_hash]
+      raw = {} unless raw.is_a?(Hash)
+      title = (
+        opts[:title] ||
+        raw[:title] || raw['title'] ||
+        raw[:report_name] || raw['report_name'] ||
+        'PWN Report'
+      ).to_s
+      summary = (
+        opts[:executive_summary] ||
+        raw[:executive_summary] || raw['executive_summary']
+      ).to_s
+      findings = raw[:findings] || raw['findings'] || raw[:data] || raw['data'] || []
+      findings = [] unless findings.is_a?(Array)
+      {
+        title: title,
+        executive_summary: summary,
+        findings: findings.map { |row| stringify_keys(hash: row) },
+        raw: raw
+      }
+    end
+
+    private_class_method def self.stringify_keys(opts = {})
+      hash = opts[:hash]
+      return { 'value' => hash.to_s } unless hash.is_a?(Hash)
+
+      hash.each_with_object({}) do |(key, val), acc|
+        acc[key.to_s] = val
+      end
+    end
 
     public_class_method def self.authors
       "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"

data/lib/pwn/version.rb

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

data/spec/integration/reinforced_feedback_loop_spec.rb

@@ -628,11 +628,11 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       expect(metrics.calibration(engine: :ollama)[:n]).to eq 1
     end
 
-    it 'a critic :flaw caps the recorded score ≤ 0.3 and triggers HER on failure' do
+    it 'a critic :flaw caps a weak judge score ≤ 0.3 and triggers HER on failure' do
       @agent_cfg[:auto_introspect] = true
       @agent_cfg[:critic]          = true
       allow(curriculum).to receive(:critic).and_return(verdict: :flaw, flaw: 'wrong CVE')
-      allow(reward).to receive(:judge).and_return(score: 0.9, verdict: :solved, rationale: '', success: true)
+      allow(reward).to receive(:judge).and_return(score: 0.45, verdict: :partial, rationale: '', success: false)
       allow(reward).to receive(:sentinel).and_return(status: :insufficient)
       expect(curriculum).to receive(:hindsight)
 
@@ -642,6 +642,21 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       expect(row[:success]).to be false
       expect(row[:score]).to be <= 0.3
     end
+
+    it 'does not let critic :flaw floor a high-evidence judge score' do
+      @agent_cfg[:auto_introspect] = true
+      @agent_cfg[:critic]          = true
+      allow(curriculum).to receive(:critic).and_return(verdict: :flaw, flaw: 'plan_cover_low')
+      allow(reward).to receive(:judge).and_return(score: 0.87, verdict: :solved, rationale: 'evidence=0.87', success: true)
+      allow(reward).to receive(:sentinel).and_return(status: :insufficient)
+      allow(curriculum).to receive(:hindsight)
+
+      s = PWN::Sessions.create(title: 'e2e_critic_keep')
+      learning.auto_introspect(session_id: s[:id], request: 'x', final: 'path-backed complete answer')
+      row = learning.outcomes.first
+      expect(row[:success]).to be true
+      expect(row[:score]).to be >= 0.6
+    end
   end
 
   # ═══════════════════════════════════════════════════════════════════════
@@ -1009,7 +1024,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       )
       expect(prompts.length).to eq 4
       blob = prompts.join(' ').downcase
-      expect(blob).to match(/one shell|at most two|no tools|three iterations|uname|cwd/)
+      expect(blob).to match(/poc|findings|severity|reports::json/i)
     end
 
     it 'practice sorts budget fingerprints ahead of shell noise' do
@@ -1167,7 +1182,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
         mistake: { tool: 'agent_loop', error: 'iteration budget exhausted' },
         count: 3
       )
-      expect(prompts.join(' ')).to match(/one shell|at most two|no tools|three iterations/i)
+      expect(prompts.join(' ')).to match(/PoC|findings|severity|Reports::JSON/i)
     end
 
     it 'practice refuses resolve when holdouts ok but trace weak on budget target' do

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

@@ -40,14 +40,12 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src).to match(/red_team_plan/)
     end
 
-    it 'auto_introspect receives plan from ts_state on success and exhaust paths' do
+    it 'does not pass TUI plan into auto_introspect' do
       src = File.read(described_class.method(:run).source_location.first)
-      # every auto_introspect in Loop.run should pass plan:
       calls = src.scan(/Learning\.auto_introspect\([^)]*\)/m)
-      # also multi-line form collapsed into one-liners already
       expect(calls.length).to be >= 2
       calls.each do |c|
-        expect(c).to match(/plan:/), "auto_introspect missing plan: #{c[0, 120]}"
+        expect(c).not_to match(/plan:/), "auto_introspect must not take TUI plan: #{c[0, 120]}"
       end
     end
 
@@ -93,7 +91,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       parked_n = [a, b].count do |m|
         PWN::AI::Agent::Mistakes.find(signature: m[:signature])[:parked]
       end
-      expect(parked_n).to be >= 1
+      expect(parked_n).to eq(0)
     ensure
       FileUtils.remove_entry(tmp) if tmp && Dir.exist?(tmp)
     end
@@ -451,12 +449,19 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       ]
       8.times do |n|
         msgs << { role: 'assistant', content: '', tool_calls: [{ id: "c#{n}" }] }
-        msgs << { role: 'tool', tool_call_id: "c#{n}", name: 'shell', content: ('x' * 4_000) }
+        msgs << { role: 'tool', tool_call_id: "c#{n}", name: 'shell', content: ('x' * 4_000) + n.to_s }
       end
       out = described_class.send(:compact_history!, messages: msgs)
       tool_bodies = out.select { |m| m[:role].to_s == 'tool' }
       expect(tool_bodies.length).to be <= 6
-      expect(tool_bodies.map { |m| m[:content].to_s.length }.max).to be <= 2_100
+      last = tool_bodies.last(2)
+      expect(last.map { |m| m[:content].to_s.length }.min).to eq(4_001)
+      older = tool_bodies[0...-2]
+      expect(older).not_to be_empty
+      older.each do |m|
+        expect(m[:content].to_s).to include('[compacted path=')
+        expect(m[:content].to_s.length).to be < 500
+      end
     end
 
     it 'compacts again after a transient engine hop before retrying' do
@@ -523,10 +528,10 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(out.map { |m| m[:tool_call_id] }).not_to include('toolu_orphan')
     end
 
-    it 'extinguishes a repeated identical payload by signature, not the whole tool' do
+    it 'checkpoints a repeated identical payload instead of extinguishing the tool' do
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).to match(/no_progress|same_payload|payload_sig/)
-      expect(src).not_to match(/pwn_extinguished\[opts\[:name\]\.to_s\] = true/)
+      expect(src).to match(/checkpoint_result/)
+      expect(src).not_to match(/pwn_extinguished\[sig\] = true/)
     end
 
     it 'records a timeout increment mistake instead of treating success:true as ok' do
@@ -910,6 +915,157 @@ 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 include('PWN::Reports::PDF.generate')
+      payload = {
+        paths: ['/tmp/out.json'],
+        min_seconds: 28_800,
+        skills: ['penetration-testing'],
+        proofs: ['/tmp/poc.sh'],
+        hosts: ['127.0.0.1'],
+        techniques: ['T1059'],
+        issue_work: true
+      }
+      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(contract[:techniques]).to eq(['T1059'])
+      expect(contract[:issue_work]).to eq(true)
+      expect(described_class).to have_received(:call_engine).once
+    ensure
+      Thread.current[:pwn_loop_active] = nil
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
+    it 'keeps issue_work unsatisfied until proofs exist, without Crit/High regex' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).not_to include('Crit/High')
+      Thread.current[:pwn_loop_deliverables] = {
+        paths: [],
+        min_seconds: 0,
+        skills: [],
+        proofs: [],
+        hosts: [],
+        techniques: ['T1059'],
+        issue_work: true
+      }
+      msgs = [{ role: 'tool', content: 'no techniques yet' }]
+      expect(
+        described_class.send(:declared_contract_unsatisfied?, request: 'unique hunt', messages: msgs)
+      ).to eq(true)
+      poc = "/tmp/pwn-issue-#{Process.pid}.poc"
+      File.write(poc, 'working poc')
+      Thread.current[:pwn_loop_deliverables][:proofs] = [poc]
+      msgs = [{ role: 'tool', content: 'used T1059 on host' }]
+      expect(
+        described_class.send(:declared_contract_unsatisfied?, request: 'unique hunt', messages: msgs)
+      ).to eq(false)
+    ensure
+      FileUtils.rm_f(poc) if defined?(poc)
+      Thread.current[:pwn_loop_deliverables] = nil
+    end
+
+    it 'does not append PLAN: onto the model wire from plan_first' do
+      src = File.read(described_class.method(:plan_first).source_location.first)
+      expect(src).not_to include('messages << { role: \'assistant\', content: "PLAN:')
+      expect(src).not_to include('messages << { role: \'user\', content: rt }')
+    end
+
+    it 'nested host hunts keep CORE_TOOLS by clearing enabled_toolsets' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/nested && needs_host_work\?/)
+      expect(src).to match(/opts\[:enabled_toolsets\] = 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/)