pwn 0.5.696 → 0.5.698

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 74bfcd98ff2b783dab4bfc6d97a3f8124e00c395f686c05303002e312d5b9596
-  data.tar.gz: 54d5d1abe1a695c1fb9dd7757becf2648857ff46dd96d9462ee5f73219a13146
+  metadata.gz: c333795b07ea88fb7ea338e6b01faf768c62bd07757328fc1698972d43a6c5e8
+  data.tar.gz: 0cfbe454002f7ffc79571162a96367aaf3d69017d997cb024c4a475ac3bbab7b
 SHA512:
-  metadata.gz: b60265a293cf56ae14e0ff8d3f822faa36ea0b530f6d01c2a9bbd5b2c3256ab3525df45f964a13939c77672c76e4c0b67647baeca3c1faf2f987ff9221a04999
-  data.tar.gz: b600f46b403f45c2418640a9047653759200d4aca46d2d0571992e6ae1d8501f40c1b28fb9515c2d38b9f313932b4441443b57c61c250b0560b7d5466df7bf43
+  metadata.gz: 7a699a8308cb00f04bdf85869647ec381009daf04fe4d8c972c62d5ed57b819b4b719672fe4ad64966c316520a2496bdeb4914c002f526e886b877f7b5d11928
+  data.tar.gz: 5b2d1fa1f979bc4852304ed09b7122817a71689114f4c4f6a1a46798b01e9d3bb186b8af28aa8d08288c470b01d323735fb252ccc9c45426835d8b717ca8e382

data/etc/default_skills/pwn/ai/agent/tool_guard/SKILL.md

@@ -42,6 +42,11 @@ PWN::AI::Agent::ToolGuard.present(opts)
 - `invalid_payload`
 - `host_load`
 - `deadline_s`
+- `reset_timeout_budget`
+- `mutation_count`
+- `payload_spent`
+- `note_timeout`
+- `next_timeout`
 - `timeout_lesson`
 - `timeout_result`
 - `timeout_prior_count`

data/etc/default_skills/pwn/ai/http_retry/SKILL.md

@@ -35,6 +35,7 @@ PWN::AI::HttpRetry.timeout_s(opts)
 
 - `timeout_s`
 - `max_attempts`
+- `retryable`
 - `retry_after_s`
 - `report_event`
 - `authors`

data/etc/default_skills/pwn/plugins/repl/SKILL.md

@@ -46,6 +46,13 @@ PWN::Plugins::REPL.ready_tty(opts)
 - `install_pwn_ai_completer`
 - `restore_pwn_ai_completer`
 - `pwn_ai_dispatch_slash`
+- `pwn_ai_engines`
+- `pwn_ai_provider_class`
+- `pwn_ai_model_ids`
+- `pwn_ai_list_llms`
+- `pwn_ai_engine_model`
+- `pwn_ai_run_model`
+- `persist_ai_selection`
 - `pwn_ai_run_cron`
 - `pwn_ai_run_sessions`
 - `pwn_ai_run_memory`

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

@@ -822,7 +822,8 @@ module PWN
               lesson = ToolGuard.timeout_lesson(
                 tool: name,
                 payload: opts[:args].to_s,
-                timeout: err.to_s[/timeout after (\d+)/, 1].to_i
+                timeout: err.to_s[/timeout after (\d+)/, 1].to_i,
+                task: timeout_task(opts)
               )
               err = lesson[:error] if lesson[:error].to_s.strip.length.positive?
               shape = :timeout
@@ -835,6 +836,32 @@ module PWN
           { ok: true, err: nil, mistake: nil }
         end
 
+        private_class_method def self.timeout_task(opts = {})
+          st = opts[:ts_state]
+          if st.respond_to?(:[])
+            idx = st[:plan_idx] || st['plan_idx']
+            return "task-#{idx}" unless idx.nil?
+          end
+          if st.respond_to?(:plan_idx)
+            idx = st.plan_idx
+            return "task-#{idx}" unless idx.nil?
+          end
+          opts[:session_id].to_s
+        rescue StandardError
+          opts[:session_id].to_s
+        end
+
+        private_class_method def self.engine_transient?(opts = {})
+          err = opts[:error]
+          return false unless err
+
+          return PWN::AI::HttpRetry.retryable?(error: err) if defined?(PWN::AI::HttpRetry) && PWN::AI::HttpRetry.respond_to?(:retryable?)
+
+          err.message.to_s.match?(/HTTP 50[234]|Gateway Time-out|stream absolute timeout/i)
+        rescue StandardError
+          false
+        end
+
         # E1 — did the environment change under this tool? If Metrics CUSUM
         # tripped for it in the last hour AND Extrospection.drift shows a
         # toolchain/net/repo change, blame the WORLD not the AGENT.
@@ -2271,6 +2298,7 @@ module PWN
           start_debug_session(opts)
           loud_debug_tui!(debug: opts[:debug])
           debug_progress(msg: "Loop.run start request=#{request[0, 240]}", debug: opts[:debug])
+          ToolGuard.reset_timeout_budget! if defined?(ToolGuard) && ToolGuard.respond_to?(:reset_timeout_budget!)
           nested = defined?(TurnFinalizer) && TurnFinalizer.user_path?
           TurnFinalizer.enter_user_path! if defined?(TurnFinalizer)
           engine = active_engine
@@ -2456,6 +2484,7 @@ module PWN
 
           turn_fails = Hash.new(0)
           escalated  = false
+          engine_blips = 0
           maybe_park_budget_scars!
           maybe_extinguish_parked!
 
@@ -2469,7 +2498,27 @@ module PWN
             inject_task_focus!(messages: messages, state: ts_state, request: request) unless skip_compass
 
             t0 = Time.now
-            msg = call_engine(messages: messages, tools: tools, ts_state: ts_state)
+            begin
+              msg = call_engine(messages: messages, tools: tools, ts_state: ts_state)
+            rescue StandardError => e
+              if engine_transient?(error: e)
+                engine_blips += 1
+                debug_progress(msg: "engine hop failed #{e.class}: #{e.message.to_s[0, 240]} blip=#{engine_blips}")
+                if engine_blips >= 5
+                  txt = "[pwn-ai] engine hop failed after #{engine_blips} tries: #{e.message.to_s[0, 240]}"
+                  debug_final_text!(text: txt)
+                  final_chars = txt.length
+                  return txt
+                end
+                messages << {
+                  role: 'user',
+                  content: '[pwn-ai] engine hop failed (transient). Keep calling CORE_TOOLS. ' \
+                           "Do not stop. (#{e.message.to_s[0, 180]})"
+                }
+                next
+              end
+              raise
+            end
             engine_s += (Time.now - t0)
             PWN::Plugins::TTYSpinner.halt_all! if defined?(PWN::Plugins::TTYSpinner)
             if msg.nil?

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

@@ -100,9 +100,10 @@ module PWN
 
             HOST LOAD
               #{host_load_block}
-              On pwn_eval/shell timeout: reconstruct the ruby/command for the
-              same goal first. Do not first raise timeout. Only if construction
-              is sound, raise a conservative HOST LOAD timeout (clamped).
+              On pwn_eval/shell timeout: keep the same ruby/command and retry
+              with timeout += 180 until it finishes or the 3-hour budget is
+              gone. Only then rewrite the payload for the same goal (max 10
+              mutations per task). Any payload.
               Record a mistake either way.
 
             AUTONOMY

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

@@ -573,8 +573,8 @@ module PWN
         # model cannot stall the user's real answer, and stay quiet on timeout.
         private_class_method def self.sidecar_timeout
           n = (PWN::Env.dig(:ai, :agent, :sidecar_llm_timeout) if defined?(PWN::Env)).to_i
-          n = 20 if n < 5
-          n = 60 if n > 60
+          n = 180 if n < 30
+          n = 180 if n > 180
           n
         rescue StandardError
           20

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 module PWN
   module AI
     module Agent
@@ -115,82 +117,176 @@ module PWN
           { ncpu: 1, load1: 0.0, mem_avail_mb: 0 }
         end
 
+        TIMEOUT_STEP_S = 180
+        TIMEOUT_MAX_S = 10_800
+        MUTATION_MAX = 10
+
         # Conservative wall-clock seconds for shell / pwn_eval.
-        # Explicit model estimate is honored then clamped. Omit → host-derived
-        # default from loadavg / ncpu / MemAvailable (loaded hosts get a bit
-        # more time, still capped).
+        # Explicit timeout is honored for any payload (1..TIMEOUT_MAX_S).
+        # Omit → host-derived default from loadavg / ncpu / MemAvailable.
+        # No tool-name sniffing: a 65k scan and `ls` use the same math.
         public_class_method def self.deadline_s(opts = {})
           kind = opts[:kind].to_s.to_sym
-          max = kind == :shell ? 180 : 90
           asked = opts[:timeout] || opts[:timeout_s]
           asked_i = asked.to_i
-          if asked_i.positive?
-            lo = 1
-            hi = max
-            return asked_i.clamp(lo, hi)
-          end
+          return asked_i.clamp(1, TIMEOUT_MAX_S) if asked_i.positive?
 
           snap = host_load
           ncpu = [snap[:ncpu].to_i, 1].max
           load1 = snap[:load1].to_f
           mem = snap[:mem_avail_mb].to_i
+          default_max = kind == :shell ? 180 : 90
           base = kind == :shell ? 30 : 20
           base += 15 if load1 > ncpu
           base += 10 if load1 > (ncpu * 1.5)
           base += 10 if mem.positive? && mem < 512
-          base.clamp(8, max)
+          base.clamp(8, default_max)
+        end
+
+        public_class_method def self.reset_timeout_budget(opts = {})
+          return :noop unless opts.is_a?(Hash)
+
+          @timeout_spent = {}
+          @timeout_mutations = {}
+          @timeout_mutated = {}
+          :reset
+        end
+
+        public_class_method def self.reset_timeout_budget!
+          reset_timeout_budget
+        end
+
+        public_class_method def self.mutation_count(opts = {})
+          return 0 unless opts.is_a?(Hash)
+
+          timeout_mutations[task_key(opts)].to_i
+        end
+
+        public_class_method def self.payload_spent(opts = {})
+          return 0 unless opts.is_a?(Hash)
+
+          timeout_spent[payload_key(opts)].to_i
+        end
+
+        public_class_method def self.note_timeout!(opts = {})
+          return 0 unless opts.is_a?(Hash)
+
+          timeout = opts[:timeout].to_i
+          timeout = 1 if timeout < 1
+          key = payload_key(opts)
+          timeout_spent[key] = timeout_spent[key].to_i + timeout
+          if budget_exhausted?(opts.merge(spent: timeout_spent[key])) && !timeout_mutated[key]
+            timeout_mutated[key] = true
+            tkey = task_key(opts)
+            timeout_mutations[tkey] = timeout_mutations[tkey].to_i + 1
+          end
+          timeout_spent[key]
+        end
+
+        public_class_method def self.next_timeout(opts = {})
+          base = opts[:timeout].to_i
+          base = 1 if base < 1
+          spent = opts.key?(:spent) ? opts[:spent].to_i : payload_spent(opts)
+          remaining = TIMEOUT_MAX_S - spent
+          remaining = 0 if remaining.negative?
+          [base + TIMEOUT_STEP_S, remaining, TIMEOUT_MAX_S].min
         end
 
-        # Two-scenario timeout policy (loop-law, not a skill):
-        # 1. First timeout → reconstruct the ruby/command for the same goal.
-        #    Do not first raise timeout.
-        # 2. A later timeout of the same tool → deadline was too short; raise
-        #    a conservative HOST LOAD timeout (still clamped).
+        # Timeout policy (loop-law, not a skill):
+        # 1. Same payload: timeout += 180 until the 3-hour budget is gone.
+        # 2. At the 3-hour cap: rewrite ruby/command for the same goal
+        #    (one mutation). Max MUTATION_MAX mutations per task.
+        # 3. After MUTATION_MAX mutations: stop (exhausted).
         public_class_method def self.timeout_lesson(opts = {})
           return { scenario: :construction, error: '', hint: '' } unless opts.is_a?(Hash)
 
           tool = opts[:tool].to_s
           timeout = opts[:timeout].to_i
-          prior = timeout_prior_count(tool: tool)
-          if prior.positive?
-            {
-              scenario: :deadline,
-              error: "#{tool} timeout: deadline too short; raise conservative HOST LOAD timeout",
-              hint: "Scenario 2: the #{tool} payload already timed out once. " \
-                    "This timeout (#{timeout}s) was too short. Raise a conservative " \
-                    'timeout from HOST LOAD (clamped). Record this so it does not recur. ' \
-                    'Do not retry the identical payload at the same deadline.'
-            }
+          spent = payload_spent(opts)
+          spent_after = spent >= timeout && timeout.positive? ? spent : spent + [timeout, 1].max
+          nxt = next_timeout(timeout: timeout, spent: spent_after)
+          mutations = mutation_count(opts)
+          if budget_exhausted?(opts.merge(timeout: timeout, spent: spent_after))
+            if mutations >= MUTATION_MAX
+              {
+                scenario: :exhausted,
+                error: "#{tool} timeout: #{MUTATION_MAX} mutations exhausted for this task",
+                hint: "This task hit the mutation cap (#{MUTATION_MAX} rewrites after " \
+                      '3-hour budgets). Do not retry the same payload. Report what ' \
+                      'was tried and what remains blocked.'
+              }
+            else
+              {
+                scenario: :construction,
+                error: "#{tool} timeout: 3-hour budget exhausted; reconstruct payload to same goal",
+                hint: "The #{tool} payload used its 3-hour budget. Generate different " \
+                      'ruby/command for the same goal. Mutation ' \
+                      "#{[mutations, 1].max}/#{MUTATION_MAX}."
+              }
+            end
           else
             {
-              scenario: :construction,
-              error: "#{tool} timeout: reconstruct payload to same goal before raising timeout",
-              hint: "Scenario 1 (try first): the #{tool} ruby/command was constructed " \
-                    'improperly. Generate it differently to achieve the same goal. ' \
-                    'Do not first raise timeout. Record this so it does not recur.'
+              scenario: :deadline,
+              error: "#{tool} timeout: deadline too short; retry with timeout += 180",
+              hint: "Keep the same #{tool} payload. This timeout (#{timeout}s) was too " \
+                    "short. Retry with timeout += 180 (next_timeout=#{nxt})."
             }
           end
         end
 
         public_class_method def self.timeout_result(opts = {})
-          return { stdout: '', stderr: '', exit: nil, error: 'timeout', scenario: :construction, hint: '', shell: shell_name } unless opts.is_a?(Hash)
+          return { stdout: '', stderr: '', exit: nil, error: 'timeout', scenario: :deadline, hint: '', next_timeout: TIMEOUT_STEP_S, shell: shell_name } unless opts.is_a?(Hash)
 
+          timeout = opts[:timeout].to_i
+          note_timeout!(opts)
           lesson = timeout_lesson(
             tool: opts[:tool],
             payload: opts[:payload],
-            timeout: opts[:timeout]
+            timeout: timeout,
+            task: opts[:task]
           )
           {
             stdout: opts[:stdout].to_s,
             stderr: opts[:stderr].to_s,
             exit: nil,
-            error: "timeout after #{opts[:timeout].to_i}s",
+            error: "timeout after #{timeout}s",
             scenario: lesson[:scenario],
             hint: lesson[:hint],
+            next_timeout: next_timeout(timeout: timeout, spent: payload_spent(opts)),
+            mutations: mutation_count(opts),
             shell: opts[:shell] || shell_name
           }
         end
 
+        private_class_method def self.timeout_spent
+          @timeout_spent ||= {}
+        end
+
+        private_class_method def self.timeout_mutations
+          @timeout_mutations ||= {}
+        end
+
+        private_class_method def self.timeout_mutated
+          @timeout_mutated ||= {}
+        end
+
+        private_class_method def self.task_key(opts = {})
+          t = opts[:task]
+          t = opts[:session_id] if t.to_s.strip.empty?
+          t.to_s.strip.empty? ? 'default' : t.to_s
+        end
+
+        private_class_method def self.payload_key(opts = {})
+          payload = opts[:payload].to_s
+          "#{task_key(opts)}:#{Digest::SHA256.hexdigest(payload)}"
+        end
+
+        private_class_method def self.budget_exhausted?(opts = {})
+          spent = opts[:spent]
+          spent = payload_spent(opts) if spent.nil?
+          opts[:timeout].to_i >= TIMEOUT_MAX_S || spent.to_i >= TIMEOUT_MAX_S
+        end
+
         public_class_method def self.timeout_prior_count(opts = {})
           return 0 unless opts.is_a?(Hash)
           return 0 unless defined?(PWN::AI::Agent::Mistakes)

data/lib/pwn/ai/agent/tools/ruby_eval.rb

@@ -24,7 +24,10 @@ PWN::AI::Agent::Registry.register(
                  'browser. Do not open a second browser. Close once with ' \
                  'Close once with TransparentBrowser.close(browser_obj: browser_obj). ' \
                  'Pass timeout as a conservative integer seconds estimate given HOST ' \
-                 'LOAD (loadavg, ncpu, mem). Omit for a host-derived default (clamped). ' \
+                 'LOAD (loadavg, ncpu, mem). Omit for a host-derived default. ' \
+                 'Explicit timeout is honored up to 10800s (3 hours) for any payload. On ' \
+                 'timeout, keep the same payload and retry with timeout += 180 ' \
+                 'until the 3-hour budget is gone; then rewrite (max 10 mutations/task). ' \
                  'Returns captured stdout plus the inspected value of the last expression.',
     parameters: {
       type: 'object',
@@ -32,7 +35,7 @@ PWN::AI::Agent::Registry.register(
         code: { type: 'string', description: 'Ruby source to evaluate.' },
         timeout: {
           type: 'integer',
-          description: 'Conservative seconds this eval should take given HOST LOAD. Omit for host-derived default. Clamped 1..90.'
+          description: 'Conservative seconds this eval should take given HOST LOAD. Omit for a host-derived default. Explicit values honored 1..10800 (3 hours). On timeout keep the same payload and timeout += 180; rewrite only after the 3-hour budget (max 10 mutations/task).'
         }
       },
       required: %w[code]
@@ -61,7 +64,7 @@ PWN::AI::Agent::Registry.register(
     old_stdout = $stdout
     buf = StringIO.new
     $stdout = buf
-    timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :eval)
+    timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :eval, payload: code)
     begin
       # rubocop:disable Security/Eval
       # INTENTIONAL: this IS the pwn-ai → PWN bridge
@@ -89,17 +92,12 @@ PWN::AI::Agent::Registry.register(
       # rubocop:enable Security/Eval
       { stdout: buf.string, value: val.inspect, timeout: timeout }
     rescue Timeout::Error
-      lesson = PWN::AI::Agent::ToolGuard.timeout_lesson(
+      PWN::AI::Agent::ToolGuard.timeout_result(
         tool: 'pwn_eval',
         payload: code,
-        timeout: timeout
+        timeout: timeout,
+        stdout: buf.string
       )
-      {
-        stdout: buf.string,
-        error: "timeout after #{timeout}s",
-        scenario: lesson[:scenario],
-        hint: lesson[:hint]
-      }
     rescue ScriptError, StandardError => e
       {
         stdout: buf.string,

data/lib/pwn/ai/agent/tools/shell.rb

@@ -23,14 +23,17 @@ PWN::AI::Agent::Registry.register(
                  'stdout/stderr/exit code. Use for OS-level work: nmap, curl, ' \
                  'ls, git, file inspection, anything not in the PWN:: namespace. ' \
                  'Pass timeout as a conservative integer seconds estimate given ' \
-                 'HOST LOAD (loadavg, ncpu, mem). Omit for a host-derived default (clamped).',
+                 'HOST LOAD (loadavg, ncpu, mem). Omit for a host-derived default. ' \
+                 'Explicit timeout is honored up to 10800s (3 hours) for any payload. On ' \
+                 'timeout, keep the same payload and retry with timeout += 180 ' \
+                 'until the 3-hour budget is gone; then rewrite (max 10 mutations/task).',
     parameters: {
       type: 'object',
       properties: {
         command: { type: 'string', description: 'The exact shell command to run.' },
         timeout: {
           type: 'integer',
-          description: 'Conservative seconds this command should take given HOST LOAD. Omit for host-derived default. Clamped 1..180.'
+          description: 'Conservative seconds this command should take given HOST LOAD. Omit for a host-derived default. Explicit values honored 1..10800 (3 hours). On timeout keep the same payload and timeout += 180; rewrite only after the 3-hour budget (max 10 mutations/task).'
         }
       },
       required: %w[command]
@@ -52,7 +55,7 @@ PWN::AI::Agent::Registry.register(
                         .gsub(/\\\r?\n/, ' ')
                         .gsub(/\\+\s*\z/, '')
                         .strip
-    timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :shell)
+    timeout = PWN::AI::Agent::ToolGuard.deadline_s(timeout: args[:timeout], kind: :shell, payload: cmd)
     if cmd.empty? || PWN::AI::Agent::ToolGuard.placeholder?(text: cmd)
       return PWN::AI::Agent::ToolGuard.invalid_payload(
         hint: 'command is required (string). Do not send ..., {...}, {…}, or empty. ' \

data/lib/pwn/ai/http_retry.rb

@@ -27,6 +27,15 @@ module PWN
         DEFAULT_MAX_ATTEMPTS
       end
 
+      public_class_method def self.retryable?(opts = {})
+        err = opts[:error]
+        msg = err.respond_to?(:message) ? err.message.to_s : err.to_s
+        msg = opts[:message].to_s if msg.empty?
+        msg.match?(/HTTP 50[234]|Gateway Time-out|stream absolute timeout|ReadTimeout|Net::ReadTimeout|Timed out reading/i)
+      rescue StandardError
+        false
+      end
+
       public_class_method def self.retry_after_s(opts = {})
         retry_count = [opts[:retry_count].to_i, 1].max
         retry_after = 0

data/lib/pwn/ai/ollama.rb

@@ -198,6 +198,21 @@ module PWN
           retry if retry_count < max_attempts
 
           nil
+        rescue StandardError => e
+          if PWN::AI::HttpRetry.retryable?(error: e) && retry_count + 1 < max_attempts
+            retry_count += 1
+            unless opts[:quiet]
+              PWN::AI::HttpRetry.report_event(
+                label: 'ollama', which_self: self, quiet: opts[:quiet],
+                http_method: http_method, rest_call: rest_call,
+                extra: "retryable attempt=#{retry_count}/#{max_attempts}",
+                error: e
+              )
+            end
+            sleep(PWN::AI::HttpRetry.retry_after_s(retry_count: retry_count) + rand(0.3..2.0))
+            retry
+          end
+          raise e
         end
       rescue RestClient::ExceptionWithResponse => e
         body = begin

data/lib/pwn/plugins/nmap_it.rb

@@ -14,19 +14,53 @@ module PWN
       #   nmap.connect_scan = true
       #   nmap.service_scan = true
       #   nmap.verbose = true
-      #   nmap.ports = [1..1024,1337]
+      #   nmap.ports = [1..1024, 1337]
       #   nmap.targets = '127.0.0.1'
-      #   nmap.xml = '/tmp/nmap_port_scan_res.xml'
+      #   nmap.xml = '/tmp/nmap_port_scan_res.xml' # alias of output_xml
       # end
+      #
+      # PWN::Plugins::NmapIt.port_scan(
+      #   targets: '127.0.0.1',
+      #   ports: '1-65535',
+      #   connect_scan: true,
+      #   service_scan: true,
+      #   script: 'vuln,safe',
+      #   xml: '/tmp/nmap_port_scan_res.xml'
+      # )
 
-      public_class_method def self.port_scan
+      public_class_method def self.port_scan(opts = {})
         Nmap::Command.sudo do |nmap|
-          yield(nmap)
+          apply_port_scan_opts(nmap: nmap, opts: opts)
+          yield(nmap_compat(nmap: nmap)) if block_given?
         end
       rescue StandardError => e
         raise e
       end
 
+      private_class_method def self.apply_port_scan_opts(opts = {})
+        nmap = opts[:nmap]
+        args = opts[:opts]
+        return nmap unless args.is_a?(Hash)
+
+        nmap.targets = args[:targets] || args[:target] if args[:targets] || args[:target]
+        nmap.ports = args[:ports] if args.key?(:ports)
+        xml = args[:xml] || args[:output_xml]
+        nmap.output_xml = xml if xml
+        nmap.connect_scan = args[:connect_scan] if args.key?(:connect_scan)
+        nmap.service_scan = args[:service_scan] || args[:service_detection] if args.key?(:service_scan) || args.key?(:service_detection)
+        nmap.verbose = args[:verbose] if args.key?(:verbose)
+        scripts = args[:script] || args[:scripts] || args[:vuln_scripts]
+        nmap.script = scripts if scripts
+        nmap
+      end
+
+      private_class_method def self.nmap_compat(opts = {})
+        nmap = opts[:nmap]
+        nmap.define_singleton_method(:xml=) { |path| self.output_xml = path }
+        nmap.define_singleton_method(:xml) { output_xml }
+        nmap
+      end
+
       # Supported Method Parameters::
       # PWN::Plugins::NmapIt.parse_xml_results(:xml_file => 'required - path to nmap xml results') do |xml|
       #   puts xml.public_methods
@@ -103,6 +137,15 @@ module PWN
             nmap.xml = '/tmp/nmap_port_scan_res.xml'
           end
 
+          #{self}.port_scan(
+            targets: '127.0.0.1',
+            ports: '1-65535',
+            connect_scan: true,
+            service_scan: true,
+            script: 'vuln,safe',
+            xml: '/tmp/nmap_port_scan_res.xml'
+          )
+
           #{self}.parse_xml_results(:xml_file => 'required - path to nmap xml results') do |xml|
             xml.each_host do |host|
               puts host.ip

data/lib/pwn/plugins/repl.rb

@@ -1284,8 +1284,9 @@ module PWN
                 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.'
+                warn "[pwn-ai] native agent loop failed (#{e.class}: #{e.message.to_s.split("\n").first})"
+                request.replace('nil')
+                next
               ensure
                 PWN::Plugins::REPL.ready_tty!
               end
@@ -1557,7 +1558,7 @@ module PWN
       end
 
       PWN_AI_SLASH_COMMANDS = %w[
-        /back /cron /debug /delegate /help /memory /sessions /skills
+        /back /cron /debug /delegate /help /memory /model /sessions /skills
       ].freeze
 
       PWN_AI_SLASH_SUBCOMMANDS = {
@@ -1566,6 +1567,7 @@ module PWN
         '/delegate' => [],
         '/help' => [],
         '/memory' => %w[list recall remember forget clear],
+        '/model' => %w[list],
         '/sessions' => %w[list resume delete stats],
         '/skills' => %w[list recall]
       }.freeze
@@ -1618,6 +1620,20 @@ module PWN
 
         cmd = tokens.first
         sub_prefix = tokens.last.to_s
+        if cmd == '/model'
+          engines = pwn_ai_engines
+          if tokens.length == 2
+            pool = (%w[list] + engines)
+            return pool.select { |s| sub_prefix.empty? || s.start_with?(sub_prefix) }
+          end
+          return %w[llms].select { |s| sub_prefix.empty? || s.start_with?(sub_prefix) } if tokens.length == 3 && tokens[1] == 'list'
+
+          if tokens.length >= 3
+            current = pwn_ai_engine_model(engine: tokens[1]).to_s
+            hits = [current].reject(&:empty?).select { |s| sub_prefix.empty? || s.start_with?(sub_prefix) }
+            return hits unless hits.empty?
+          end
+        end
         subs = Array(PWN_AI_SLASH_SUBCOMMANDS[cmd])
         hits = subs.select { |s| sub_prefix.empty? || s.start_with?(sub_prefix) }
         hits = [target] if hits.empty? && !target.empty?
@@ -1735,6 +1751,8 @@ module PWN
         when '/delegate'
           puts "[*] Delegating: #{args.join(' ')}"
           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)
         end
         true
       rescue StandardError => e
@@ -1742,6 +1760,171 @@ module PWN
         true
       end
 
+      public_class_method def self.pwn_ai_engines(opts = {})
+        return [] unless opts.is_a?(Hash)
+
+        tmpl = {}
+        tmpl = PWN::Config.env_template[:ai] if defined?(PWN::Config) && PWN::Config.respond_to?(:env_template)
+        keys = tmpl.select { |_k, v| v.is_a?(Hash) && v.key?(:model) }.keys.map(&:to_s)
+        if defined?(PWN::Env) && PWN::Env.is_a?(Hash) && PWN::Env[:ai].is_a?(Hash)
+          PWN::Env[:ai].each do |k, v|
+            next unless v.is_a?(Hash)
+            next if %i[agent driver_opts].include?(k.to_sym)
+
+            keys << k.to_s if v.key?(:model) || v.key?(:key) || v.key?(:base_uri)
+          end
+        end
+        keys.uniq.sort
+      end
+
+      public_class_method def self.pwn_ai_provider_class(opts = {})
+        engine = opts[:engine].to_s.downcase
+        map = {
+          'anthropic' => 'Anthropic',
+          'gemini' => 'Gemini',
+          'grok' => 'Grok',
+          'ollama' => 'Ollama',
+          'openai' => 'OpenAI',
+          'openwebui' => 'OpenWebUI'
+        }
+        name = map[engine]
+        return nil if name.nil? || !defined?(PWN::AI) || !PWN::AI.const_defined?(name)
+
+        PWN::AI.const_get(name)
+      end
+
+      public_class_method def self.pwn_ai_model_ids(opts = {})
+        raw = opts[:models]
+        rows = case raw
+               when Array then raw
+               when Hash then raw[:data] || raw[:models] || raw['data'] || raw['models'] || []
+               else []
+               end
+        Array(rows).filter_map do |row|
+          if row.is_a?(Hash)
+            row[:id] || row['id'] || row[:name] || row['name'] || row[:model] || row['model']
+          else
+            row.to_s
+          end
+        end.map(&:to_s).reject(&:empty?).uniq
+      end
+
+      public_class_method def self.pwn_ai_list_llms(opts = {})
+        engine = opts[:engine].to_s
+        engine = PWN::Env.dig(:ai, :active).to_s if engine.empty? && defined?(PWN::Env)
+        raise 'no active engine — /model <engine> first' if engine.empty?
+
+        klass = pwn_ai_provider_class(engine: engine)
+        raise "#{engine} has no PWN::AI provider with get_models" unless klass.respond_to?(:get_models)
+
+        ids = pwn_ai_model_ids(models: klass.get_models)
+        puts "[*] #{engine} llms (#{ids.length})"
+        ids.each { |id| puts id }
+        ids
+      end
+
+      public_class_method def self.pwn_ai_engine_model(opts = {})
+        engine = opts[:engine].to_s.downcase.to_sym
+        return '' if engine.empty?
+        return '' unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
+
+        PWN::Env.dig(:ai, engine, :model).to_s
+      end
+
+      public_class_method def self.pwn_ai_run_model(opts = {})
+        args = Array(opts[:args]).map(&:to_s)
+        engines = pwn_ai_engines
+        current = defined?(PWN::Env) && PWN::Env.is_a?(Hash) ? PWN::Env.dig(:ai, :active).to_s : ''
+        current_model = pwn_ai_engine_model(engine: current)
+        sub = args[0].to_s
+        if sub.empty? || %w[show status].include?(sub)
+          msg = "active=#{current.empty? ? '(none)' : current} model=#{current_model.empty? ? '(unset)' : current_model}"
+          puts "[*] #{msg}"
+          return msg
+        end
+        if %w[list help].include?(sub)
+          return pwn_ai_list_llms(engine: current) if args[1].to_s == 'llms'
+
+          puts 'pwn-ai /model — switch provider and model in this session'
+          puts "  current: #{current} #{current_model}"
+          puts '  usage: /model [list] | /model list llms | /model <engine> [model] | /model <model>'
+          engines.each do |eng|
+            mark = eng == current ? '*' : ' '
+            puts "  #{mark} #{eng}  #{pwn_ai_engine_model(engine: eng)}"
+          end
+          return engines
+        end
+
+        engine = nil
+        model = nil
+        if engines.include?(sub)
+          engine = sub
+          model = args[1..].join(' ')
+          model = nil if model.strip.empty?
+        else
+          engine = current
+          model = args.join(' ')
+        end
+        raise "no active engine — /model <engine> first (#{engines.join(', ')})" if engine.to_s.empty?
+        raise "unknown engine #{engine.inspect} — try: #{engines.join(', ')}" unless engines.include?(engine.to_s)
+
+        PWN::Env[:ai] ||= {}
+        PWN::Env[:ai][engine.to_sym] ||= {}
+        PWN::Env[:ai][:active] = engine.to_s
+        PWN::Env[:ai][engine.to_sym][:model] = model unless model.to_s.strip.empty?
+        persisted = persist_ai_selection(engine: engine, model: PWN::Env[:ai][engine.to_sym][:model])
+        shown = PWN::Env[:ai][engine.to_sym][:model]
+        msg = "active=#{engine} model=#{shown.to_s.empty? ? '(unset)' : shown}"
+        msg = "#{msg} (session only)" unless persisted
+        puts "[*] #{msg}"
+        msg
+      end
+
+      public_class_method def self.persist_ai_selection(opts = {})
+        engine = opts[:engine].to_s
+        model = opts[:model]
+        return false if engine.empty?
+
+        env_path = nil
+        dec_path = nil
+        if defined?(PWN::Env) && PWN::Env.is_a?(Hash)
+          env_path = PWN::Env.dig(:driver_opts, :pwn_env_path)
+          dec_path = PWN::Env.dig(:driver_opts, :pwn_dec_path)
+        end
+        env_path = env_path.to_s.strip
+        env_path = File.join(Dir.home, '.pwn', 'pwn.yaml') if env_path.empty?
+        dec_path = dec_path.to_s.strip
+        dec_path = "#{env_path}.decryptor" if dec_path.empty?
+        return false unless File.exist?(env_path) && File.exist?(dec_path) && File.readable?(dec_path)
+
+        decryptor = YAML.load_file(dec_path, symbolize_names: true)
+        key = decryptor.is_a?(Hash) ? decryptor[:key] : nil
+        iv = decryptor.is_a?(Hash) ? decryptor[:iv] : nil
+        return false if key.to_s.strip.empty? || iv.to_s.strip.empty?
+
+        PWN::Plugins::Vault.decrypt(file: env_path, key: key, iv: iv)
+        begin
+          cfg = YAML.load_file(env_path, symbolize_names: true)
+          cfg = {} unless cfg.is_a?(Hash)
+          cfg[:ai] = {} unless cfg[:ai].is_a?(Hash)
+          cfg[:ai][:active] = engine
+          unless model.to_s.strip.empty?
+            slot = engine.to_sym
+            cfg[:ai][slot] = {} unless cfg[:ai][slot].is_a?(Hash)
+            cfg[:ai][slot][:model] = model
+          end
+          yaml_env = YAML.dump(cfg).gsub(/^(\s*):/, '\1')
+          File.write(env_path, yaml_env)
+          File.chmod(0o600, env_path)
+        ensure
+          PWN::Plugins::Vault.encrypt(file: env_path, key: key, iv: iv)
+        end
+        true
+      rescue StandardError => e
+        warn "[pwn-ai] /model persist skipped: #{e.class}: #{e.message}"
+        false
+      end
+
       public_class_method def self.pwn_ai_run_cron(opts = {})
         args = Array(opts[:args])
         sub = args[0] || 'list'

data/lib/pwn/version.rb

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

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

@@ -424,15 +424,23 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(src).to match(/note_exception!/)
       expect(src).to match(/rescue StandardError/)
       expect(src).to include("debug_progress(msg: 'engine returned no message')")
+      expect(src).to match(/engine_transient|retryable\?/)
       expect(src).not_to match(/dispatch #\{name\} ok_len=/)
     end
 
-    it 'records a reconstruct-first timeout mistake instead of treating success:true as ok' do
+    it 'keeps Loop.run going after a transient engine 504' do
+      src = File.read(described_class.method(:run).source_location.first)
+      expect(src).to match(/engine_transient\?|HttpRetry\.retryable\?/)
+      expect(src).to match(/engine hop failed|engine_blip/)
+    end
+
+    it 'records a timeout increment mistake instead of treating success:true as ok' do
       tmp = Dir.mktmpdir
       stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
+      PWN::AI::Agent::ToolGuard.reset_timeout_budget! if PWN::AI::Agent::ToolGuard.respond_to?(:reset_timeout_budget!)
       raw = JSON.generate(
         success: true,
-        result: { stdout: '', error: 'timeout after 20s', hint: 'x', scenario: 'construction' }
+        result: { stdout: '', error: 'timeout after 20s', hint: 'x', scenario: 'deadline' }
       )
       tele = described_class.send(
         :record_metrics,
@@ -443,7 +451,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       )
       expect(tele[:ok]).to eq false
       expect(tele[:mistake]).to be_a(Hash)
-      expect(tele[:mistake][:error].to_s).to match(/reconstruct/)
+      expect(tele[:mistake][:error].to_s).to match(/timeout \+= 180|too short/i)
       expect(tele[:mistake][:shape].to_s).to eq('timeout')
     end
 

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

@@ -68,40 +68,101 @@ describe PWN::AI::Agent::ToolGuard do
       expect(snap[:mem_avail_mb].to_i).to be >= 0
     end
 
-    it 'clamps an explicit timeout and derives a default when omitted' do
+    it 'honors any explicit timeout up to 3 hours and derives a default when omitted' do
       expect(described_class.deadline_s(timeout: 1, kind: :eval)).to eq(1)
-      expect(described_class.deadline_s(timeout: 9_999, kind: :eval)).to eq(90)
-      expect(described_class.deadline_s(timeout: 9_999, kind: :shell)).to eq(180)
+      expect(described_class.deadline_s(timeout: 300, kind: :eval)).to eq(300)
+      expect(described_class.deadline_s(timeout: 3_600, kind: :shell)).to eq(3_600)
+      expect(described_class.deadline_s(timeout: 99_999, kind: :eval)).to eq(10_800)
       omitted = described_class.deadline_s(kind: :eval)
       expect(omitted).to be_between(8, 90)
     end
+
+    it 'does not sniff payloads for named tools' do
+      src = File.read(described_class.method(:deadline_s).source_location.first)
+      expect(src).not_to match(/\bnmap\b/i)
+      expect(src).not_to match(/\bsqlmap\b/i)
+      expect(src).not_to match(/\bhydra\b/i)
+      expect(described_class).not_to respond_to(:long_work?)
+    end
+  end
+
+  describe '.next_timeout' do
+    it 'adds 180 seconds until the 3-hour cap' do
+      expect(described_class.next_timeout(timeout: 60)).to eq(240)
+      expect(described_class.next_timeout(timeout: 180)).to eq(360)
+      expect(described_class.next_timeout(timeout: 10_800)).to eq(10_800)
+    end
   end
 
   describe '.timeout_lesson' do
-    it 'prefers reconstruct-the-payload before raising timeout' do
+    before do
+      described_class.reset_timeout_budget!
+    end
+
+    it 'increments timeout on the same payload before rewriting' do
       tmp = Dir.mktmpdir
       stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
-      first = described_class.timeout_lesson(tool: 'pwn_eval', payload: 'sleep 3', timeout: 1)
-      expect(first[:scenario]).to eq(:construction)
-      expect(first[:hint]).to match(/reconstruct|generated differently|improperly/i)
-      expect(first[:hint]).to match(/do not first raise timeout/i)
-      expect(first[:error]).to match(/reconstruct/)
+      first = described_class.timeout_lesson(
+        tool: 'pwn_eval',
+        payload: 'sleep 3',
+        timeout: 180,
+        task: 't1'
+      )
+      expect(first[:scenario]).to eq(:deadline)
+      expect(first[:hint]).to match(/timeout \+= 180|next_timeout/i)
+      expect(first[:hint]).not_to match(/reconstruct/i)
+      expect(described_class.next_timeout(timeout: 180, spent: 180)).to eq(360)
     end
 
-    it 'switches to deadline-too-short only after a prior timeout mistake' do
+    it 'rewrites the payload only after the 3-hour budget is exhausted' do
       tmp = Dir.mktmpdir
       stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
-      PWN::AI::Agent::Mistakes.record(
+      described_class.note_timeout!(
+        tool: 'shell',
+        payload: 'sleep 3',
+        timeout: 10_800,
+        task: 't1'
+      )
+      lesson = described_class.timeout_lesson(
+        tool: 'shell',
+        payload: 'sleep 3',
+        timeout: 10_800,
+        task: 't1'
+      )
+      expect(lesson[:scenario]).to eq(:construction)
+      expect(lesson[:hint]).to match(/3-hour budget|Generate different/i)
+      expect(described_class.mutation_count(task: 't1')).to eq(1)
+    end
+
+    it 'stops after 10 mutations on the same task' do
+      10.times do |i|
+        described_class.note_timeout!(
+          tool: 'shell',
+          payload: "payload-#{i}",
+          timeout: 10_800,
+          task: 't1'
+        )
+      end
+      last = described_class.timeout_lesson(
+        tool: 'shell',
+        payload: 'payload-9',
+        timeout: 10_800,
+        task: 't1'
+      )
+      expect(described_class.mutation_count(task: 't1')).to eq(10)
+      expect(last[:scenario]).to eq(:exhausted)
+      expect(last[:hint]).to match(/10 mutations|mutation cap/i)
+    end
+
+    it 'includes next_timeout on a mid-budget timeout result' do
+      out = described_class.timeout_result(
         tool: 'shell',
-        error: 'shell timeout: reconstruct payload to same goal before raising timeout',
-        args: 'sleep 3',
-        source: :tool,
-        shape: :timeout
+        payload: 'sleep 3',
+        timeout: 180,
+        task: 't1'
       )
-      second = described_class.timeout_lesson(tool: 'shell', payload: 'sleep 3', timeout: 1)
-      expect(second[:scenario]).to eq(:deadline)
-      expect(second[:hint]).to match(/timeout was too short|deadline too short|raise a conservative/i)
-      expect(second[:error]).to match(/too short/)
+      expect(out[:scenario]).to eq(:deadline)
+      expect(out[:next_timeout]).to eq(360)
     end
   end
 end

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

@@ -49,8 +49,8 @@ describe 'PWN::AI::Agent::Tools ruby_eval' do
     result = entry.handler.call(code: 'sleep 3', timeout: 1)
     expect(Time.now - t0).to be < 2.5
     expect(result[:error].to_s).to match(/timeout after 1s/)
-    expect(result[:hint].to_s).to match(/reconstruct|generated differently|improperly/i)
-    expect(result[:scenario].to_s).to eq('construction')
+    expect(result[:hint].to_s).to match(/timeout \+= 180|next_timeout|same .*payload/i)
+    expect(result[:scenario].to_s).to eq('deadline')
   end
 
   it 'Dispatch.call JSON-wraps syntax errors instead of raising' do

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

@@ -60,12 +60,12 @@ describe 'PWN::AI::Agent::Tools shell' do
     expect(r[:exit]).to eq(0)
   end
 
-  it 'on timeout prefers reconstruct-the-command before raising timeout' do
+  it 'on timeout keeps the same command and increments timeout' do
     tmp = Dir.mktmpdir
     stub_const('PWN::AI::Agent::Mistakes::MISTAKES_FILE', File.join(tmp, 'mistakes.json'))
     r = handler.call(command: 'sleep 3', timeout: 1)
     expect(r[:error].to_s).to match(/timeout after 1s/)
-    expect(r[:hint].to_s).to match(/reconstruct|generated differently|improperly/i)
-    expect(r[:scenario].to_s).to eq('construction')
+    expect(r[:hint].to_s).to match(/timeout \+= 180|next_timeout|same .*payload/i)
+    expect(r[:scenario].to_s).to eq('deadline')
   end
 end

data/spec/lib/pwn/ai/http_retry_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'stringio'
+require 'rest-client'
 
 describe PWN::AI::HttpRetry do
   it 'defaults timeout to 180 and max_attempts to 5' do
@@ -14,6 +15,12 @@ describe PWN::AI::HttpRetry do
     expect(described_class.max_attempts(max_attempts: 3)).to eq(3)
   end
 
+  it 'treats gateway 504 and stream absolute timeouts as retryable' do
+    expect(described_class.retryable?(error: 'ERROR: Ollama HTTP 504 for api/chat: Gateway Time-out')).to eq(true)
+    expect(described_class.retryable?(error: 'ERROR: Ollama stream absolute timeout after 20s for api/chat')).to eq(true)
+    expect(described_class.retryable?(error: '400 Bad Request')).to eq(false)
+  end
+
   it 'tees emit lines into the open debug request log' do
     path = PWN::Plugins::Log.start_debug(
       tee: StringIO.new,
@@ -50,6 +57,7 @@ describe PWN::AI::HttpRetry do
       expect(src).not_to match(/timeout \|\|= 900/)
       expect(src).to match(/Exceptions::Timeout/)
       expect(src).to match(/HttpRetry\.report_event/)
+      expect(src).to match(/retryable\?|HTTP 50/) if name == 'PWN::AI::Ollama'
     end
   end
 end

data/spec/lib/pwn/plugins/nmap_it_spec.rb

@@ -12,4 +12,11 @@ describe PWN::Plugins::NmapIt do
     help_response = PWN::Plugins::NmapIt
     expect(help_response).to respond_to :help
   end
+
+  it 'port_scan accepts opts = {} and aliases xml to output_xml' do
+    expect(described_class.method(:port_scan).parameters).to include(%i[opt opts])
+    src = File.read(described_class.method(:port_scan).source_location.first)
+    expect(src).to include('opts[')
+    expect(src).to include('output_xml')
+  end
 end

data/spec/lib/pwn/plugins/repl_pwn_vault_spec.rb

@@ -174,4 +174,14 @@ describe 'pwn-ai debug final answer placement' do
     expect(hook).to include('→ pwn-ai →')
     expect(hook).to include('→ result')
   end
+
+  it 'does not fall through to regex-ReAct after a native Loop.run error' do
+    native_start = hook.index('final = PWN::AI::Agent::Loop.run')
+    rescue_at = hook.index('rescue StandardError', native_start)
+    expect(rescue_at).not_to be_nil
+    chunk = hook[rescue_at, 900]
+    expect(chunk).to match(/request\.replace\('nil'\)/)
+    expect(chunk).to match(/\bnext\b/)
+    expect(chunk).not_to include('legacy regex-ReAct')
+  end
 end

data/spec/lib/pwn/plugins/repl_spec.rb

@@ -67,11 +67,15 @@ describe PWN::Plugins::REPL do
       hits = described_class.pwn_ai_complete(target: '/sk', line: '/sk')
       expect(hits).to include('/skills')
       hits = described_class.pwn_ai_complete(target: '/', line: '/')
-      %w[/cron /skills /sessions /memory /debug /back /help].each do |cmd|
+      %w[/cron /skills /sessions /memory /debug /back /help /model].each do |cmd|
         expect(hits).to include(cmd)
       end
       hits = described_class.pwn_ai_complete(target: 'li', line: '/cron li')
       expect(hits).to include('list')
+      hits = described_class.pwn_ai_complete(target: 'li', line: '/model li')
+      expect(hits).to include('list')
+      hits = described_class.pwn_ai_complete(target: 'll', line: '/model list ll')
+      expect(hits).to include('llms')
     end
 
     it 'completes host-native paths when slash is not the first character' do
@@ -101,5 +105,37 @@ describe PWN::Plugins::REPL do
       expect(hook).to match(/pwn_ai_dispatch_slash!/)
       expect(described_class).to respond_to(:pwn_ai_dispatch_slash!)
     end
+
+    it 'switches the live engine and model via /model without Loop.run' do
+      expect(described_class).to respond_to(:pwn_ai_run_model)
+      PWN::Env[:ai] ||= {}
+      PWN::Env[:ai][:grok] ||= {}
+      prev_active = PWN::Env[:ai][:active]
+      prev_model = PWN::Env[:ai][:grok][:model]
+      allow(described_class).to receive(:persist_ai_selection).and_return(false)
+      out = described_class.pwn_ai_run_model(args: %w[grok pwn-ai-test-model])
+      expect(PWN::Env[:ai][:active].to_s).to eq('grok')
+      expect(PWN::Env[:ai][:grok][:model]).to eq('pwn-ai-test-model')
+      expect(out.to_s).to match(/grok/i)
+    ensure
+      if PWN::Env.is_a?(Hash) && PWN::Env[:ai].is_a?(Hash)
+        PWN::Env[:ai][:active] = prev_active if defined?(prev_active)
+        PWN::Env[:ai][:grok][:model] = prev_model if defined?(prev_model) && PWN::Env[:ai][:grok].is_a?(Hash)
+      end
+    end
+
+    it 'lists llm ids from the active provider via /model list llms' do
+      expect(described_class).to respond_to(:pwn_ai_list_llms)
+      PWN::Env[:ai] ||= {}
+      prev_active = PWN::Env[:ai][:active]
+      PWN::Env[:ai][:active] = 'grok'
+      allow(PWN::AI::Grok).to receive(:get_models).and_return(
+        [{ id: 'grok-test-a' }, { id: 'grok-test-b' }]
+      )
+      ids = described_class.pwn_ai_run_model(args: %w[list llms])
+      expect(ids).to eq(%w[grok-test-a grok-test-b])
+    ensure
+      PWN::Env[:ai][:active] = prev_active if PWN::Env.is_a?(Hash) && PWN::Env[:ai].is_a?(Hash)
+    end
   end
 end

data/third_party/pwn_rdoc.jsonl

@@ -339,6 +339,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.degrade_text_only Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.degrade_text_only`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.dispatch_fail_n Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.dispatch_fail_n`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.emit_task_summary Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.emit_task_summary`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.engine_transient? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.engine_transient?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.escalate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.escalate`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.evidence_enough_to_finalize? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.evidence_enough_to_finalize?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.expose_current_session Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.expose_current_session`: "}]}
@@ -383,6 +384,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.task_summary_flush! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.task_summary_flush!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.task_summary_plan! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.task_summary_plan!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.task_summary_record! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.task_summary_record!`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.timeout_task Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.timeout_task`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.tool_effects Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.tool_effects`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.world_knowledge? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.world_knowledge?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.write_verified? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.write_verified?`: "}]}
@@ -706,18 +708,30 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.why_bit Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.why_bit`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.authors Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.authors`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.bashism? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.bashism?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.budget_exhausted? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.budget_exhausted?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.coerce_args Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.coerce_args`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.deadline_s Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.deadline_s`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.host_load Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.host_load`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.invalid_payload Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.invalid_payload`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.mutation_count Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.mutation_count`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.next_timeout Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.next_timeout`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.note_timeout! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.note_timeout!`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.payload_key Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.payload_key`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.payload_spent Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.payload_spent`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.placeholder? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.placeholder?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.present? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.present?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.reset_timeout_budget Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.reset_timeout_budget`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.reset_timeout_budget! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.reset_timeout_budget!`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.shell_bash? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.shell_bash?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.shell_name Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.shell_name`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.task_key Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.task_key`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.timeout_lesson Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.timeout_lesson`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.timeout_mutated Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.timeout_mutated`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.timeout_mutations Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.timeout_mutations`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.timeout_prior_count Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.timeout_prior_count`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.timeout_result Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.timeout_result`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::ToolGuard.timeout_spent Usage"},{"role":"assistant","content":"`PWN::AI::Agent::ToolGuard.timeout_spent`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TransparentBrowser.analyze Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TransparentBrowser.analyze`: Supported Method Parameters\n\nai_analysis = PWN::AI::Agent::TransparentBrowser.analyze(\n\nrequest: 'required - current step in the JavaScript debugging session to analyze',\nsource_to_review: 'required - the block of JavaScript code in which the current step resides'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TransparentBrowser.authors Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TransparentBrowser.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TransparentBrowser.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TransparentBrowser.help`: "}]}
@@ -780,6 +794,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::HttpRetry.max_attempts Usage"},{"role":"assistant","content":"`PWN::AI::HttpRetry.max_attempts`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::HttpRetry.report_event Usage"},{"role":"assistant","content":"`PWN::AI::HttpRetry.report_event`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::HttpRetry.retry_after_s Usage"},{"role":"assistant","content":"`PWN::AI::HttpRetry.retry_after_s`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::HttpRetry.retryable? Usage"},{"role":"assistant","content":"`PWN::AI::HttpRetry.retryable?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::HttpRetry.timeout_s Usage"},{"role":"assistant","content":"`PWN::AI::HttpRetry.timeout_s`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Ollama.assemble_native_chat_stream Usage"},{"role":"assistant","content":"`PWN::AI::Ollama.assemble_native_chat_stream`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Ollama.assemble_ollama_stream Usage"},{"role":"assistant","content":"`PWN::AI::Ollama.assemble_ollama_stream`: "}]}
@@ -2140,11 +2155,13 @@
 {"messages":[{"role":"user","content":"PWN::Plugins::NexposeVulnScan.logout Usage"},{"role":"assistant","content":"`PWN::Plugins::NexposeVulnScan.logout`: Supported Method Parameters\n\nPWN::Plugins::NexposeVulnScan.logout(\n\nnsc_obj: 'required nsc_obj returned from login method'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::NexposeVulnScan.scan_site_by_name Usage"},{"role":"assistant","content":"`PWN::Plugins::NexposeVulnScan.scan_site_by_name`: Supported Method Parameters\n\nPWN::Plugins::NexposeVulnScan.scan_site_by_name(\n\nnsc_obj: 'required nsc_obj returned from login method',\nsite_name: 'required Nexpose site name to scan (case-sensitive),\npoll_interval: 'optional poll interval to check the completion status of the scan (defaults to 3 minutes)\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::NexposeVulnScan.update_site_assets Usage"},{"role":"assistant","content":"`PWN::Plugins::NexposeVulnScan.update_site_assets`: Supported Method Parameters\n\nPWN::Plugins::NexposeVulnScan.update_site_assets(\n\nnsc_obj: 'required nsc_obj returned from login method',\nsite_name: 'required Nexpose site name to update (case-sensitive),\nassets: 'required array of hashes containing called :ip => values being IP address (All IPs not included in the :assets parameter will be removed from Nexpose)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.apply_port_scan_opts Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.apply_port_scan_opts`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.authors Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.diff_xml_results Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.diff_xml_results`: Supported Method Parameters\n\nPWN::Plugins::NmapIt.diff_xml_results(\n\nxml_a: 'required - path to nmap xml results',\nxml_b: 'required - path to nmap xml results',\ndiff: 'required - path to nmap xml results diff'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.help Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.nmap_compat Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.nmap_compat`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.parse_xml_results Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.parse_xml_results`: Supported Method Parameters\n\nPWN::Plugins::NmapIt.parse_xml_results(:xml_file => ‘required - path to nmap xml results’) do |xml|\n\nputs xml.public_methods\nxml.each_host do |host|\n  puts \"[#{host.ip}]\"\n\n  host.scripts.each do |name,output|\n    output.each_line { |line| puts \"  #{line}\" }\n  end\n\n  host.each_port do |port|\n    puts \"  [#{port.number}/#{port.protocol}]\"\n\n    port.scripts.each do |name,output|\n      puts \"    [#{name}]\"\n      output.each_line { |line| puts \"      #{line}\" }\n    end\n  end\nend\n\n\nend\n"}]}
-{"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.port_scan Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.port_scan`: Supported Method Parameters\n\nPWN::Plugins::NmapIt.port_scan do |nmap|\n\nputs nmap.public_methods\nnmap.connect_scan = true\nnmap.service_scan = true\nnmap.verbose = true\nnmap.ports = [1..1024,1337]\nnmap.targets = '127.0.0.1'\nnmap.xml = '/tmp/nmap_port_scan_res.xml'\n\n\nend\n"}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::NmapIt.port_scan Usage"},{"role":"assistant","content":"`PWN::Plugins::NmapIt.port_scan`: Supported Method Parameters\n\nPWN::Plugins::NmapIt.port_scan do |nmap|\n\nputs nmap.public_methods\nnmap.connect_scan = true\nnmap.service_scan = true\nnmap.verbose = true\nnmap.ports = [1..1024, 1337]\nnmap.targets = '127.0.0.1'\nnmap.xml = '/tmp/nmap_port_scan_res.xml' # alias of output_xml\n\n\nend\n\nPWN::Plugins::NmapIt.port_scan(\n\ntargets: '127.0.0.1',\nports: '1-65535',\nconnect_scan: true,\nservice_scan: true,\nscript: 'vuln,safe',\nxml: '/tmp/nmap_port_scan_res.xml'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::OAuth2.authors Usage"},{"role":"assistant","content":"`PWN::Plugins::OAuth2.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::OAuth2.decode Usage"},{"role":"assistant","content":"`PWN::Plugins::OAuth2.decode`: Supported Method Parameters\n\nPWN::Plugins::OAuth2.decode(\n\noauth2_token: 'required oauth2 token'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::OAuth2.get_value_by_key Usage"},{"role":"assistant","content":"`PWN::Plugins::OAuth2.get_value_by_key`: Supported Method Parameters\n\nPWN::Plugins::OAuth2.get_value_by_key(\n\noauth2_token: 'required oauth2 token',\nkey: 'required oauth2 token key name located within the Base64 encoded token as symbol, e.g. :company_id'\n\n)\n"}]}
@@ -2228,14 +2245,21 @@
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.enable_autocomplete Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.enable_autocomplete`: Supported Method Parameters\n\nPWN::Plugins::REPL.enable_autocomplete(\n\nenabled: 'optional - Boolean (default true). false reverts to single-line cycling.'\n\n)\n\nIRB-style suggest-as-you-type for the pwn REPL.\n\nReplaces Pry’s default input (rb-readline — single-candidate TAB cycling) with Reline and turns on Reline.autocompletion, which renders a live dropdown of candidates below the cursor as you type (the same widget IRB uses).  Pry already wires Reline.completion_proc → @pry.complete (Pry::InputCompleter) when input == Reline, so the menu is fed by the full Ruby/PWN object graph: constants (PWN::Plugins::Nm<TAB>), instance methods, local/global variables, and Pry slash-commands.\n\nNavigate with ↑/↓ or TAB, accept with → or ENTER, dismiss with ESC.\n\nScope: this drives the MAIN pwn REPL (Ruby).  pwn-ai swaps PWNMultiLineInput onto Reline.readmultiline and installs install_pwn_ai_completer! so TAB is command / path / Ruby menus. pwn-asm keeps opcode input without those menus.\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.help Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.install_pwn_ai_completer! Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.install_pwn_ai_completer!`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.persist_ai_selection Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.persist_ai_selection`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_complete Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_complete`: Supported Method Parameters\n\nhits = PWN::Plugins::REPL.pwn_ai_complete(\n\ntarget: 'required - token Reline is completing',\nline: 'optional - full line buffer',\npry: 'optional - Pry instance for Ruby completion'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_complete_command Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_complete_command`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_complete_kind Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_complete_kind`: Supported Method Parameters\n\nkind = PWN::Plugins::REPL.pwn_ai_complete_kind(line: ‘optional - current input buffer’)\n\nfirst char is ‘/’ → :command (pwn-ai slash menu)\n\n‘/’ anywhere else → :path (host-native file nav)\n\nelse → :ruby (same Pry::InputCompleter menu as the pwn REPL)\n\n"}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_complete_path Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_complete_path`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_complete_ruby Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_complete_ruby`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_dispatch_slash! Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_dispatch_slash!`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_engine_model Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_engine_model`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_engines Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_engines`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_list_llms Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_list_llms`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_model_ids Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_model_ids`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_provider_class Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_provider_class`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_run_cron Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_run_cron`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_run_memory Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_run_memory`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_run_model Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_run_model`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_run_sessions Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_run_sessions`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.pwn_ai_run_skills Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.pwn_ai_run_skills`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL.ready_tty! Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL.ready_tty!`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.696
+  version: 0.5.698
 platform: ruby
 authors:
 - 0day Inc.