pwn 0.5.686 → 0.5.688

data/lib/pwn/plugins/log.rb

@@ -13,6 +13,9 @@ module PWN
         authors help to_s inspect class object_id hash eql? == equal? !
         method public_send send __send__ instance_eval class_eval
         public_class_method private_class_method
+        debug_on? debug_progress start_debug_session quiet_debug_tui!
+        loud_debug_tui! budget_scar? effective_count safe_check
+        rank_for_request usable_preference? cause_crumb
       ].freeze
       TRACE_SKIP_PREFIXES = %w[
         PWN::Plugins::Log
@@ -107,6 +110,7 @@ module PWN
 
           if msg.instance_of?(Interrupt)
             logger.level = Logger::WARN
+            note_interrupt!(where: 'CTRL+C', which_self: which_self) if debug_enabled?
             if driver_name == 'pwn'
               log_event += ' => CTRL+C Detected.'
             else
@@ -124,6 +128,7 @@ module PWN
 
         logger.add(logger.level, log_event, which_self)
       rescue Interrupt
+        note_interrupt!(where: 'CTRL+C', which_self: self) if debug_enabled?
         puts "\n#{self}.#{__method__} => Goodbye."
       rescue StandardError => e
         raise e
@@ -141,33 +146,69 @@ module PWN
         @debug_path
       end
 
-      # Open /tmp/pwn-ai-DEBUG-TIMESTAMP.log, tee the same lines to the TUI
-      # (opts[:tee]), and TracePoint PWN modules that process a pwn-ai request.
-      DEBUG_LOG_MAX = 1_024_000
-
+      # Open a debug session. Request traces go to
+      # /tmp/pwn-ai-DEBUG-<session_id>-RN.log via next_request_log!.
+      # opts[:path] is a test override that writes to one file.
       public_class_method def self.start_debug(opts = {})
-        return @debug_path if debug_enabled? && opts.is_a?(Hash)
+        if debug_enabled? && opts[:path].to_s.empty?
+          @debug_tee = opts[:tee] if opts.key?(:tee)
+          sid = sanitize_debug_session_id(session_id: opts[:session_id])
+          @debug_session_id = sid unless sid.empty?
+          return @debug_path
+        end
 
-        ts = Time.now.strftime('%Y%m%d-%H%M%S')
+        stop_trace! if @debug_tp
         path = opts[:path].to_s
-        path = "/tmp/pwn-ai-DEBUG-#{ts}.1.log" if path.empty?
-        stem, idx = debug_path_parts(path: path)
-        path = "#{stem}.#{idx}.log"
-        FileUtils.mkdir_p(File.dirname(path))
-        io = File.open(path, 'a')
-        io.sync = true
-        @debug_file = io
-        @debug_path = path
-        @debug_stem = stem
-        @debug_index = idx
         @debug_tee = opts[:tee]
         @debug_tui_quiet = false
         @debug_enabled = true
-        start_trace!(prefixes: opts[:prefixes]) unless opts[:trace] == false
-        progress(msg: "debug session start path=#{path}", which_self: self)
+        @debug_session_id = sanitize_debug_session_id(session_id: opts[:session_id])
+        @debug_req_n = 0
+        @debug_request_open = false
+        if path.empty?
+          close_debug_file!
+          @debug_path = nil
+        else
+          open_debug_file!(path: path)
+        end
+        start_trace!(prefixes: opts[:prefixes]) if opts[:trace] == true
+        progress(msg: 'debug session start', which_self: self) if @debug_file
+        @debug_path
+      end
+
+      public_class_method def self.next_request_log!(opts = {})
+        return unless debug_enabled?
+        return @debug_path if @debug_request_open && opts[:force] != true
+
+        sid = sanitize_debug_session_id(session_id: opts[:session_id])
+        sid = @debug_session_id if sid.empty?
+        sid = 'nosession' if sid.empty?
+        @debug_session_id = sid
+        n = next_debug_request_n(session_id: sid)
+        path = "/tmp/pwn-ai-DEBUG-#{sid}-R#{n}.log"
+        open_debug_file!(path: path)
+        @debug_req_n = n
+        @debug_request_open = true
+        progress(msg: "request log R#{n} path=#{path}", which_self: self)
         path
       end
 
+      public_class_method def self.finish_request_log!(opts = {})
+        return unless debug_enabled?
+        return unless @debug_request_open || opts[:force] == true
+
+        bits = [
+          "footer iter=#{opts[:iter].to_i}",
+          "tools_called=#{opts[:tools_called].to_i}",
+          "engine_s=#{opts[:engine_s].to_f.round(3)}",
+          "final_chars=#{opts[:final_chars].to_i}"
+        ]
+        bits << "nested=#{opts[:nested]}" unless opts[:nested].to_s.empty?
+        progress(msg: bits.join(' '), which_self: self)
+        @debug_request_open = false
+        @debug_path
+      end
+
       public_class_method def self.stop_debug(opts = {})
         reason = opts[:reason].to_s if opts.is_a?(Hash)
         if debug_enabled?
@@ -175,37 +216,49 @@ module PWN
           progress(msg: tail, which_self: self)
         end
         stop_trace!
-        begin
-          @debug_file&.close unless @debug_file.nil? || @debug_file.closed?
-        rescue StandardError
-          nil
-        end
         path = @debug_path
-        @debug_file = nil
+        close_debug_file!
         @debug_path = nil
-        @debug_stem = nil
-        @debug_index = nil
+        @debug_session_id = nil
+        @debug_req_n = nil
+        @debug_request_open = false
         @debug_tee = nil
         @debug_tui_quiet = false
         @debug_enabled = false
         path
       end
 
-      private_class_method def self.debug_path_parts(opts = {})
-        path = opts[:path].to_s
-        return [Regexp.last_match(1), Regexp.last_match(2).to_i] if path =~ /\A(.+)\.(\d+)\.log\z/
+      private_class_method def self.sanitize_debug_session_id(opts = {})
+        opts[:session_id].to_s.gsub(/[^A-Za-z0-9._-]/, '_')[0, 80]
+      end
 
-        [path.sub(/\.log\z/, ''), 1]
+      private_class_method def self.next_debug_request_n(opts = {})
+        sid = sanitize_debug_session_id(session_id: opts[:session_id])
+        max_n = 0
+        Dir.glob("/tmp/pwn-ai-DEBUG-#{sid}-R*.log").each do |p|
+          n = p[/-R(\d+)\.log\z/, 1].to_i
+          max_n = n if n > max_n
+        end
+        max_n + 1
       end
 
-      private_class_method def self.roll_debug_log!(opts = {})
+      private_class_method def self.close_debug_file!(opts = {})
         return if opts[:skip]
-        return if @debug_file.nil? || @debug_file.closed?
-        return if @debug_file.size < DEBUG_LOG_MAX
 
-        @debug_file.close
-        @debug_index = @debug_index.to_i + 1
-        path = "#{@debug_stem}.#{@debug_index}.log"
+        begin
+          @debug_file&.close unless @debug_file.nil? || @debug_file.closed?
+        rescue StandardError
+          nil
+        end
+        @debug_file = nil
+      end
+
+      private_class_method def self.open_debug_file!(opts = {})
+        path = opts[:path].to_s
+        return if path.empty?
+
+        close_debug_file!
+        FileUtils.mkdir_p(File.dirname(path))
         io = File.open(path, 'a')
         io.sync = true
         @debug_file = io
@@ -233,11 +286,15 @@ module PWN
         Thread.current[:pwn_log_progress] = true
         msg = sanitize_debug_text(text: opts[:msg].to_s)
         which = opts[:which_self] || self
-        line = format_progress(msg: msg, which_self: which)
+        line = format_progress(
+          msg: msg,
+          which_self: which,
+          keep_newlines: opts[:keep_newlines],
+          cap: opts[:cap]
+        )
         begin
           @debug_file&.puts(line)
           @debug_file&.flush
-          roll_debug_log!
         rescue StandardError
           nil
         end
@@ -245,6 +302,8 @@ module PWN
         if !@debug_tui_quiet && tee.respond_to?(:puts)
           begin
             tee.puts(color_progress(line: line))
+            tee.flush if tee.respond_to?(:flush)
+            $stdout.flush if $stdout.respond_to?(:flush)
           rescue StandardError
             nil
           end
@@ -254,8 +313,88 @@ module PWN
         Thread.current[:pwn_log_progress] = false
       end
 
+      public_class_method def self.note_interrupt!(opts = {})
+        return false unless debug_enabled?
+
+        where = opts[:where].to_s
+        where = 'CTRL+C' if where.empty?
+        # CTRL+C can land mid-progress (HTTP spinner tee, tool row mirror).
+        # Clear the reentrancy latch so the Interrupt stamp always lands in the
+        # open RN file before the ensure footer / process unwind.
+        Thread.current[:pwn_log_progress] = false
+        at = Time.now
+        local_ts = at.strftime('%Y-%m-%d %H:%M:%S.%L%z')
+        msg = "Interrupt #{where} at=#{at.utc.iso8601(3)}"
+        which = opts[:which_self] || self
+        # Prefer the normal DEBUG stamp path; fall back to a direct file write
+        # if progress is still unavailable for any reason.
+        ok = progress(msg: msg, which_self: which)
+        unless ok
+          begin
+            who = which.is_a?(Module) ? (which.name || which.to_s) : which.to_s
+            line = "[DEBUG #{local_ts}] #{who} #{msg}".strip
+            @debug_file&.puts(line)
+            @debug_file&.flush
+            ok = true
+          rescue StandardError
+            ok = false
+          end
+        end
+        # Also clone the operator-facing TUI shape into the RN file.
+        mirror_tui!(msg: "[ #{local_ts} → pwn-ai → Interrupt ] #{where}")
+        ok
+      end
+
+      public_class_method def self.note_exception!(opts = {})
+        return false unless debug_enabled?
+
+        err = opts[:error]
+        return false unless err.respond_to?(:message)
+
+        where = opts[:where].to_s
+        where = 'Loop.run' if where.empty?
+        bt = Array(err.backtrace).join("\n")
+        progress(
+          msg: "exception #{where} #{err.class}: #{err.message}\n#{bt}",
+          which_self: opts[:which_self] || self,
+          keep_newlines: true,
+          cap: 0
+        )
+      end
+
+      # Clone operator-visible TUI rows into the open RN request log (no ANSI).
+      # Used for [ ts → pwn-ai → tool ] / → result / task briefs so the file
+      # matches what the operator saw without needing a TracePoint dump.
+      public_class_method def self.mirror_tui!(opts = {})
+        return unless debug_enabled?
+        return unless opts.is_a?(Hash)
+
+        text = opts[:msg].to_s
+        text = text.gsub(/\e\[[0-9;]*m/, '')
+        text = sanitize_debug_text(text: text)
+        return if text.strip.empty?
+
+        begin
+          io = @debug_file
+          return if io.nil? || (io.respond_to?(:closed?) && io.closed?)
+
+          io.write(text.end_with?("\n") ? text : "#{text}\n")
+          io.flush
+        rescue StandardError
+          return
+        end
+        text
+      end
+
       private_class_method def self.format_progress(opts = {})
-        msg = opts[:msg].to_s.tr("\n", ' ')[0, 4_000]
+        cap = if opts.key?(:cap)
+                opts[:cap].to_i
+              else
+                4_000
+              end
+        msg = opts[:msg].to_s
+        msg = msg.tr("\n", ' ') unless opts[:keep_newlines]
+        msg = msg[0, cap] if cap.positive? && msg.length > cap
         which = opts[:which_self]
         who = if which.is_a?(Module)
                 (which.name || which.to_s).to_s
@@ -271,7 +410,7 @@ module PWN
 
       private_class_method def self.color_progress(opts = {})
         line = opts[:line].to_s
-        "\001\e[35m\002#{line}\001\e[0m\002"
+        "\e[35m#{line}\e[0m"
       end
 
       private_class_method def self.trace_module_name(opts = {})
@@ -414,10 +553,13 @@ module PWN
 
           path = #{self}.start_debug(
             tee: $stdout,
-            path: 'optional - defaults to /tmp/pwn-ai-DEBUG-TIMESTAMP.log'
+            session_id: 'optional - pwn-ai session id'
           )
+          #{self}.next_request_log!(session_id: 'optional')
           #{self}.progress(msg: 'stage', which_self: self)
+          #{self}.finish_request_log!(iter: 1, tools_called: 0, engine_s: 0.2, final_chars: 12)
           #{self}.stop_debug
+          # start_debug(trace: true) enables per-call TracePoint (opt-in)
         "
       end
     end

data/lib/pwn/plugins/repl.rb

@@ -471,15 +471,14 @@ module PWN
             PWN::Config.load_memory
             mem_count = (PWN.const_defined?(:Memory) ? PWN::Memory.load.keys.length : 0)
             sess = begin
-              PWN::Sessions.create(title: "pwn-ai #{Time.now.strftime('%Y-%m-%d %H:%M')}", source: 'pwn-ai-repl')
+              PWN::Sessions.create(title: "pwn-ai #{Time.now.strftime('%Y-%m-%d %H:%M')}", source: 'pwn-ai')
             rescue StandardError
               nil
             end
             pi.config.pwn_ai_session_id = sess[:id] if sess
             cron_count = (PWN.const_defined?(:Cron) ? PWN::Cron.list.keys.length : 0)
 
-            puts "\
-[*] pwn-ai agent TUI activated (PWN REPL driver w/ memory, sessions, delegation, cron)."
+            puts '[*] pwn-ai agent TUI activated (PWN REPL driver w/ memory, sessions, delegation, cron).'
             puts "[*] Memory facts: #{mem_count} | Session: #{pi.config.pwn_ai_session_id} | Cron jobs: #{cron_count} | Skills: #{skills_count}"
             puts '[*] Instruct the AI agent to carry out a task, e.g.:'
             puts "    'Use NmapIt to port scan target.com then use TransparentBrowser to spider and SAST::TestCaseEngine to analyze code if cloned. Generate report with PWN::Reports.'"
@@ -488,6 +487,8 @@ module PWN
             puts "[*] Type 'back' to exit pwn-ai mode."
             puts '[*] MULTILINE in pwn-ai: SHIFT+ENTER (or ALT+ENTER, or trailing `\\`) inserts a newline; ENTER submits to the AI.'
             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 → /tmp/pwn-ai-DEBUG-#{tag}-R<REQUEST_NUMBER>.log"
           end
         end
 
@@ -1043,8 +1044,8 @@ module PWN
           end
         end
 
-        Pry::Commands.create_command 'toggle-pwn-ai-debug' do
-          description 'Stream pwn-ai module progress to the TUI and /tmp/pwn-ai-DEBUG-TIMESTAMP.log'
+        Pry::Commands.create_command 'toggle-debug' do
+          description 'Stream pwn-ai stage log to the TUI and /tmp/pwn-ai-DEBUG-<SESSION_ID>-RN.log (trace: Env ai.agent.debug_trace)'
 
           def process
             pi = pry_instance
@@ -1057,9 +1058,10 @@ module PWN
                 output.puts 'pwn-ai debug OFF'
               end
             else
-              path = PWN::Plugins::Log.start_debug(tee: output)
+              sid = pi.config.pwn_ai_session_id
+              PWN::Plugins::Log.start_debug(tee: output, session_id: sid)
               pi.config.pwn_ai_debug = true
-              output.puts "pwn-ai debug ON → #{path}"
+              output.puts 'pwn-ai debug ON.'
             end
           end
         end
@@ -1205,22 +1207,49 @@ module PWN
                 # belong only to the subsequent per-tool lines (one-to-many).
                 on_tool = lambda do |name, args, result|
                   # Task summaries are shown in their entirety (multi-line OK).
-                  # Per-tool arg previews stay capped so the TUI stays readable.
+                  # Tool request + result are shown in full (no char cap).
+                  # Raw ANSI only — PS1 SOH/STX on live stdout swallows later rows.
+                  # When debug is on, the same plain text is mirrored into the
+                  # open /tmp pwn-ai-DEBUG-…-RN.log for human troubleshooting.
+                  mirror = lambda do |plain|
+                    next unless pi.config.pwn_ai_debug && defined?(PWN::Plugins::Log)
+
+                    PWN::Plugins::Log.mirror_tui!(msg: plain)
+                  end
                   if name.to_s == 'task'
                     body = args.is_a?(String) ? args.to_s : args.inspect
                     timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S%z')
-                    print "\001\e[33m\002[ #{timestamp} → pwn-ai → task ]\001\e[0m\002\s"
-                    body.to_s.each_line { |ln| puts "\001\e[32m\002  #{ln.rstrip}\001\e[0m\002" }
-                    # Never pair a result row with a task brief
+                    header = "[ #{timestamp} → pwn-ai → task ]"
+                    print "\e[33m#{header}\e[0m "
+                    body_out = +''
+                    body.to_s.each_line do |ln|
+                      puts "\e[32m  #{ln.rstrip}\e[0m"
+                      body_out << "  #{ln.rstrip}\n"
+                    end
+                    mirror.call("#{header}\n#{body_out}")
                     next
                   end
 
-                  arg_preview = args.is_a?(String) ? args[0, 280] : args.inspect[0, 280]
+                  argv = args.is_a?(String) ? args.to_s : args.inspect
                   timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S%z')
-                  puts "\001\e[33m\002[ #{timestamp} → pwn-ai → #{name} ]\001\e[0m\002 #{arg_preview}"
+                  header = "[ #{timestamp} → pwn-ai → #{name} ]"
+                  puts "\e[33m#{header}\e[0m"
+                  argv_out = +''
+                  argv.to_s.each_line do |ln|
+                    puts "\e[33m  #{ln.rstrip}\e[0m"
+                    argv_out << "  #{ln.rstrip}\n"
+                  end
 
                   timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S%z')
-                  puts "\001\e[36m\002#{timestamp} → result → #{result.to_s[0, 700]}\001\e[0m\002\n"
+                  res_header = "#{timestamp} → result"
+                  puts "\e[36m#{res_header}\e[0m"
+                  res_out = +''
+                  result.to_s.each_line do |ln|
+                    puts "\e[36m  #{ln.rstrip}\e[0m"
+                    res_out << "  #{ln.rstrip}\n"
+                  end
+                  puts
+                  mirror.call("#{header}\n#{argv_out}#{res_header}\n#{res_out}\n")
                 end
                 final = PWN::AI::Agent::Loop.run(
                   request: orig_request,
@@ -1231,8 +1260,9 @@ module PWN
                   debug_tee: $stdout
                 )
                 $stdout.flush
-                puts "\n\001\e[32m\002#{final}\001\e[0m\002\n\n"
+                puts "\n\e[32m#{final}\e[0m\n\n"
                 $stdout.flush
+                PWN::Plugins::Log.mirror_tui!(msg: "\n#{final}\n\n") if pi.config.pwn_ai_debug && defined?(PWN::Plugins::Log)
                 if pi.config.pwn_ai_debug && sess_id && PWN.const_defined?(:Sessions)
                   PWN::Plugins::Log.progress(
                     msg: "session=#{sess_id}",
@@ -1241,7 +1271,12 @@ module PWN
                 end
                 request.replace('nil')
                 next
+              rescue Interrupt
+                Thread.current[:pwn_log_progress] = false
+                PWN::Plugins::Log.note_interrupt!(where: 'CTRL+C', which_self: PWN::Plugins::REPL) if pi.config.pwn_ai_debug && defined?(PWN::Plugins::Log)
+                raise
               rescue StandardError => e
+                PWN::Plugins::Log.note_exception!(error: e, where: 'native agent loop', which_self: PWN::Plugins::REPL) if defined?(PWN::Plugins::Log) && PWN::Plugins::Log.respond_to?(:note_exception!)
                 warn "[pwn-ai] native agent loop failed (#{e.class}: #{e.message}\n#{e.backtrace}); " \
                      'falling back to legacy regex-ReAct.'
               ensure

data/lib/pwn/plugins/transparent_browser.rb

@@ -41,6 +41,17 @@ module PWN
         raise e
       end
 
+      private_class_method def self.apply_driver_timeouts!(opts = {})
+        browser = opts[:browser_obj].is_a?(Hash) ? opts[:browser_obj][:browser] : nil
+        return unless browser.respond_to?(:driver)
+
+        timeouts = browser.driver.manage.timeouts
+        timeouts.page_load = 45
+        timeouts.script = 30
+      rescue StandardError
+        nil
+      end
+
       # Supported Method Parameters::
       # browser_obj1 = PWN::Plugins::TransparentBrowser.open(
       #   browser_type: 'optional - :firefox|:chrome|:headless|:rest|:websocket (defaults to :chrome)',
@@ -66,8 +77,10 @@ module PWN
         devtools = opts[:devtools] ||= false
         devtools = true if devtools_supported.include?(browser_type) && devtools
 
-        # Let's crank up the default timeout from 30 seconds to 15 min for slow sites
-        Watir.default_timeout = 900
+        # Element waits (Watir) vs navigation (Selenium page_load) are
+        # separate. 900s element waits made Wix browser.links.map hang for
+        # hours. Keep navigation bounded too.
+        Watir.default_timeout = 15 unless %i[rest websocket].include?(browser_type)
 
         args = []
         # args.push('--start-maximized')
@@ -365,6 +378,7 @@ module PWN
           browser_obj[:devtools] = browser_obj[:browser].driver.bidi if firefox_types.include?(browser_type)
         end
 
+        apply_driver_timeouts!(browser_obj: browser_obj)
         browser_obj
       rescue StandardError => e
         puts e.backtrace

data/lib/pwn/sessions.rb

@@ -48,7 +48,7 @@ module PWN
     # Supported Method Parameters::
     #   session = PWN::Sessions.create(
     #     title: 'optional - human title',
-    #     source: 'optional - e.g. pwn-ai-repl',
+    #     source: 'optional - e.g. pwn-ai',
     #     id: 'optional - fixed session id (tests / replay); default timestamp_hex'
     #   )
     public_class_method def self.create(opts = {})
@@ -220,6 +220,54 @@ module PWN
       }
     end
 
+    # Current-session conversation for the next LLM call. User + assistant
+    # only (no tool/observation). Always on — not gated by recall wording.
+    # Tail-window by max_chars so a long JSONL cannot blow the context.
+    #
+    #   msgs = PWN::Sessions.to_llm_messages(
+    #     session_id: 'required',
+    #     max_chars: 'optional - keep newest turns under this (default 48_000)',
+    #     skip_request: 'optional - drop a trailing user line equal to this'
+    #   )
+    public_class_method def self.to_llm_messages(opts = {})
+      sid = opts[:session_id]
+      return [] if sid.to_s.empty?
+
+      max_chars = opts[:max_chars].to_i
+      max_chars = 48_000 if max_chars <= 0
+      skip = opts[:skip_request].to_s
+      rows = load(session_id: sid).select do |row|
+        next false unless row.is_a?(Hash)
+
+        role = row[:role].to_s
+        next false unless %w[user assistant].include?(role)
+
+        body = row[:content].to_s
+        next false if body.strip.empty?
+
+        true
+      end
+      if !skip.empty? && rows.last && rows.last[:role].to_s == 'user' && rows.last[:content].to_s == skip
+        rows = rows[0...-1]
+      elsif !skip.empty?
+        rows = rows.reject { |row| row[:role].to_s == 'user' && row[:content].to_s == skip }
+      end
+
+      picked = []
+      used = 0
+      rows.reverse_each do |row|
+        body = row[:content].to_s
+        n = body.length
+        break if picked.any? && (used + n) > max_chars
+
+        picked.unshift(role: row[:role].to_s, content: body)
+        used += n
+      end
+      picked
+    rescue StandardError
+      []
+    end
+
     # Supported Method Parameters::
     #   PWN::Sessions.delete(
     #     session_id: 'required',
@@ -497,6 +545,7 @@ module PWN
           PWN::Sessions.append(session_id: sess[:id], role: 'user', content: 'Run NmapIt...')
           transcript = PWN::Sessions.load(session_id: sess[:id])
           hist = PWN::Sessions.to_response_history(session_id: sess[:id])
+          msgs = PWN::Sessions.to_llm_messages(session_id: sess[:id])
           PWN::Sessions.recall(query: 'hping3', exclude_session_id: sess[:id])
           PWN::Sessions.previous_id(exclude_session_id: sess[:id])
           PWN::Sessions.list

data/lib/pwn/version.rb

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

data/spec/integration/reinforced_feedback_loop_spec.rb

@@ -423,6 +423,8 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
 
       hint = curriculum.red_team_plan(request: 'goal', plan: "1. shell nmap\n2. shell msfconsole")
       expect(hint).to start_with('[pwn-ai/red_team]')
+      src = File.read(curriculum.method(:red_team_plan).source_location.first)
+      expect(src).to match(/text_only:\s*true/)
     end
   end
 
@@ -1478,23 +1480,19 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
       expect(src).not_to match(/n = \[n, hot_cap\]\.min/)
     end
 
-    it 'forces tools=nil on last iter and skips counterfactual when budget-hot' do
+    it 'never strips tools because a round cap is about to fire' do
       src = File.read(loop_mod.method(:run).source_location.first)
-      expect(src).to match(/FINAL ITERATION/)
-      expect(src).to match(/last_iter \? nil : tools/)
-      # CF gate requires !budget_exhaustion_hot?
+      expect(src).not_to match(/FINAL ITERATION/)
+      expect(src).not_to match(/last_iter \? nil : tools/)
       expect(src).to match(/!budget_exhaustion_hot\?/)
       expect(src).to match(/Curriculum\.counterfactual/)
     end
 
-    it 'exhaust path appends session + auto_introspect (not bare string only)' do
+    it 'does not return a budget-exhausted canned final' do
       src = File.read(loop_mod.method(:run).source_location.first)
-      idx = src.index('shape: :budget_exhausted')
-      expect(idx).not_to be_nil
-      tail = src[idx, 800]
-      expect(tail).to match(/append_session/)
-      expect(tail).to match(/auto_introspect/)
-      expect(tail).to match(/final_msg/)
+      expect(src).not_to match(/shape: :budget_exhausted/)
+      expect(src).not_to match(/iteration budget exhausted/)
+      expect(src).to match(/may_finalize\?/)
     end
 
     it 'STATUS table lists Budget exhaust deepen' do