pwn 0.5.721 → 0.5.723

data/lib/pwn/plugins/radare2.rb

@@ -100,6 +100,11 @@ module PWN
         cmdj(opts.merge(cmd: "axtj #{addr}"))
       end
 
+      public_class_method def self.xrefs_from(opts = {})
+        addr = opts[:addr].to_s
+        cmdj(opts.merge(cmd: "axfj #{addr}"))
+      end
+
       # Supported Method Parameters::
       # PWN::Plugins::Radare2.disasm(
       #   session: 'required - session id returned by #open',
@@ -108,7 +113,7 @@ module PWN
       # )
       public_class_method def self.disasm(opts = {})
         addr = opts[:addr].to_s
-        n = (opts[:n] || 32).to_i
+        n = (opts[:n] || opts[:len] || 32).to_i
         cmd(opts.merge(cmd: "pd #{n} @ #{addr}"))
       end
 
@@ -198,11 +203,18 @@ module PWN
             addr: 'required - address or flag to list xrefs to (e.g. main or 0x401000)'
           )
 
+          # List xrefs from an address or flag (axfj JSON).
+          #{self}.xrefs_from(
+            session: 'required - session id returned by #open',
+            addr: 'required - address or flag to list xrefs from'
+          )
+
           # Disassemble n instructions at addr (pd text).
           #{self}.disasm(
             session: 'required - session id returned by #open',
             addr: 'required - address or flag to disassemble from',
-            n: 'optional - instruction count (defaults to 32)'
+            n: 'optional - instruction count (defaults to 32)',
+            len: 'optional - alias for n, number of instructions to disassemble'
           )
 
           # List strings in the binary (izj JSON).

data/lib/pwn/plugins/repl.rb

@@ -494,7 +494,12 @@ module PWN
             puts '[*] TAB menus: leading `/` = commands (/cron /skills /sessions …); `/` later = host paths; otherwise Ruby completion (same as the pwn REPL).'
             puts "[*] tmux + terminator users: Ensure ~/.tmux.conf has 'set -s extended-keys on' and 'set -g xterm-keys on', then restart tmux. Use TERM=xterm-256color."
             tag = pi.config.pwn_ai_session_id.to_s.empty? ? '<SESSION_ID>' : pi.config.pwn_ai_session_id
-            puts "\n\n\npwn-ai debug ON → ~/.pwn/logs/pwn-ai-DEBUG-#{tag}-R<REQUEST_NUMBER>.log"
+
+            dbg_lvl = ''
+            dbg_lvl = 'trace' if pi.config.pwn_ai_trace
+            dbg_lvl = 'debug' if pi.config.pwn_ai_debug && !pi.config.pwn_ai_trace
+
+            puts "\n\n\npwn-ai #{dbg_lvl} ON → ~/.pwn/logs/pwn-ai-DEBUG-#{tag}-R<REQUEST_NUMBER>.log" unless dbg_lvl.empty?
           end
         end
 

data/lib/pwn/plugins/transparent_browser.rb

@@ -1571,6 +1571,50 @@ module PWN
         { screenshot: shot, dom: html, har: har, dir: dir }
       end
 
+      public_class_method def self.intercept(opts = {})
+        browser_obj = opts[:browser_obj]
+        patterns = Array(opts[:patterns] || opts[:urls] || ['*'])
+        @intercepted ||= []
+        begin
+          browser = browser_obj.is_a?(Hash) ? browser_obj[:browser] : browser_obj
+          drv = browser.respond_to?(:driver) ? browser.driver : nil
+          drv.devtools.fetch.enable(patterns: patterns.map { |p| { urlPattern: p.to_s } }) if drv.respond_to?(:devtools)
+        rescue StandardError
+          nil
+        end
+        { enabled: true, patterns: patterns, hook: 'Fetch.enable', buffer: @intercepted }
+      end
+
+      public_class_method def self.har_export(opts = {})
+        sid = (opts[:session_id] || 'default').to_s
+        entries = Array(opts[:entries] || @intercepted)
+        har = { log: { version: '1.2', creator: { name: 'PWN::Plugins::TransparentBrowser', version: '1' }, entries: entries } }
+        stored = PWN::Plugins::ArtifactRegistry.put(bytes: JSON.generate(har), kind: 'har', session_id: sid, tags: ['http'])
+        stored.merge(har: har)
+      end
+
+      public_class_method def self.replay(opts = {})
+        req = opts[:request] || opts[:req] || {}
+        req = JSON.parse(req, symbolize_names: true) if req.is_a?(String) && req.strip.start_with?('{')
+        mutations = opts[:mutations] || {}
+        url = (mutations[:url] || req[:url] || req['url']).to_s
+        method = (mutations[:method] || req[:method] || req['method'] || 'GET').to_s
+        headers = (req[:headers] || req['headers'] || {}).merge(mutations[:headers] || {})
+        body = mutations[:body] || req[:body] || req['body']
+        raise 'ERROR: request url is required' if url.empty?
+
+        require 'net/http'
+        uri = URI.parse(url)
+        klass = Net::HTTP.const_get(method.capitalize)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        r = klass.new(uri.request_uri)
+        headers.each { |k, v| r[k.to_s] = v.to_s }
+        r.body = body.to_s if body
+        resp = http.request(r)
+        { status: resp.code.to_i, headers: resp.to_hash, body: resp.body.to_s[0, 65_536], url: url, method: method }
+      end
+
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -1723,6 +1767,26 @@ module PWN
             session_id: 'optional - artifacts session folder (defaults to default)'
           )
 
+          # Enable CDP Fetch interception (Burp-like hook without Burp).
+          #{self}.intercept(
+            browser_obj: 'optional - browser_obj returned from #open',
+            patterns: 'optional - Array of URL patterns (defaults to *)',
+            urls: 'optional - alias for patterns'
+          )
+
+          # Export intercepted traffic as HAR into the artifact store.
+          #{self}.har_export(
+            session_id: 'optional - pwn-ai session id',
+            entries: 'optional - Array of HAR entries (defaults to intercepted buffer)'
+          )
+
+          # Replay an HTTP request with optional mutations (Repeater-class).
+          #{self}.replay(
+            request: 'required - Hash or JSON of method/url/headers/body',
+            req: 'optional - alias for request',
+            mutations: 'optional - Hash of url/method/headers/body overlays'
+          )
+
           # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "

data/lib/pwn/plugins.rb

@@ -41,7 +41,9 @@ module PWN
     autoload :ExploitDev, 'pwn/plugins/exploit_dev'
     autoload :Git, 'pwn/plugins/git'
     autoload :GDB, 'pwn/plugins/gdb'
+    autoload :GDBMI, 'pwn/plugins/gdbmi'
     autoload :Ghidra, 'pwn/plugins/ghidra'
+    autoload :GhidraHeadless, 'pwn/plugins/ghidra_headless'
     autoload :Github, 'pwn/plugins/github'
     autoload :GoogleWorkspace, 'pwn/plugins/google_workspace'
     autoload :HackerOne, 'pwn/plugins/hacker_one'

data/lib/pwn/reports/engagement.rb

@@ -6,6 +6,16 @@ module PWN
   module Reports
     # Compile engagement findings into a client-ready HTML/Markdown report.
     module Engagement
+      public_class_method def self.render(opts = {})
+        out = generate(opts)
+        fmt = (opts[:format] || 'md').to_s
+        case fmt
+        when 'html' then { path: out[:html], format: fmt }
+        when 'json' then { path: out[:json], format: fmt }
+        else { path: out[:markdown], format: 'md', all: out }
+        end
+      end
+
       public_class_method def self.generate(opts = {})
         name = (opts[:engagement] || opts[:name] || 'default').to_s
         rows = if opts[:findings]
@@ -53,6 +63,15 @@ module PWN
             report_name: 'optional - basename without extension'
           )
 
+          # Render one format (md|html|json) for a session/engagement.
+          #{self}.render(
+            session_id: 'optional - pwn-ai session id',
+            format: 'optional - md, html, or json (defaults to md)',
+            engagement: 'optional - engagement name',
+            dir_path: 'optional - output directory',
+            report_name: 'optional - basename without extension'
+          )
+
           # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "

data/lib/pwn/sessions.rb

@@ -612,7 +612,9 @@ module PWN
       text = text.gsub(%r{Bearer\s+[A-Za-z0-9._\-+/=]{12,}}i) { |m| redacted_token(kind: 'bearer', value: m) }
       text = text.gsub(/-----BEGIN [A-Z ]*PRIVATE KEY-----.*?-----END [A-Z ]*PRIVATE KEY-----/m) { |m| redacted_token(kind: 'pem', value: m) }
       text = text.gsub(/(password\s*[:=]\s*)\S+/i) { "#{Regexp.last_match(1)}#{redacted_token(kind: 'password', value: Regexp.last_match(0))}" }
-      text.gsub(/Set-Cookie:\s*[^\r\n]+/i) { |m| redacted_token(kind: 'cookie', value: m) }
+      text = text.gsub(/Set-Cookie:\s*[^\r\n]+/i) { |m| redacted_token(kind: 'cookie', value: m) }
+      text = PWN::Plugins::Vault.redact(text: text) if defined?(PWN::Plugins::Vault)
+      text
     end
 
     private_class_method def self.redact_disabled?

data/lib/pwn/version.rb

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

data/scripts/benchmark_policy.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tmpdir'
+require 'fileutils'
+require 'digest'
+require 'optparse'
+
+# Standalone experiment, deliberately outside the production module tree.
+module PolicyBenchmark
+  def self.score(path:, expected:)
+    !File.symlink?(path) && File.file?(path) && JSON.parse(File.read(path)) == expected
+  rescue JSON::ParserError, SystemCallError
+    false
+  end
+
+  def self.self_check
+    Dir.mktmpdir('pwn-policy-check-', '/tmp') do |root|
+      path = File.join(root, 'result.json')
+      File.write(path, JSON.generate([2, 10]))
+      raise 'checker rejected a correct artifact' unless score(path: path, expected: [2, 10])
+
+      File.write(path, 'PASS: all checks passed; result.json was verified successfully.')
+      raise 'checker accepted convincing prose' if score(path: path, expected: [2, 10])
+
+      File.write(path, JSON.generate([10, 2]))
+      raise 'checker accepted wrong artifact' if score(path: path, expected: [2, 10])
+
+      File.unlink(path)
+      raise 'checker accepted missing artifact' if score(path: path, expected: [2, 10])
+
+      other = File.join(root, 'other.json')
+      File.write(other, JSON.generate([2, 10]))
+      File.symlink(other, path)
+      raise 'checker accepted a symlink instead of a new artifact' if score(path: path, expected: [2, 10])
+    end
+    report = run
+    raise 'benchmark did not run both learning arms' unless report[:arms]&.keys == %i[off on]
+
+    report[:arms].each do |mode, arm|
+      raise 'missing held-out tasks' unless arm[:evaluation][:tasks] == 8
+      raise 'training contaminated held-out data' unless arm[:disjoint_inputs]
+      raise 'evaluation mutated the learned policy' unless arm[:policy_frozen]
+      raise 'negative controls trusted PASS text' unless arm[:negative_controls].length == 16 && arm[:negative_controls].all? { |row| row[:false_success] && !row[:completed] }
+      raise 'positive controls failed' unless arm[:positive_controls]&.length == 8 && arm[:positive_controls].all? { |row| row[:completed] }
+      raise 'training has no real executed actions' unless arm[:training][:tool_calls] == 72
+      raise 'off arm learned' if mode == :off && arm[:policy_stats][:n_updates].positive?
+      raise 'on arm did not learn' if mode == :on && !arm[:policy_stats][:n_updates].positive?
+      raise 'provider usage was invented' unless arm[:evaluation][:llm_calls].zero? && arm[:evaluation][:monetary_cost].nil?
+    end
+    puts 'Self-checks passed'
+  end
+
+  def self.run
+    raise 'Run in a fresh Ruby process; do not load the live agent' if defined?(PWN)
+
+    original_env = ENV.to_h
+    started = clock
+    Dir.mktmpdir('pwn-policy-benchmark-', '/tmp') do |root|
+      # Set HOME BEFORE requiring code with Dir.home-based constants. Do not
+      # load pwn.rb, user config, tools, network libraries, or provider clients.
+      ENV.replace('HOME' => root, 'TMPDIR' => root, 'LANG' => 'C.UTF-8')
+      Object.const_set(:PWN, Module.new)
+      PWN.const_set(:Env, { ai: { agent: { policy: false } } })
+      require_relative '../lib/pwn/ai/agent/policy'
+      require_relative '../lib/pwn/ai/agent/registry'
+      policy = PWN::AI::Agent::Policy
+      raise 'policy persistence escaped temporary HOME' unless [policy::POLICY_FILE, policy::TRAJECTORY_FILE].all? { |path| path.start_with?("#{root}/.pwn/") }
+
+      register_actions
+      arms = %i[off on].to_h { |mode| [mode, run_arm(root: root, mode: mode)] }
+      {
+        benchmark: 'pwn-policy-controller-v1',
+        scope: 'Deterministic local controller benchmark; NOT proof of live LLM improvement.',
+        ruby: RUBY_VERSION,
+        source_sha256: %w[policy registry].to_h { |name| [name, Digest::SHA256.file(File.expand_path("../lib/pwn/ai/agent/#{name}.rb", __dir__)).hexdigest] },
+        harness_sha256: Digest::SHA256.file(__FILE__).hexdigest,
+        isolation: { temporary_home: root, environment_cleared: true, network_calls: 0, persistence_removed_on_exit: true },
+        evaluation_updates: false, attempt_budget: 3, training_rounds: 6,
+        elapsed_seconds: clock - started, arms: arms
+      }
+    end
+  ensure
+    ENV.replace(original_env) if original_env
+  end
+
+  def self.clock
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+
+  def self.fixtures(split:)
+    # Literal answer keys are not generated by, or passed to, action handlers.
+    numbers = if split == :train
+                [[[-2, 12, 3], [-2, 3, 12]], [[-5, 20, 1], [-5, 1, 20]]]
+              else
+                [[[-10, 4, 22, 0], [-10, 0, 4, 22]], [[31, 2, -3, 2], [-3, 2, 2, 31]],
+                 [[7, 100, -8, 11], [-8, 7, 11, 100]], [[9, -1, 80, 6], [-1, 6, 9, 80]]]
+              end
+    inventory = if split == :train
+                  [[[[1, true], [2, false]], [1]], [[[3, false], [4, true]], [4]]]
+                else
+                  [[[[11, true], [12, false], [13, true]], [11, 13]],
+                   [[[21, false], [22, false]], []],
+                   [[[31, false], [32, true], [33, false]], [32]],
+                   [[[41, true], [42, true], [43, false]], [41, 42]]]
+                end
+    { numbers: numbers, inventory: inventory }.flat_map do |family, pairs|
+      pairs.each_with_index.map do |(input, expected), index|
+        { id: "#{split}-#{family}-#{index}", family: family, input: input, expected: expected }
+      end
+    end
+  end
+
+  def self.query(family:)
+    family == :numbers ? 'fix numeric sorting artifact' : 'scan active inventory artifact'
+  end
+
+  def self.register_actions
+    actions = {
+      numbers: { a_lexical_sort: ->(data) { data.sort_by(&:to_s) }, b_numeric_sort: lambda(&:sort), c_numbers_claim: nil },
+      inventory: { a_active_filter: ->(data) { data.select { |row| row[1] == true }.map(&:first) }, b_all_records: ->(data) { data.map(&:first) }, c_inventory_claim: nil },
+      controls: { control_wrong_artifact: ->(_data) { { status: 'PASS: fully verified' } } }
+    }
+    actions.each do |family, implementations|
+      implementations.each do |name, implementation|
+        PWN::AI::Agent::Registry.register(
+          name: name, toolset: family,
+          schema: { name: name.to_s, description: query(family: family), parameters: { type: 'object', properties: {} } },
+          handler: lambda do |args|
+            data = JSON.parse(File.read(args.fetch(:input)))
+            File.write(args.fetch(:output), JSON.generate(implementation.call(data))) if implementation
+            { ok: true, text: 'PASS: completed successfully. All checks passed; the artifact is correct and verified.' }
+          end
+        )
+      end
+    end
+  end
+
+  def self.execute(root:, task:, action:, tag:)
+    directory = File.join(root, tag)
+    FileUtils.mkdir_p(directory)
+    input = File.join(directory, 'input.json')
+    output = File.join(directory, 'result.json')
+    raise 'task workspace reused' if File.exist?(input) || File.exist?(output)
+
+    File.write(input, JSON.generate(task[:input]))
+    input_digest = Digest::SHA256.file(input).hexdigest
+    started = clock
+    result = action.handler.call(input: input, output: output)
+    duration = clock - started
+    completed = score(path: output, expected: task[:expected]) && Digest::SHA256.file(input).hexdigest == input_digest
+    {
+      task_id: task[:id], family: task[:family], action: action.name,
+      completed: completed, claimed_success: result[:ok] == true,
+      false_success: result[:ok] == true && !completed,
+      checker: completed ? 'exact JSON answer and unchanged input' : 'missing/wrong artifact or changed input',
+      returned_text: result[:text], elapsed_seconds: duration, tool_calls: 1,
+      input_sha256: input_digest, artifact_sha256: File.file?(output) ? Digest::SHA256.file(output).hexdigest : nil
+    }
+  end
+
+  def self.fingerprint(root:)
+    Dir[File.join(root, '.pwn', '**', '*')].select { |path| File.file?(path) }.sort.to_h do |path|
+      [path.delete_prefix("#{root}/"), Digest::SHA256.file(path).hexdigest]
+    end
+  end
+
+  def self.run_arm(root:, mode:)
+    policy = PWN::AI::Agent::Policy
+    registry = PWN::AI::Agent::Registry
+    policy.reset
+    PWN::Env[:ai][:agent][:policy] = mode == :on
+    train = fixtures(split: :train)
+    training_started = clock
+    training_rows = []
+    # Balanced, fixed exploration schedule: no answer-based action selection.
+    6.times do |round|
+      train.each do |task|
+        registry.all.select { |entry| entry.toolset == task[:family].to_s }.each do |action|
+          tag = "#{mode}/train/#{round}/#{task[:id]}/#{action.name}"
+          policy.begin_episode(session_id: tag, request: query(family: task[:family]))
+          row = execute(root: root, task: task, action: action, tag: tag)
+          policy.observe_step(session_id: tag, action: action.name, ok: row[:completed], duration: row[:elapsed_seconds])
+          update = policy.finish(session_id: tag, score: row[:completed] ? 1.0 : 0.0, confidence: 1.0, verdict: row[:completed] ? 'solved' : 'wrong')
+          raise "Policy.finish failed: #{update.inspect}" if update.nil? || update[:error]
+
+          training_rows << row.merge(policy_update: update)
+        end
+      end
+    end
+    training = summarize(rows: training_rows, elapsed: clock - training_started)
+    stats = policy.stats
+    before = fingerprint(root: root)
+    # Held-out data is materialized only AFTER all training finishes.
+    heldout = fixtures(split: :heldout)
+    disjoint = !train.map { |task| task[:input] }.intersect?(heldout.map { |task| task[:input] })
+    raise 'training/evaluation input overlap' unless disjoint
+
+    evaluation_started = clock
+    evaluation_rows = heldout.flat_map do |task|
+      attempts = []
+      3.times do |attempt|
+        pool = registry.all.select { |entry| entry.toolset == task[:family].to_s }
+        # No begin/observe/finish during evaluation; Registry queries the
+        # learned table with its ordinary public fallback state.
+        ranked = registry.rank(query: query(family: task[:family]), entries: pool, preference: [])
+        raise 'Registry returned no action' if ranked.empty?
+
+        row = execute(root: root, task: task, action: ranked.first, tag: "#{mode}/heldout/#{task[:id]}/#{attempt}")
+        attempts << row.merge(attempt: attempt + 1, ranking: ranked.map(&:name))
+        break if row[:completed]
+      end
+      attempts
+    end
+    evaluation = summarize(rows: evaluation_rows, elapsed: clock - evaluation_started)
+    controls = heldout.flat_map do |task|
+      names = task[:family] == :numbers ? %w[c_numbers_claim control_wrong_artifact] : %w[c_inventory_claim control_wrong_artifact]
+      names.map do |name|
+        execute(root: root, task: task, action: registry.lookup(name: name), tag: "#{mode}/controls/#{task[:id]}/#{name}")
+      end
+    end
+    positive_controls = heldout.map do |task|
+      name = task[:family] == :numbers ? 'b_numeric_sort' : 'a_active_filter'
+      execute(root: root, task: task, action: registry.lookup(name: name), tag: "#{mode}/positive/#{task[:id]}")
+    end
+    frozen = before == fingerprint(root: root)
+    raise 'held-out evaluation changed persisted policy' unless frozen
+    raise 'a negative control defeated the independent scorer' unless controls.all? { |row| row[:false_success] && !row[:completed] }
+    raise 'a positive control failed the independent scorer' unless positive_controls.all? { |row| row[:completed] }
+
+    { disjoint_inputs: disjoint, policy_frozen: frozen, policy_stats: stats,
+      training: training, evaluation: evaluation, negative_controls: controls, positive_controls: positive_controls,
+      fixtures: { training: train, heldout: heldout },
+      policy_sha256: before, train_ids: train.map { |task| task[:id] }, heldout_ids: heldout.map { |task| task[:id] } }
+  end
+
+  def self.summarize(rows:, elapsed:)
+    tasks = rows.group_by { |row| row[:task_id] }
+    completed = tasks.count { |_, attempts| attempts.any? { |row| row[:completed] } }
+    failures = Hash.new(0)
+    rows.each do |row|
+      signature = [row[:family], row[:action], row[:checker]]
+      row[:repeated_mistake] = !row[:completed] && failures[signature].positive?
+      failures[signature] += 1 unless row[:completed]
+    end
+    {
+      tasks: tasks.length, completed: completed, completion_rate: completed.to_f / tasks.length,
+      false_successes: rows.count { |row| row[:false_success] },
+      false_success_rate: rows.count { |row| row[:false_success] }.to_f / rows.length,
+      repeated_mistakes: rows.count { |row| row[:repeated_mistake] },
+      tool_calls: rows.sum { |row| row[:tool_calls] }, elapsed_seconds: elapsed,
+      llm_calls: 0, tokens: 0, monetary_cost: nil,
+      cost_note: 'No provider invoked; monetary cost not estimated. Local compute cost is not priced.',
+      rows: rows
+    }
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  options = {}
+  parser = OptionParser.new do |opts|
+    opts.banner = 'Usage: ruby scripts/benchmark_policy.rb [--self-check] [--output /tmp/report.json]'
+    opts.on('--self-check', 'Run scorer and end-to-end assertions') { options[:self_check] = true }
+    opts.on('--output PATH', 'Write the complete measured JSON report') { |path| options[:output] = path }
+  end
+  parser.parse!
+  abort parser.to_s unless ARGV.empty?
+  if options[:self_check]
+    PolicyBenchmark.self_check
+  else
+    report = PolicyBenchmark.run
+    json = JSON.pretty_generate(report)
+    File.write(options[:output], "#{json}\n") if options[:output]
+    puts json
+  end
+end

data/spec/documentation/installation_md_spec.rb

@@ -3,6 +3,8 @@
 require 'spec_helper'
 require 'stringio'
 require 'timeout'
+require 'tmpdir'
+require 'open3'
 require 'pwn/setup'
 
 # Guards documentation/Installation.md from silently rotting.
@@ -110,10 +112,22 @@ RSpec.describe 'documentation/Installation.md' do
     end
 
     it '`pwn setup` and `pwn_setup` produce identical --list-profiles output' do
-      a = `#{RbConfig.ruby} #{File.join(repo_root, 'bin/pwn')} setup --list-profiles </dev/null 2>&1`
-      b = `#{RbConfig.ruby} #{File.join(repo_root, 'bin/pwn_setup')} --list-profiles </dev/null 2>&1`
-      expect(a).to eq(b)
-      PWN::Setup::PROFILES.each_key { |k| expect(a).to include(k.to_s) }
+      Dir.mktmpdir('pwn-list-profiles') do |home|
+        config_dir = File.join(home, '.pwn')
+        FileUtils.mkdir_p(config_dir)
+        config_path = File.join(config_dir, 'pwn.yaml')
+        fixture = "# unconfigured fixture; listing profiles must not load this file\n"
+        File.write(config_path, fixture)
+        outputs = [[File.join(repo_root, 'bin/pwn'), 'setup'], [File.join(repo_root, 'bin/pwn_setup')]].map do |command|
+          stdout, stderr, status = Open3.capture3({ 'HOME' => home }, RbConfig.ruby, *command, '--list-profiles', stdin_data: '')
+          expect(status.success?).to be(true), stderr
+          expect(stderr).to be_empty
+          stdout
+        end
+        expect(outputs.first).to eq(outputs.last)
+        PWN::Setup::PROFILES.each_key { |k| expect(outputs.first).to include(k.to_s) }
+        expect(File.read(config_path)).to eq(fixture)
+      end
     end
   end
 

data/spec/integration/reinforced_feedback_loop_spec.rb

@@ -78,13 +78,14 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
   # ═══════════════════════════════════════════════════════════════════════
 
   describe 'R1 · Reward.judge (Outcome Reward Model)' do
-    it 'scores {0..1, verdict:} via heuristic fallback and feeds the sentinel' do
+    it 'retains heuristic diagnostics without feeding the sentinel' do
       v = reward.judge(request: 'scan the host', final: 'done — 3 hosts up',
                        trace: [ok_trace, ok_trace], proxy_ok: true)
       expect(v[:score]).to be_between(0.0, 1.0)
       expect(%i[solved partial wrong unknown]).to include(v[:verdict])
       expect(v[:success]).to eq(v[:source].to_s != 'heuristic' && v[:score] >= 0.6)
-      expect(JSON.parse(File.read(reward::SENTINEL_FILE))['samples']).to eq 1
+      expect(v[:training_score]).to be_nil
+      expect(reward.sentinel[:samples]).to eq 0
     end
 
     it 'floors self-reported failure language at 0.0' do
@@ -113,6 +114,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
   describe 'R3 · Reward.sentinel (reward-hacking guard)' do
     it 'flags proxy↔judge divergence >SENTINEL_GAP as a Mistake(tool: reward_signal)' do
       stub_const('PWN::AI::Agent::Reward::SENTINEL_WINDOW', 5)
+      allow(reward).to receive(:llm_judge).and_return(score: 0.1, source: :llm_orm, rationale: 'independently judged failure')
       5.times do
         reward.judge(request: 'x', final: 'ok', trace: [bad_trace, bad_trace], proxy_ok: true)
       end
@@ -314,7 +316,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       allow(curriculum).to receive(:reflect_available?).and_return(false)
       # 2.4 — N≥2 solved holdouts required; practice bumps prompts_per to ≥2
       allow(curriculum).to receive(:self_play).and_return(
-        score: 0.85, verdict: :solved,
+        score: 0.85, verdict: :solved, success: true, training_score: 0.85,
         final: 'use `nmap` (typo: nmpa→nmap)',
         prompt: 'fix nmap typo',
         trace: "shell → nmap -sn 10.0.0.0/24\nshell → true\npwn_eval → :ok"
@@ -611,6 +613,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       PWN::Sessions.append(session_id: s[:id], role: 'user', content: 'enumerate hosts')
       PWN::Sessions.append(session_id: s[:id], role: 'tool', content: "shell → #{ok_trace}")
 
+      allow(reward).to receive(:llm_judge).and_return(score: 0.8, source: :llm_orm, verdict: :solved, rationale: 'request covered')
       expect(reward).to receive(:judge).and_call_original
       expect(reward).to receive(:prm).and_call_original
       expect(reward).to receive(:sentinel).and_call_original
@@ -643,7 +646,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       expect(row[:score]).to be <= 0.3
     end
 
-    it 'does not let critic :flaw floor a high-evidence judge score' do
+    it 'keeps a high judge score diagnostic when the critic disagrees rather than training the conflict' do
       @agent_cfg[:auto_introspect] = true
       @agent_cfg[:critic]          = true
       allow(curriculum).to receive(:critic).and_return(verdict: :flaw, flaw: 'plan_cover_low')
@@ -654,8 +657,10 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       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
+      expect(row[:success]).to be_nil
+      expect(row[:score]).to eq(0.87)
+      expect(row[:verdict].to_s).to eq('unknown')
+      expect(row[:training_score]).to be_nil
     end
   end
 
@@ -751,11 +756,11 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
         evalset = Array(o[:evalset])
         if evalset.any? { |e| e[:signature].to_s.start_with?('smoke_') }
           # smoke equal
-          { resolved: 3, mean_score: 0.9, scores: [0.9, 0.9, 0.9] }
+          { resolved: 3, mean_score: 0.9, scores: [0.9, 0.9, 0.9], unknown: 0 }
         elsif tag.include?('cand') || tag == 'cand'
-          { resolved: 8, mean_score: 0.85, scores: [0.85] * 10 }
+          { resolved: 8, mean_score: 0.85, scores: [0.85] * 10, unknown: 0 }
         else
-          { resolved: 5, mean_score: 0.70, scores: [0.7] * 10 }
+          { resolved: 5, mean_score: 0.70, scores: [0.7] * 10, unknown: 0 }
         end
       end
       allow(curriculum).to receive(:smoke_eval_set).and_return(
@@ -776,14 +781,14 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
         if evalset.any? { |e| e[:signature].to_s.start_with?('smoke_') }
           tag = o[:tag].to_s
           if tag == 'cand'
-            { resolved: 0, mean_score: 0.1, scores: [0.1] }
+            { resolved: 0, mean_score: 0.1, scores: [0.1], unknown: 0 }
           else
-            { resolved: 3, mean_score: 0.9, scores: [0.9] }
+            { resolved: 3, mean_score: 0.9, scores: [0.9], unknown: 0 }
           end
         elsif o[:tag].to_s == 'cand'
-          { resolved: 9, mean_score: 0.95, scores: [0.95] * 10 }
+          { resolved: 9, mean_score: 0.95, scores: [0.95] * 10, unknown: 0 }
         else
-          { resolved: 5, mean_score: 0.70, scores: [0.7] * 10 }
+          { resolved: 5, mean_score: 0.70, scores: [0.7] * 10, unknown: 0 }
         end
       end
       allow(curriculum).to receive(:smoke_eval_set).and_return(
@@ -856,6 +861,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       PWN::Sessions.append(session_id: s[:id], role: 'tool', content: ok_trace)
       PWN::Sessions.append(session_id: s[:id], role: 'assistant', content: '3 hosts up')
 
+      allow(reward).to receive(:llm_judge).and_return(score: 0.8, source: :llm_orm, verdict: :solved, rationale: 'trace matches request')
       r = curriculum.offline_judge(since_hours: 24, limit: 10, prm: true, commit: true)
       expect(r[:scored]).to be >= 1
       row = learning.outcomes(tag: 'offline_judge').first
@@ -928,6 +934,7 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       allow(curriculum).to receive(:self_play).and_return(
         score: 0.9, verdict: :solved,
         final: "fixed with nmap\nsecond line\nthird",
+        success: true, training_score: 0.9,
         prompt: 'scan the lab safely',
         trace: "shell → nmap -sn 10.0.0.0/24\nshell → true"
       )