pwn 0.5.719 → 0.5.721

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/ghidra.rb

@@ -3,6 +3,7 @@
 require 'open3'
 require 'fileutils'
 require 'json'
+require 'digest'
 
 module PWN
   module Plugins
@@ -31,12 +32,28 @@ module PWN
       end
 
       public_class_method def self.decompile(opts = {})
-        analyze(opts)
+        path = (opts[:bin] || opts[:path]).to_s
+        raise 'ERROR: bin is required' if path.empty?
+
+        sha = Digest::SHA256.file(path).hexdigest if File.file?(path)
+        cache = File.join(Dir.home, '.pwn', 'cache', 'decompile', "#{sha}.json") if sha
+        return JSON.parse(File.read(cache), symbolize_names: true).merge(cached: true) if cache && File.file?(cache)
+
+        row = analyze(opts)
+        fn = opts[:function].to_s
+        row[:function] = fn unless fn.empty?
+        FileUtils.mkdir_p(File.dirname(cache)) if cache
+        File.write(cache, JSON.generate(row)) if cache
+        row
       end
 
       private_class_method def self.r2_fallback(opts = {})
         path = opts[:path].to_s
         stdout, stderr, status = Open3.capture3('r2', '-q', '-c', 'aaa;s main;pdg', path)
+        if stdout.to_s.strip.empty?
+          stdout, stderr, status = Open3.capture3('r2', '-q', '-c', 'aaa;s main;pdc', path)
+          return { stdout: stdout, stderr: stderr, exit: status.exitstatus, engine: 'r2-pdc' }
+        end
         { stdout: stdout, stderr: stderr, exit: status.exitstatus, engine: 'r2' }
       rescue StandardError => e
         { error: e.message, engine: 'r2' }
@@ -62,7 +79,8 @@ module PWN
           #{self}.decompile(
             bin: 'required - filesystem path of the binary',
             path: 'optional - alias for bin',
-            project_dir: 'optional - Ghidra project directory'
+            project_dir: 'optional - Ghidra project directory',
+            function: 'optional - function name to decompile instead of the whole program'
           )
 
           # Print the AUTHOR(S) string for this module.

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/preflight_checker.rb

@@ -67,6 +67,23 @@ module PWN
         { ok: false, name: name, degraded: true, hint: "missing #{name}; install via pwn setup --deps" }
       end
 
+      CAPABILITIES = {
+        web_scan: %w[nuclei burpsuite zaproxy],
+        raw_packet: %w[],
+        decompile: %w[analyzeHeadless r2],
+        debug: %w[gdb]
+      }.freeze
+
+      public_class_method def self.capability_coverage(opts = {})
+        want = opts[:capability] || opts[:cap]
+        if want
+          bins = Array(CAPABILITIES[want.to_sym])
+          covered = bins.any? { |b| bin?(name: b) }
+          return { capability: want.to_s, covered: covered, bins: bins }
+        end
+        CAPABILITIES.keys.map { |k| capability_coverage(capability: k) }
+      end
+
       TASK_BINS = {
         'proxy' => %w[burpsuite zaproxy],
         'vuln-scan' => %w[nuclei openvas],
@@ -176,6 +193,12 @@ module PWN
             name: 'required - binary name to probe'
           )
 
+          # Report whether a named capability is covered by any healthy plugin binary.
+          #{self}.capability_coverage(
+            capability: 'optional - capability name such as web_scan',
+            cap: 'optional - alias for capability'
+          )
+
           # First healthy binary for a task (proxy, vuln-scan, re).
           #{self}.pick(
             task: 'required - capability name such as proxy or vuln-scan'

data/lib/pwn/plugins/process_tube.rb

@@ -21,7 +21,7 @@ module PWN
         argv = cmd.is_a?(Array) ? cmd.map(&:to_s) : ['bash', '-lc', cmd.to_s]
         r, w, pid = PTY.spawn(*argv)
         id = "tube_#{pid}"
-        @tubes[id] = { r: r, w: w, pid: pid, buf: +'' }
+        @tubes[id] = { r: r, w: w, pid: pid, buf: +'', started_at: Time.now, last_io: Time.now }
         { id: id, pid: pid }
       end
 
@@ -105,6 +105,26 @@ module PWN
         n
       end
 
+      public_class_method def self.list(opts = {})
+        _idle = opts[:idle]
+        now = Time.now
+        @tubes.map do |id, t|
+          { id: id, pid: t[:pid], started_at: t[:started_at], last_io: t[:last_io], age_s: (now - (t[:started_at] || now)).to_i }
+        end
+      end
+
+      public_class_method def self.kill(opts = {})
+        id = opts[:id].to_s
+        t = @tubes[id]
+        return { ok: false, id: id } unless t
+
+        Process.kill('TERM', t[:pid]) if t[:pid]
+        close(id: id)
+        { ok: true, id: id }
+      rescue StandardError => e
+        { ok: false, id: id, error: e.message }
+      end
+
       public_class_method def self.authors
         "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
       end
@@ -165,6 +185,16 @@ module PWN
             session_id: 'optional - agent session id for transcript grouping'
           )
 
+          # List live tubes with age.
+          #{self}.list(
+            idle: 'optional - unused reserved idle-seconds filter'
+          )
+
+          # SIGTERM then close a tube by id.
+          #{self}.kill(
+            id: 'required - tube id from spawn or connect'
+          )
+
           # 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/sessions.rb

@@ -172,6 +172,10 @@ module PWN
           next unless %w[user assistant].include?(row[:role].to_s)
 
           body = row[:content].to_s
+          if body.include?('[compacted') && body =~ /ref=(\S+)/
+            ref = Regexp.last_match(1)
+            body = File.read(ref) if File.file?(ref)
+          end
           next if body.strip.empty?
           next if !target.empty? && !body.downcase.include?(target)
 

data/lib/pwn/version.rb

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

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

@@ -28,6 +28,15 @@ describe PWN::AI::Agent::Dispatch do
     expect(described_class.effect(name: 'memory_recall', args: { query: 'docs' })).to eq :recall
     expect(described_class.effect(name: 'memory_remember', args: { key: 'sop' })).to eq :store
     expect(described_class.effect(name: 'learning_note_outcome', args: { task: 'x' })).to eq :store
+    expect(
+      described_class.effect(
+        name: 'shell',
+        args: {
+          command: "cat >> ~/.pwn/logs/pwn-ai-DEBUG-2026-09-03.md <<'EOF'\n" \
+                   "ToolGuard, TransparentBrowser, and devtools are strengths.\nEOF"
+        }
+      )
+    ).to eq :write
     src = File.read(described_class.method(:effect).source_location.first)
     expect(src).to match(/def self\.effect/)
   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

@@ -985,6 +985,50 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       Thread.current[:pwn_loop_deliverables] = nil
     end
 
+    it 'does not bounce with empty unmet after a redirected write whose body mentions browsers' do
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, 'pwn-ai-DEBUG-2026-09-03.md')
+        File.write(path, "# assessment\n" * 40)
+        req = "analyze how well pwn-ai enables pentest. Store this list in #{path}."
+        write_cmd = "cat >> #{path} <<'EOF'\nTransparentBrowser and devtools are strengths.\nEOF"
+        msgs = [
+          { role: 'user', content: req },
+          {
+            role: 'assistant',
+            tool_calls: [{ function: { name: 'shell', arguments: { command: write_cmd }.to_json } }]
+          },
+          {
+            role: 'tool',
+            name: 'shell',
+            content: {
+              success: true,
+              result: { stdout: 'APPENDED', exit: 0 },
+              effect: PWN::AI::Agent::Dispatch.effect(name: 'shell', args: { command: write_cmd })
+            }.to_json
+          },
+          {
+            role: 'assistant',
+            tool_calls: [{ function: { name: 'shell', arguments: { command: "cat #{path}" }.to_json } }]
+          },
+          {
+            role: 'tool',
+            name: 'shell',
+            content: { success: true, result: { stdout: File.read(path), exit: 0 }, effect: 'read' }.to_json
+          }
+        ]
+        expect(described_class.send(:completion_unmet, request: req, messages: msgs)).to eq([])
+        expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(false)
+        expect(
+          described_class.send(
+            :may_finalize?,
+            request: req,
+            messages: msgs,
+            text: "Done. The assessment is at #{path}."
+          )
+        ).to eq(true)
+      end
+    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')