pwn 0.5.718 → 0.5.720

data/lib/pwn/plugins/exploit_db.rb

@@ -207,27 +207,51 @@ module PWN
       end
 
       private_class_method def self.gtfobins_json(opts = {})
-        body = opts[:body].to_s
-        stripped = body.lstrip
-        return body if stripped.start_with?('{', '[')
+        raw = opts[:body]
+        raw = raw.to_s.b unless raw.nil?
+        stripped = raw.to_s.lstrip
+        if stripped.start_with?('{', '[')
+          parsed = JSON.parse(stripped)
+          raise 'ERROR: GTFOBins JSON was empty' if parsed.nil? || parsed.empty?
+
+          return stripped
+        end
 
         bins = {}
-        Zlib::GzipReader.wrap(StringIO.new(body)) do |gz|
+        Zlib::GzipReader.wrap(StringIO.new(raw)) do |gz|
           Gem::Package::TarReader.new(gz) do |tar|
             tar.each do |entry|
               next unless entry.file?
-              next unless entry.full_name.include?('_gtfobins/') && entry.full_name.end_with?('.md')
 
-              name = File.basename(entry.full_name, '.md')
+              path = entry.full_name.to_s
+              next unless path.include?('/_gtfobins/') || path.start_with?('_gtfobins/')
+
+              base = File.basename(path)
+              next if base.empty? || base.start_with?('.')
+
+              name = base.sub(/\.md\z/i, '')
               text = entry.read.to_s
-              funcs = text.scan(/^##\s+(.+)$/).flatten.map(&:strip)
+              funcs = gtfobins_functions(text: text)
               bins[name] = { 'binary' => name, 'functions' => funcs }
             end
           end
         end
+        raise 'ERROR: GTFOBins archive contained no _gtfobins entries' if bins.empty?
+
         JSON.generate(bins)
-      rescue StandardError
-        body.start_with?('{') ? body : JSON.generate({})
+      end
+
+      private_class_method def self.gtfobins_functions(opts = {})
+        text = opts[:text].to_s
+        headed = text.scan(/^##\s+(.+)$/).flatten.map(&:strip)
+        return headed unless headed.empty?
+
+        if text =~ /^functions:\s*$/
+          keys = text.scan(/^(?:  |\t)([A-Za-z0-9._-]+):\s*$/).flatten
+          return keys unless keys.empty?
+        end
+
+        []
       end
     end
   end

data/lib/pwn/plugins/findings.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'fileutils'
 require 'securerandom'
+require 'digest'
 
 module PWN
   module Plugins
@@ -39,9 +40,28 @@ module PWN
         }
         FileUtils.mkdir_p(File.dirname(FILE))
         File.open(FILE, 'a') { |f| f.puts(JSON.generate(row)) }
+        evidence_anchor(row: row, arts: arts)
         row
       end
 
+      public_class_method def self.evidence_verify(opts = {})
+        eng = (opts[:engagement_id] || opts[:name] || 'default').to_s
+        path = File.join(Dir.home, '.pwn', 'engagements', eng, 'evidence.jsonl')
+        return { ok: true, rows: 0 } unless File.file?(path)
+
+        mismatches = []
+        n = 0
+        File.readlines(path).each do |ln|
+          row = JSON.parse(ln, symbolize_names: true)
+          n += 1
+          next unless File.file?(row[:path].to_s)
+
+          sha = Digest::SHA256.file(row[:path]).hexdigest
+          mismatches << row[:path] unless sha == row[:sha256].to_s
+        end
+        { ok: mismatches.empty?, rows: n, mismatches: mismatches }
+      end
+
       public_class_method def self.report(opts = {})
         return [] unless File.file?(FILE)
 
@@ -84,6 +104,27 @@ module PWN
         }
       end
 
+      private_class_method def self.evidence_anchor(opts = {})
+        row = opts[:row]
+        arts = Array(opts[:arts])
+        eng = (row[:engagement_id] || 'default').to_s
+        dir = File.join(Dir.home, '.pwn', 'engagements', eng)
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, 'evidence.jsonl')
+        arts.each do |art|
+          next unless File.file?(art.to_s)
+
+          rec = {
+            ts: Time.now.utc.iso8601,
+            finding_id: row[:id],
+            path: art,
+            sha256: Digest::SHA256.file(art).hexdigest,
+            size: File.size(art)
+          }
+          File.open(path, 'a') { |f| f.puts(JSON.generate(rec)) }
+        end
+      end
+
       public_class_method def self.authors
         "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
       end
@@ -134,6 +175,12 @@ module PWN
             report_name: 'optional - basename without extension (defaults to findings)'
           )
 
+          # Re-hash evidence files and report tampering.
+          #{self}.evidence_verify(
+            engagement_id: 'optional - engagement name (defaults to default)',
+            name: 'optional - alias for engagement_id'
+          )
+
           # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "

data/lib/pwn/plugins/gdb.rb

@@ -62,6 +62,34 @@ module PWN
         batch(opts.merge(commands: cmds))
       end
 
+      public_class_method def self.crash_info(opts = {})
+        binary = opts[:binary].to_s
+        row = run_to_crash(opts.merge(binary: binary))
+        out = "#{row[:stdout]}#{row[:stderr]}"
+        sig = out[/Program received signal ([A-Z0-9]+)/, 1] || out[/SIG[A-Z]+/]
+        pc = out[/\bpc\s+0x([0-9a-f]+)/i, 1] || out[/rip\s+0x([0-9a-f]+)/i, 1]
+        frames = out.scan(/#\d+\s+0x[0-9a-f]+.+/).first(8)
+        exploitability = if sig.to_s.include?('SEGV') && pc
+                           'likely-exploitable'
+                         elsif sig
+                           'unknown'
+                         end
+        {
+          signal: sig,
+          pc: pc,
+          faulting_access: out[/Access at address 0x([0-9a-f]+)/, 1],
+          backtrace: frames,
+          regs: out,
+          exploitability_heuristic: exploitability,
+          raw: row
+        }
+      end
+
+      public_class_method def self.debug_session(opts = {})
+        script = Array(opts[:script] || opts[:commands])
+        crash_info(opts.merge(commands: script))
+      end
+
       public_class_method def self.authors
         "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
       end
@@ -105,6 +133,20 @@ module PWN
             args: 'optional - Array of inferior argv'
           )
 
+          # Parse a run-to-crash gdb session into typed crash_info.
+          #{self}.crash_info(
+            binary: 'required - crashing binary path',
+            args: 'optional - Array of inferior argv',
+            commands: 'optional - extra gdb commands'
+          )
+
+          # Alias of crash_info for the debug_session agent tool.
+          #{self}.debug_session(
+            binary: 'required - crashing binary path',
+            args: 'optional - Array of inferior argv',
+            script: 'optional - Array of gdb/MI commands'
+          )
+
           # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "

data/lib/pwn/plugins/packet.rb

@@ -1194,6 +1194,24 @@ module PWN
         raise e
       end
 
+      public_class_method def self.tcp_connect_scan(opts = {})
+        hosts = Array(opts[:hosts] || opts[:targets])
+        ports = Array(opts[:ports]).map(&:to_i).reject(&:zero?)
+        ports = [80, 443] if ports.empty?
+        timeout = (opts[:timeout] || 2).to_f
+        rows = hosts.product(ports).map do |host, port|
+          open = begin
+            sock = Socket.tcp(host, port, connect_timeout: timeout)
+            sock.close
+            true
+          rescue StandardError
+            false
+          end
+          { host: host, port: port, open: open }
+        end
+        { results: rows, degraded: true, fidelity: 'connect-scan (no raw sockets / custom IP flags)' }
+      end
+
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -1424,6 +1442,14 @@ module PWN
             iface: 'optional - interface to send packet (defaults to eth0)'
           )
 
+          # Unprivileged TCP connect sweep (fallback when CAP_NET_RAW is missing).
+          #{self}.tcp_connect_scan(
+            hosts: 'required - Array of hostnames or IPs',
+            targets: 'optional - alias for hosts',
+            ports: 'optional - Array of ports (defaults to 80,443)',
+            timeout: 'optional - connect timeout seconds (defaults to 2)'
+          )
+
           # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "

data/lib/pwn/plugins/repl.rb

@@ -1583,7 +1583,7 @@ module PWN
       end
 
       PWN_AI_SLASH_COMMANDS = %w[
-        /back /cron /debug /delegate /help /memory /model /sessions /skills /trace
+        /back /cron /debug /delegate /help /learning /memory /model /sessions /skills /trace
       ].freeze
 
       PWN_AI_SLASH_SUBCOMMANDS = {
@@ -1595,7 +1595,8 @@ module PWN
         '/memory' => %w[list recall remember forget clear],
         '/model' => %w[list],
         '/sessions' => %w[list resume delete stats],
-        '/skills' => %w[list recall]
+        '/skills' => %w[list recall],
+        '/learning' => %w[list requeue]
       }.freeze
 
       # Supported Method Parameters::
@@ -1785,6 +1786,8 @@ module PWN
           puts '    Use agent_list / agent_debate from pwn-ai, or pwn-ai-delegate in the pwn REPL.'
         when '/model'
           pwn_ai_run_model(args: args)
+        when '/learning'
+          pwn_ai_run_learning(args: args)
         end
         true
       rescue StandardError => e
@@ -2016,6 +2019,21 @@ module PWN
         end
       end
 
+      public_class_method def self.pwn_ai_run_learning(opts = {})
+        args = Array(opts[:args])
+        sub = args[0] || 'list'
+        case sub
+        when 'list'
+          flag = args.include?('--conflicted') || args.include?('conflicted')
+          rows = flag ? PWN::AI::Agent::Learning.list_conflicted : PWN::AI::Agent::Learning.outcomes(limit: 20)
+          puts rows.inspect
+        when 'requeue'
+          puts PWN::AI::Agent::Learning.requeue_conflicted.inspect
+        else
+          puts 'Usage: /learning [list [--conflicted]|requeue]'
+        end
+      end
+
       public_class_method def self.pwn_ai_run_skills(opts = {})
         args = Array(opts[:args])
         sub = args[0] || 'list'
@@ -2246,6 +2264,11 @@ module PWN
             args: 'optional - Array args value consumed by #pwn_ai_run_memory'
           )
 
+          # List or requeue conflicted learning outcomes.
+          #{self}.pwn_ai_run_learning(
+            args: 'optional - list [--conflicted] or requeue'
+          )
+
           # Run pwn ai run skills and return its result
           #{self}.pwn_ai_run_skills(
             args: 'optional - Array args value consumed by #pwn_ai_run_skills'

data/lib/pwn/plugins/vault.rb

@@ -3,6 +3,8 @@
 require 'base64'
 require 'openssl'
 require 'yaml'
+require 'json'
+require 'fileutils'
 
 module PWN
   module Plugins
@@ -244,6 +246,99 @@ module PWN
         raise e
       end
 
+      public_class_method def self.store(opts = {})
+        label = opts[:label].to_s
+        secret = opts[:secret].to_s
+        raise 'ERROR: label and secret are required' if label.empty? || secret.empty?
+
+        box = load_box
+        box[label] = encrypt_secret(secret: secret)
+        save_box(box: box)
+        { label: label, stored: true }
+      end
+
+      public_class_method def self.fetch(opts = {})
+        label = opts[:label].to_s
+        raise 'ERROR: label is required' if label.empty?
+
+        row = load_box[label]
+        return nil unless row
+
+        decrypt_secret(row: row)
+      end
+
+      public_class_method def self.expand(opts = {})
+        text = opts[:text].to_s
+        text.gsub(/\{\{vault:([^}]+)\}\}/) { fetch(label: Regexp.last_match(1).to_s.strip).to_s }
+      end
+
+      public_class_method def self.redact(opts = {})
+        text = opts[:text].to_s
+        load_box.each do |label, row|
+          val = decrypt_secret(row: row).to_s
+          next if val.empty?
+
+          text = text.gsub(val, "{{vault:#{label}}}")
+        end
+        text
+      end
+
+      private_class_method def self.key_path
+        File.join(Dir.home, '.pwn-vault.key')
+      end
+
+      private_class_method def self.box_path
+        File.join(Dir.home, '.pwn', 'vault-secrets.json')
+      end
+
+      private_class_method def self.master_key(opts = {})
+        _n = opts[:n]
+        path = key_path
+        unless File.file?(path)
+          File.binwrite(path, OpenSSL::Random.random_bytes(32))
+          File.chmod(0o600, path)
+        end
+        File.binread(path)
+      end
+
+      private_class_method def self.encrypt_secret(opts = {})
+        cipher = OpenSSL::Cipher.new('aes-256-gcm')
+        cipher.encrypt
+        cipher.key = master_key
+        iv = cipher.random_iv
+        cipher.auth_data = 'pwn-vault'
+        ct = cipher.update(opts[:secret].to_s) + cipher.final
+        { iv: Base64.strict_encode64(iv), ct: Base64.strict_encode64(ct), tag: Base64.strict_encode64(cipher.auth_tag) }
+      end
+
+      private_class_method def self.decrypt_secret(opts = {})
+        row = opts[:row]
+        return '' unless row.is_a?(Hash)
+
+        cipher = OpenSSL::Cipher.new('aes-256-gcm')
+        cipher.decrypt
+        cipher.key = master_key
+        cipher.iv = Base64.strict_decode64(row[:iv] || row['iv'].to_s)
+        cipher.auth_tag = Base64.strict_decode64(row[:tag] || row['tag'].to_s)
+        cipher.auth_data = 'pwn-vault'
+        cipher.update(Base64.strict_decode64(row[:ct] || row['ct'].to_s)) + cipher.final
+      end
+
+      private_class_method def self.load_box(opts = {})
+        return {} unless opts.is_a?(Hash)
+        return {} unless File.file?(box_path)
+
+        JSON.parse(File.read(box_path))
+      rescue StandardError
+        {}
+      end
+
+      private_class_method def self.save_box(opts = {})
+        FileUtils.mkdir_p(File.dirname(box_path))
+        File.write(box_path, JSON.pretty_generate(opts[:box] || {}))
+        File.chmod(0o600, box_path)
+      end
+
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -304,6 +399,27 @@ module PWN
             file: 'required - file to check if encrypted'
           )
 
+          # Store a secret outside the transcript (AES-GCM; key in ~/.pwn-vault.key).
+          #{self}.store(
+            label: 'required - vault label',
+            secret: 'required - secret value'
+          )
+
+          # Fetch a stored secret by label.
+          #{self}.fetch(
+            label: 'required - vault label'
+          )
+
+          # Replace {{vault:label}} tokens with stored secrets.
+          #{self}.expand(
+            text: 'required - string possibly containing {{vault:label}} tokens'
+          )
+
+          # Replace stored secret values with {{vault:label}} placeholders.
+          #{self}.redact(
+            text: 'required - string that may contain stored secrets'
+          )
+
           # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "

data/lib/pwn/plugins.rb

@@ -10,6 +10,8 @@ module PWN
     autoload :ArtifactRegistry, 'pwn/plugins/artifact_registry'
     autoload :Assembly, 'pwn/plugins/assembly'
     autoload :BinaryParser, 'pwn/plugins/binary_parser'
+    autoload :BinWorkspace, 'pwn/plugins/bin_workspace'
+    autoload :Capability, 'pwn/plugins/capability'
     autoload :AuthenticationHelper, 'pwn/plugins/authentication_helper'
     autoload :BareSIP, 'pwn/plugins/baresip'
     autoload :BasicAuth, 'pwn/plugins/basic_auth'
@@ -28,7 +30,9 @@ module PWN
     autoload :DAOSQLite3, 'pwn/plugins/dao_sqlite3'
     autoload :DefectDojo, 'pwn/plugins/defect_dojo'
     autoload :DetectOS, 'pwn/plugins/detect_os'
+    autoload :Detonate, 'pwn/plugins/detonate'
     autoload :EIN, 'pwn/plugins/ein'
+    autoload :Emulator, 'pwn/plugins/emulator'
     autoload :ExploitDB, 'pwn/plugins/exploit_db'
     autoload :FileFu, 'pwn/plugins/file_fu'
     autoload :Findings, 'pwn/plugins/findings'

data/lib/pwn/reports/engagement.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PWN
+  module Reports
+    # Compile engagement findings into a client-ready HTML/Markdown report.
+    module Engagement
+      public_class_method def self.generate(opts = {})
+        name = (opts[:engagement] || opts[:name] || 'default').to_s
+        rows = if opts[:findings]
+                 Array(opts[:findings])
+               elsif defined?(PWN::Plugins::Findings)
+                 PWN::Plugins::Findings.report
+               else
+                 []
+               end
+        rows = rows.sort_by { |r| -severity_rank(row: r) }
+        payload = {
+          title: "Engagement #{name}",
+          findings: rows,
+          summary: { count: rows.length, critical: rows.count { |r| r[:severity].to_s == 'critical' || r['severity'].to_s == 'critical' } }
+        }
+        dir = opts[:dir_path].to_s
+        dir = File.join(Dir.home, '.pwn', 'exports') if dir.empty?
+        report_name = (opts[:report_name] || "engagement-#{name}").to_s
+        {
+          markdown: PWN::Reports::Markdown.generate(results_hash: payload, dir_path: dir, report_name: report_name),
+          html: PWN::Reports::HTML.generate(results_hash: payload, dir_path: dir, report_name: report_name),
+          json: PWN::Reports::JSON.generate(results_hash: payload, dir_path: dir, report_name: report_name)
+        }
+      end
+
+      private_class_method def self.severity_rank(opts = {})
+        row = opts[:row]
+        row = {} unless row.is_a?(Hash)
+        sev = (row[:severity] || row['severity']).to_s
+        { 'critical' => 4, 'high' => 3, 'medium' => 2, 'low' => 1 }[sev] || 0
+      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:
+          # Compile findings into markdown, html, and json.
+          #{self}.generate(
+            engagement: 'optional - engagement name (defaults to default)',
+            name: 'optional - alias for engagement',
+            findings: 'optional - Array of finding hashes (defaults to Findings.report)',
+            dir_path: 'optional - output directory',
+            report_name: 'optional - basename without extension'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end

data/lib/pwn/reports.rb

@@ -9,6 +9,7 @@ module PWN
   module Reports
     autoload :AIRedTeam, 'pwn/reports/ai_red_team'
     autoload :CSV, 'pwn/reports/csv'
+    autoload :Engagement, 'pwn/reports/engagement'
     autoload :Fuzz, 'pwn/reports/fuzz'
     autoload :HTML, 'pwn/reports/html'
     autoload :HTMLFooter, 'pwn/reports/html_footer'

data/lib/pwn/version.rb

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

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'tmpdir'
+require 'fileutils'
+
+describe PWN::AI::Agent::Engagement do
+  it 'should display information for authors' do
+    expect(described_class).to respond_to :authors
+  end
+
+  it 'should display information for existing help method' do
+    expect(described_class).to respond_to :help
+  end
+
+  it 'blocks out-of-scope IPs when a CIDR engagement is active' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      stub_const('PWN::AI::Agent::Engagement::ROOT', File.join(dir, '.pwn', 'engagements'))
+      stub_const('PWN::AI::Agent::Engagement::ACTIVE_FILE', File.join(dir, '.pwn', 'engagements', 'active'))
+      described_class.open(name: 'lab', scope_cidrs: ['10.0.0.0/24'])
+      deny = described_class.deny_if_out_of_scope(command: 'scan 8.8.8.8')
+      expect(deny[:error]).to include('8.8.8.8')
+      expect(described_class.in_scope?(ip: '10.0.0.5')).to eq(true)
+    end
+  end
+end

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

@@ -355,3 +355,26 @@ describe PWN::AI::Agent::Learning do
     end
   end
 end
+
+describe 'PWN::AI::Agent::Learning conflicted outcomes' do
+  it 'tags verifier/judge conflicts and keeps them out of RECENT FAILURES' do
+    Dir.mktmpdir do |dir|
+      stub_const('PWN::AI::Agent::Learning::LEARNING_FILE', File.join(dir, 'learning.jsonl'))
+      PWN::AI::Agent::Learning.note_outcome(task: 'pass-low-judge', success: false, score: 0.36, verifier_verdict: :pass, details: 'overlap=0.01 ratio=1.0')
+      expect(PWN::AI::Agent::Learning.list_conflicted.first[:status]).to eq('conflicted')
+      ctx = PWN::AI::Agent::Learning.to_context(limit: 10)
+      expect(ctx).not_to include('overlap=')
+    end
+  end
+
+  it 'prunes bak files down to max_baks' do
+    Dir.mktmpdir do |dir|
+      stub_const('PWN::AI::Agent::Learning::LEARNING_FILE', File.join(dir, 'learning.jsonl'))
+      File.write(File.join(dir, 'learning.jsonl'), "{}\n")
+      7.times { |i| File.write(File.join(dir, "learning.jsonl.bak-#{i}"), 'x') }
+      out = PWN::AI::Agent::Learning.compact!(max_baks: 5)
+      expect(Dir[File.join(dir, '*.bak*')].length).to eq(5)
+      expect(out[:pruned]).to eq(2)
+    end
+  end
+end

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

@@ -931,7 +931,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
         {
           role: 'tool',
           name: 'pwn_eval',
-          content: '{"success":true,"result":{"stdout":"Report saved to /tmp/pentest_report.json"},"effect":"write"}'
+          content: '{"success":true,"result":{"stdout":"Report saved to /tmp/pwn-spec-report.json"},"effect":"write"}'
         },
         {
           role: 'assistant',

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

@@ -422,4 +422,20 @@ describe 'PWN::AI::Agent::Reward vs TUI plan' do
     m = PWN::AI::Agent::Reward.send(:judge_model)
     expect(m).to eq('local-judge')
   end
+
+  it 'records verifier PASS as success even when the judge scores 0.0' do
+    allow(PWN::AI::Agent::Reward).to receive(:llm_judge).and_return(
+      { score: 0.0, source: 'heuristic', verdict: :wrong, rationale: 'overlap=0.01', confidence: 0.3 }
+    )
+    v = PWN::AI::Agent::Reward.judge(
+      request: 'write /tmp/x',
+      final: 'PASS file exists',
+      trace: ['{"success":true}'],
+      commit: false,
+      verifier_verdict: :pass
+    )
+    expect(v[:success]).to eq(true)
+    expect(v[:verifier_verdict]).to eq(:pass)
+    expect(v[:judge_score]).to be < 0.6
+  end
 end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'tmpdir'
 
 describe PWN::AI::Agent::Swarm do
   it 'should display information for authors' do
@@ -43,4 +44,14 @@ describe PWN::AI::Agent::Swarm do
     expect(rows.length).to eq(4)
     expect(rows.map { |r| r[:port] }.uniq.length).to eq(4)
   end
+
+  it 'allows only one live claim per unit' do
+    Dir.mktmpdir do |dir|
+      allow(Dir).to receive(:home).and_return(dir)
+      a = described_class.claim(unit: '10.0.0.5:recon', agent_id: 'a', ttl: 60, engagement_id: 'lab')
+      b = described_class.claim(unit: '10.0.0.5:recon', agent_id: 'b', ttl: 60, engagement_id: 'lab')
+      expect(a[:ok]).to eq(true)
+      expect(b[:ok]).to eq(false)
+    end
+  end
 end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'PWN::AI::Agent::Tools debug_lane' do
+  before(:all) do
+    PWN::AI::Agent::Registry.discover(force: true)
+    load '/opt/pwn/lib/pwn/ai/agent/tools/debug_lane.rb'
+  end
+
+  it 'registers debug_session binary_diff crash_triage emulate detonate budget_status pty_expect' do
+    %w[debug_session binary_diff crash_triage capability_request emulate detonate budget_status pty_expect].each do |name|
+      expect(PWN::AI::Agent::Registry.lookup(name: name)).not_to be_nil
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'PWN::AI::Agent::Tools engagement' do
+  before(:all) do
+    PWN::AI::Agent::Registry.discover(force: true)
+    load '/opt/pwn/lib/pwn/ai/agent/tools/engagement.rb'
+  end
+
+  it 'registers engagement_open close and status' do
+    expect(PWN::AI::Agent::Registry.lookup(name: 'engagement_open')).not_to be_nil
+    expect(PWN::AI::Agent::Registry.lookup(name: 'engagement_close')).not_to be_nil
+    expect(PWN::AI::Agent::Registry.lookup(name: 'engagement_status')).not_to be_nil
+  end
+end