pwn 0.5.702 → 0.5.704

data/lib/pwn/ai/agent/loop.rb

@@ -144,6 +144,15 @@ module PWN
           )
         end
 
+        private_class_method def self.wait_trace_step!(opts = {})
+          return unless defined?(PWN::Plugins::Log) && PWN::Plugins::Log.respond_to?(:wait_trace_step!)
+
+          PWN::Plugins::Log.wait_trace_step!(
+            label: opts[:label],
+            nested: opts[:nested]
+          )
+        end
+
         private_class_method def self.start_debug_session(opts = {})
           return unless debug_on?(opts)
           return unless defined?(PWN::Plugins::Log)
@@ -153,13 +162,14 @@ module PWN
             return
           end
 
-          unless PWN::Plugins::Log.debug_enabled?
-            want_trace = opts[:trace] == true
-            begin
-              want_trace ||= PWN::Env.dig(:ai, :agent, :debug_trace) == true
-            rescue StandardError
-              nil
-            end
+          want_trace = opts[:trace] == true
+          begin
+            want_trace ||= defined?(Pry) && Pry.config.respond_to?(:pwn_ai_trace) && Pry.config.pwn_ai_trace
+          rescue StandardError
+            nil
+          end
+          want_trace ||= PWN::Plugins::Log.trace_enabled? if PWN::Plugins::Log.respond_to?(:trace_enabled?)
+          if !PWN::Plugins::Log.debug_enabled? || want_trace
             PWN::Plugins::Log.start_debug(
               tee: opts[:debug_tee] || $stdout,
               session_id: opts[:session_id],
@@ -934,10 +944,14 @@ module PWN
           nil
         end
 
+        PAYLOAD_SHA256 = Digest::SHA256
+
         private_class_method def self.payload_sig(opts = {})
-          Digest::SHA256.hexdigest("#{opts[:name]}|#{opts[:args]}")[0, 16]
+          blob = "#{opts[:name]}|#{opts[:args]}"
+          PAYLOAD_SHA256.hexdigest(blob)[0, 16]
         rescue StandardError
-          "nosig-#{opts[:name]}"
+          key = "#{opts[:name]}|#{opts[:args]}"
+          "#{opts[:name]}-#{key.hash.abs.to_s(16)[0, 12]}"
         end
 
         private_class_method def self.note_same_payload!(opts = {})
@@ -1742,7 +1756,12 @@ module PWN
             what\s+did\s+you\s+(?:just\s+)?(?:say|answer|reply|respond)|
             what\s+(?:was|is)\s+your\s+(?:last|previous|prior)\s+(?:answer|response|reply)|
             (?:without\s+looking\s+up).{0,40}(?:session|discussing|talking)|
-            (?:from\s+)?(?:memory|context|earlier|previously|prior\s+turn)|
+            from\s+(?:(?:your|my|the)\s+)?(?:memory|context)|
+            in\s+your\s+memory|
+            (?:your|my)\s+memory\s+(?:of|about)|
+            earlier\s+in\s+(?:this\s+)?(?:session|chat|conversation|turn)|
+            previously\s+in\s+(?:this\s+)?(?:session|chat|conversation)|
+            prior\s+turn|
             (?:do\s+you\s+)?remember\s+what\s+(?:i|you)|
             recall\s+(?:what|my|your|the\s+last)|
             last\s+thing\s+(?:i|you)\s+said
@@ -2619,6 +2638,7 @@ module PWN
             end
             engine_s += (Time.now - t0)
             PWN::Plugins::TTYSpinner.halt_all! if defined?(PWN::Plugins::TTYSpinner)
+            wait_trace_step!(label: 'engine', nested: nested)
             if msg.nil?
               task_summary_flush!(state: ts_state, on_tool: on_tool)
               debug_progress(msg: 'engine returned no message')
@@ -2766,6 +2786,7 @@ module PWN
 
               on_tool&.call(name, args, result)
               debug_tool_io!(name: name, args: args, result: result)
+              wait_trace_step!(label: "tool #{name}", nested: nested)
               task_summary_record!(state: ts_state, name: name, args: args, result: result, on_tool: on_tool)
 
               messages << {

data/lib/pwn/ai/agent/tool_guard.rb

@@ -60,23 +60,34 @@ module PWN
         end
 
         # RestClient uses HTTP::CookieJar. pwn_eval in TOPLEVEL_BINDING can
-        # assign HTTP = "/path/http" (a mkdir) and then every provider hop
-        # TypeErrors: "path is not a class/module".
+        # assign HTTP = "/path/http" or Digest = "(self.we" and then every
+        # provider hop / payload_sig TypeErrors.
+        CORE_CONSTS = %i[HTTP Digest JSON URI Timeout].freeze
+
         public_class_method def self.protect_http!
-          if Object.const_defined?(:HTTP, false)
-            cur = Object.const_get(:HTTP)
-            @http_mod = cur if cur.is_a?(Module) && @http_mod.nil?
-            return cur if cur.is_a?(Module)
+          protect_core_constants!
+        end
+
+        public_class_method def self.protect_core_constants!
+          @core_mods ||= {}
+          CORE_CONSTS.each do |name|
+            if Object.const_defined?(name, false)
+              cur = Object.const_get(name, false)
+              @core_mods[name] = cur if cur.is_a?(Module) && @core_mods[name].nil?
+              next if cur.is_a?(Module)
+
+              Object.send(:remove_const, name)
+            end
+            next unless @core_mods[name].is_a?(Module)
+            next if Object.const_defined?(name, false) && Object.const_get(name, false).equal?(@core_mods[name])
 
-            Object.send(:remove_const, :HTTP)
+            Object.const_set(name, @core_mods[name])
           end
-          if @http_mod.is_a?(Module)
-            Object.const_set(:HTTP, @http_mod)
-            return @http_mod
+          unless Object.const_defined?(:HTTP, false) && Object.const_get(:HTTP, false).is_a?(Module)
+            require 'http/cookie_jar'
+            @core_mods[:HTTP] = Object.const_get(:HTTP) if Object.const_defined?(:HTTP) && Object.const_get(:HTTP).is_a?(Module)
           end
-          require 'http/cookie_jar'
-          @http_mod = Object.const_get(:HTTP) if Object.const_defined?(:HTTP) && Object.const_get(:HTTP).is_a?(Module)
-          @http_mod
+          @core_mods
         rescue StandardError
           nil
         end

data/lib/pwn/config.rb

@@ -849,9 +849,11 @@ module PWN
     end
 
     # Seed bundled skills into ~/.pwn/skills (or pwn_skills_path:).
-    # Missing names are copied from etc/default_skills (or a one-level
-    # category subdir such as productivity/<name>). Existing SKILL.md
-    # files are left alone so operator edits survive upgrades.
+    # Every SKILL.md under etc/default_skills is copied, preserving
+    # relative path. SOP SKILL.md files are left alone so operator
+    # edits survive upgrades. Generated module skills under pwn/ are
+    # overwritten by ModuleSkills.install. scripts/ are never copied
+    # from the gem templates.
     public_class_method def self.install_default_skills(opts = {})
       root = opts[:pwn_skills_path] || pwn_skills_path
       src_root = opts[:source] || default_skills_dir
@@ -859,33 +861,17 @@ module PWN
 
       FileUtils.mkdir_p(root)
       seeded = []
-      default_skill_names.each do |name|
-        src_dir = default_skill_src_dir(source: src_root, name: name)
-        dest = File.join(root, name, SKILL_ENTRY)
-        src = File.join(src_dir, SKILL_ENTRY)
-        next unless File.file?(src)
+      each_skill_md(root: src_root) do |src, rel_dir|
+        next if module_skill_rel?(rel: rel_dir)
 
+        dest_dir = File.join(root, rel_dir)
+        dest = File.join(dest_dir, SKILL_ENTRY)
         unless File.file?(dest)
-          FileUtils.mkdir_p(File.dirname(dest))
+          FileUtils.mkdir_p(dest_dir)
           FileUtils.cp(src, dest)
-          seeded << { name: name, path: dest }
-        end
-
-        # Copy missing reference files (never overwrite operator edits).
-        ref_src = File.join(src_dir, 'references')
-        next unless Dir.exist?(ref_src)
-
-        ref_dest = File.join(root, name, 'references')
-        FileUtils.mkdir_p(ref_dest)
-        Dir.children(ref_src).each do |base|
-          from = File.join(ref_src, base)
-          next unless File.file?(from)
-
-          to = File.join(ref_dest, base)
-          next if File.file?(to)
-
-          FileUtils.cp(from, to)
+          seeded << { name: rel_dir, path: dest }
         end
+        copy_missing_references(source_dir: File.dirname(src), dest_dir: dest_dir)
       end
       if defined?(PWN::ModuleSkills) && PWN::ModuleSkills.respond_to?(:install)
         PWN::ModuleSkills.install(
@@ -899,16 +885,82 @@ module PWN
       []
     end
 
-    private_class_method def self.default_skill_src_dir(opts = {})
-      src_root = opts[:source].to_s
-      name = opts[:name].to_s
-      direct = File.join(src_root, name)
-      return direct if File.file?(File.join(direct, SKILL_ENTRY))
+    private_class_method def self.each_skill_md(opts = {})
+      root = opts[:root].to_s.chomp('/')
+      return if root.empty? || !Dir.exist?(root)
+
+      Dir.glob(File.join(root, '**', SKILL_ENTRY)).each do |path|
+        next unless File.file?(path)
+        next if path.include?('/references/')
+        next if path.include?('/scripts/')
 
-      nested = Dir.glob(File.join(src_root, '*', name, SKILL_ENTRY)).min
-      return File.dirname(nested) if nested
+        rel_dir = File.dirname(path).delete_prefix("#{root}/")
+        next if rel_dir.empty? || rel_dir == '.'
+
+        yield path, rel_dir
+      end
+    end
+
+    private_class_method def self.module_skill_rel?(opts = {})
+      rel = opts[:rel].to_s
+      rel == 'pwn' || rel.start_with?('pwn/')
+    end
 
-      direct
+    private_class_method def self.copy_missing_references(opts = {})
+      ref_src = File.join(opts[:source_dir].to_s, 'references')
+      return unless Dir.exist?(ref_src)
+
+      ref_dest = File.join(opts[:dest_dir].to_s, 'references')
+      Dir.glob(File.join(ref_src, '**', '*')).each do |from|
+        next unless File.file?(from)
+
+        rel = from.delete_prefix("#{ref_src}/")
+        to = File.join(ref_dest, rel)
+        next if File.file?(to)
+
+        FileUtils.mkdir_p(File.dirname(to))
+        FileUtils.cp(from, to)
+      end
+    end
+
+    private_class_method def self.ingest_skill_md(opts = {})
+      skills = opts[:skills]
+      entry = opts[:entry].to_s
+      rel_dir = opts[:rel_dir].to_s
+      return skills unless skills.is_a?(Hash)
+      return skills if entry.empty? || rel_dir.empty?
+
+      key = rel_dir.to_sym
+      return skills if skills.key?(key)
+
+      dir = File.dirname(entry)
+      content = File.read(entry)
+      parsed = parse_skill_frontmatter(content: content)
+      fm = parsed[:frontmatter]
+      desc = (fm['description'] || fm[:description]).to_s.strip
+      desc = parsed[:body].to_s.lines.first.to_s.strip.sub(/^#+\s*/, '')[0, 200] if desc.empty?
+      scripts = Dir.glob(File.join(dir, 'scripts', '*.rb'))
+      fmt = module_skill_rel?(rel: rel_dir) ? :module : :agentskills
+      meta = {
+        type: scripts.any? ? :ruby : :instruction,
+        format: fmt,
+        path: entry,
+        dir: dir,
+        content: content,
+        description: desc,
+        frontmatter: fm,
+        references: parse_skill_references(content: content),
+        allowed_tools: Array(fm['allowed-tools'] || fm[:'allowed-tools'] || fm['allowed_tools'])
+      }
+      scripts.each do |rb|
+        require rb
+      rescue StandardError => e
+        meta[:loaded] = false
+        meta[:error] = e.message
+      end
+      meta[:loaded] = true unless meta.key?(:loaded) || scripts.empty?
+      skills[key] = meta
+      skills
     end
 
     # Supported Method Parameters::
@@ -919,7 +971,8 @@ module PWN
     # Loads skills into the PWN::Skills constant. Two on-disk shapes are
     # accepted so upgrades are seamless:
     #
-    #   agentskills.io  →  <root>/<name>/SKILL.md      (preferred; written by write_skill)
+    #   agentskills.io  →  <root>/**/SKILL.md          (recursive; written by write_skill)
+    #   module skills   →  <root>/pwn/**/SKILL.md
     #   legacy flat     →  <root>/<name>.{md,txt,rb,skill,yml,yaml}
     #
     # Each entry: { type:, format:, path:, dir:, content:, description:,
@@ -931,38 +984,8 @@ module PWN
       skills = {}
       return skills unless pwn_skills_path && Dir.exist?(pwn_skills_path.to_s)
 
-      # ── agentskills.io directory layout ───────────────────────────────
-      Dir.glob(File.join(pwn_skills_path, '*', SKILL_ENTRY)).each do |entry|
-        dir     = File.dirname(entry)
-        key     = File.basename(dir).to_sym
-        content = File.read(entry)
-        parsed  = parse_skill_frontmatter(content: content)
-        fm      = parsed[:frontmatter]
-        desc    = (fm['description'] || fm[:description]).to_s.strip
-        desc    = parsed[:body].to_s.lines.first.to_s.strip.sub(/^#+\s*/, '')[0, 200] if desc.empty?
-        scripts = Dir.glob(File.join(dir, 'scripts', '*.rb'))
-
-        meta = {
-          type: scripts.any? ? :ruby : :instruction,
-          format: :agentskills,
-          path: entry,
-          dir: dir,
-          content: content,
-          description: desc,
-          frontmatter: fm,
-          references: parse_skill_references(content: content),
-          allowed_tools: Array(fm['allowed-tools'] || fm[:'allowed-tools'] || fm['allowed_tools'])
-        }
-
-        scripts.each do |rb|
-          require rb
-        rescue StandardError => e
-          meta[:loaded] = false
-          meta[:error]  = e.message
-        end
-        meta[:loaded] = true unless meta.key?(:loaded) || scripts.empty?
-
-        skills[key] = meta
+      each_skill_md(root: pwn_skills_path) do |entry, rel_dir|
+        ingest_skill_md(skills: skills, entry: entry, rel_dir: rel_dir)
       end
 
       # ── legacy flat files (backward-compat shim) ──────────────────────
@@ -998,30 +1021,6 @@ module PWN
         end
       end
 
-      # ── generated module skills: ~/.pwn/skills/pwn/**/SKILL.md ──────
-      Dir.glob(File.join(pwn_skills_path, 'pwn', '**', 'SKILL.md')).each do |skill_file|
-        next if skill_file.include?('/references/')
-
-        rel = skill_file.delete_prefix("#{pwn_skills_path}/").sub(%r{/SKILL\.md\z}, '')
-        key = rel.to_sym
-        next if skills.key?(key)
-
-        content = File.read(skill_file)
-        parsed = parse_skill_frontmatter(content: content)
-        desc = (parsed[:frontmatter]['description'] || parsed[:frontmatter][:description]).to_s.strip
-        desc = parsed[:body].to_s.lines.first.to_s.strip.sub(/^#+\s*/, '')[0, 200] if desc.empty?
-        skills[key] = {
-          type: :instruction,
-          format: :module,
-          path: skill_file,
-          dir: File.dirname(skill_file),
-          content: content,
-          description: desc,
-          frontmatter: parsed[:frontmatter],
-          references: parse_skill_references(content: content)
-        }
-      end
-
       PWN.send(:remove_const, :Skills) if PWN.const_defined?(:Skills)
       PWN.const_set(:Skills, skills.freeze)
       skills

data/lib/pwn/module_skills.rb

@@ -22,7 +22,7 @@ module PWN
 
         found.concat(parse_file(path: path, lib_root: lib))
       end
-      found.uniq { |h| h[:source] }
+      found.uniq { |h| h[:source] }.each { |rec| enrich_live_methods!(rec: rec) }
     end
 
     public_class_method def self.relpath(opts = {})
@@ -132,6 +132,48 @@ module PWN
       { modules: mods.length, written: written, removed: removed, dest: dest }
     end
 
+    public_class_method def self.drift(opts = {})
+      dest = opts[:dest].to_s
+      dest = File.expand_path('../../etc/default_skills', __dir__) if dest.empty?
+      dest = File.dirname(dest) if File.basename(dest) == 'pwn'
+      lib = opts[:lib_root].to_s
+      lib = File.expand_path('..', LIB_ROOT) if lib.empty?
+      mods = enumerate(lib_root: lib)
+      missing = []
+      stale = []
+      keep = {}
+      mods.each do |rec|
+        path = skill_abs(dest: dest, module: rec)
+        dir = File.dirname(path)
+        keep[path] = true
+        if preserved_skill?(path: path)
+          Dir.glob(File.join(dir, 'references', '*.md')).each { |p| keep[p] = true }
+          next
+        end
+
+        if File.file?(path)
+          stale << path if File.read(path) != render(module: rec)
+        else
+          missing << path
+        end
+        Array(rec[:references]).each do |ref|
+          keep[File.join(dir, 'references', ref[:file])] = true
+        end
+      end
+      orphans = []
+      root = File.join(dest, 'pwn')
+      if Dir.exist?(root)
+        Dir.glob(File.join(root, '**', '*')).each do |path|
+          next unless File.file?(path)
+          next if File.basename(path).start_with?('.')
+          next if keep[path]
+
+          orphans << path
+        end
+      end
+      { missing: missing, stale: stale, orphans: orphans, modules: mods.length }
+    end
+
     public_class_method def self.install(opts = {})
       root = opts[:pwn_skills_path]
       root = PWN::Config.pwn_skills_path if root.to_s.empty? && defined?(PWN::Config)
@@ -333,6 +375,33 @@ module PWN
                  .downcase
     end
 
+    private_class_method def self.enrich_live_methods!(opts = {})
+      rec = opts[:rec]
+      return rec unless rec.is_a?(Hash)
+
+      parsed = Array(rec[:methods]).map(&:to_s)
+      extra = live_class_methods(const: rec[:const]) - parsed
+      rec[:methods] = parsed + extra.sort
+      rec
+    end
+
+    private_class_method def self.live_class_methods(opts = {})
+      const = opts[:const].to_s
+      return [] if const.empty?
+
+      mod = const.split('::').inject(Object) do |cur, part|
+        return [] unless cur.is_a?(Module)
+        return [] unless cur.const_defined?(part)
+
+        cur.const_get(part)
+      end
+      return [] unless mod.is_a?(Module)
+
+      mod.singleton_methods(false).map(&:to_s)
+    rescue StandardError
+      []
+    end
+
     private_class_method def self.example_call(opts = {})
       const = opts[:const]
       methods = Array(opts[:methods]) - %w[help authors]
@@ -370,6 +439,7 @@ module PWN
         USAGE:
           #{self}.enumerate
           #{self}.refresh!
+          #{self}.drift
           #{self}.install(pwn_skills_path: '~/.pwn/skills')
           #{self}.authors
       USAGE

data/lib/pwn/plugins/github.rb

@@ -85,7 +85,7 @@ module PWN
       rescue RestClient::Forbidden, RestClient::Unauthorized => e
         @@logger.error("GitHub #{e.class}: #{e.response&.body}")
         raise e
-      rescue RestClient::BadRequest, RestClient::NotFound, StandardError => e
+      rescue StandardError => e
         raise e
       end
 

data/lib/pwn/plugins/log.rb

@@ -23,12 +23,8 @@ module PWN
         PWN::Banner
       ].freeze
       DEFAULT_TRACE_PREFIXES = %w[
-        PWN::AI
-        PWN::Memory
-        PWN::Sessions
-        PWN::Config
-        PWN::Cron
-        PWN::Plugins
+        PWN::AI::Agent::Loop
+        PWN::AI::Agent::Dispatch
       ].freeze
       SECRET_KEY_RX = /password|passwd|secret|token|api[_-]?key|authorization|bearer|cookie|session[_-]?id|private[_-]?key|decryptor|credential|ssh[_-]?key|client[_-]?secret|refresh[_-]?token|access[_-]?token|id[_-]?token|vault|csrf/i
       SECRET_VALUE_RX = %r{
@@ -150,10 +146,13 @@ module PWN
       # /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 = {})
+        want_trace = opts[:trace] == true
         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?
+          @debug_step_io = opts[:step_io] if opts.key?(:step_io)
+          apply_trace!(trace: want_trace, prefixes: opts[:prefixes]) if want_trace
           return @debug_path
         end
 
@@ -165,18 +164,23 @@ module PWN
         @debug_session_id = sanitize_debug_session_id(session_id: opts[:session_id])
         @debug_req_n = 0
         @debug_request_open = false
+        @debug_step_io = opts[:step_io]
         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
+        apply_trace!(trace: want_trace, prefixes: opts[:prefixes])
         install_stderr_tee!
         progress(msg: 'debug session start', which_self: self) if @debug_file
         @debug_path
       end
 
+      public_class_method def self.trace_enabled?
+        @debug_trace == true
+      end
+
       public_class_method def self.next_request_log!(opts = {})
         return unless debug_enabled?
         return @debug_path if @debug_request_open && opts[:force] != true
@@ -226,6 +230,8 @@ module PWN
         @debug_tee = nil
         @debug_tui_quiet = false
         @debug_enabled = false
+        @debug_step = false
+        @debug_step_io = nil
         remove_stderr_tee!
         path
       end
@@ -574,6 +580,16 @@ module PWN
         opts[:key].to_s.match?(SECRET_KEY_RX)
       end
 
+      private_class_method def self.opaque_secret?(opts = {})
+        return false unless opts[:key].to_s == 'value'
+
+        val = opts[:value]
+        return false unless val.is_a?(String)
+        return false if val.length < 24
+
+        val.match?(%r{\A[A-Za-z0-9\-_/=+.]+\z})
+      end
+
       private_class_method def self.sanitize_debug_text(opts = {})
         text = opts[:text].to_s
         text = text.gsub(SECRET_VALUE_RX, '[REDACTED]')
@@ -584,6 +600,7 @@ module PWN
         val = opts[:value]
         key = opts[:key]
         return '[REDACTED]' if secret_key?(key: key)
+        return '[REDACTED]' if opaque_secret?(key: key, value: val)
         return format_debug_hash(hash: val) if val.is_a?(Hash)
         return '[REDACTED]' if val.is_a?(String) && val.match?(SECRET_VALUE_RX)
 
@@ -667,6 +684,7 @@ module PWN
           nil
         end
         @debug_tp.enable
+        @debug_trace = true
         @debug_tp
       end
 
@@ -675,6 +693,50 @@ module PWN
 
         @debug_tp&.disable
         @debug_tp = nil
+        @debug_trace = false
+        @debug_step = false
+      end
+
+      public_class_method def self.wait_trace_step!(opts = {})
+        return unless debug_enabled?
+        return unless @debug_step
+        return if opts[:nested]
+
+        io = @debug_step_io || $stdin
+        return unless io.respond_to?(:gets)
+        return if io.equal?($stdin) && !$stdin.tty?
+
+        label = opts[:label].to_s
+        label = 'loop' if label.empty?
+        progress(msg: "trace step #{label} — Press ENTER to Continue...", which_self: self, tee: nil)
+        prompt_trace_enter!
+        io.gets
+        true
+      rescue StandardError
+        nil
+      end
+
+      private_class_method def self.prompt_trace_enter!(opts = {})
+        return if opts[:skip]
+
+        tee = @debug_tee
+        return unless tee.respond_to?(:puts)
+
+        tee.print("\e[31mPress ENTER to Continue...\e[0m")
+        tee.flush if tee.respond_to?(:flush)
+        $stdout.flush if $stdout.respond_to?(:flush)
+      rescue StandardError
+        nil
+      end
+
+      private_class_method def self.apply_trace!(opts = {})
+        if opts[:trace]
+          @debug_step = true
+          start_trace!(prefixes: opts[:prefixes])
+          @debug_trace = true
+        else
+          @debug_step = false
+        end
       end
 
       # Author(s):: 0day Inc. <support@0dayinc.com>
@@ -703,7 +765,8 @@ module PWN
           #{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)
+          # start_debug(trace: true) enables TracePoint + ENTER after each Loop step
+          # (toggle-trace). Stored on Pry.config.pwn_ai_trace, not Env.
         "
       end
     end