pwn 0.5.666 → 0.5.668

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad38a3062af2dfd655e372b35546535f8f652b39a8b91269ce8ee9e45a01ba9b
-  data.tar.gz: c66ed8a1aa104008e480f5118b892a5132ce8047e0029ab4728381f8a4e00ba7
+  metadata.gz: 21fe6bb04741fbc78392d434588c1c86d0f605db0988bfa2192f68e9baa870ec
+  data.tar.gz: cf66359fb95bb12f08705d11dd304625878115902133d9e1ad0f8becfa8fb83a
 SHA512:
-  metadata.gz: f27ba8cff4c35f7cb330ce1b1fad3cf7806759ff84a6706b61e6dd55864a3241c29990e151e63ae9218a065748e9383698dfec586245573c3d80a55a4bd9300a
-  data.tar.gz: 2643e1501646d411888403352dd2e822f597f2222089a8d06ac1fac8d9b5c474d72a55ad072e150e102366e63bdb9d157a0ad1d2a2c935722b1ba80d20782788
+  metadata.gz: 35f079f6d7c765c6395f490f07c06ce3494b81487bba31c978367fc2b8a23a421a6b1d9a68cda02592fd94868ca343a13c441323b6e1dee0656f46ade8c88aef
+  data.tar.gz: b9a45751eaf30849ac1c98bd8d603df89d8522fb950dfc830f188769b0fc8e7b69848ed1f71053f7053da24a85e0c2f56f0f9a2c26b95de2040835a7e9871c47

data/.rubocop_todo.yml

@@ -73,6 +73,7 @@ Naming/AccessorMethodName:
     - 'lib/pwn/ai/grok.rb'
     - 'lib/pwn/ai/ollama.rb'
     - 'lib/pwn/ai/open_ai.rb'
+    - 'lib/pwn/ai/open_web_ui.rb'
     - 'lib/pwn/blockchain/btc.rb'
     - 'lib/pwn/plugins/jira_data_center.rb'
     - 'lib/pwn/plugins/vin.rb'

data/Gemfile

@@ -67,7 +67,7 @@ gem 'os', '1.1.4'
 gem 'ostruct', '0.6.3'
 gem 'packetfu', '2.0.0'
 gem 'packetgen', '4.1.1'
-gem 'pdf-reader', '2.15.1'
+gem 'pdf-reader', '2.16.0'
 gem 'pg', '1.6.3'
 gem 'pry', '0.16.0'
 gem 'pry-doc', '1.7.0'
@@ -89,12 +89,12 @@ gem 'ruby-nmap', '1.0.3'
 gem 'ruby-saml', '1.18.1'
 gem 'rvm', '1.11.3.9'
 gem 'savon', '2.17.4'
-gem 'selenium-devtools', '0.150.0'
-gem 'selenium-webdriver', '4.46.0'
+gem 'selenium-devtools', '0.151.0'
+gem 'selenium-webdriver', '4.47.0'
 gem 'slack-ruby-client', '3.2.0'
 gem 'socksify', '1.8.1'
 gem 'spreadsheet', '1.3.5'
-gem 'sqlite3', '2.9.5'
+gem 'sqlite3', '2.9.6'
 gem 'thin', '2.0.1'
 gem 'tty-prompt', '0.23.1'
 gem 'tty-spinner', '0.9.3'

data/README.md

@@ -58,11 +58,20 @@ pwn.ai:grok/grok-4.5/0:500K[CURRENT_VERSION]:002 >>> Briefly describe your take
 
 **My take, in plain English:**
 
-pwn-ai’s reinforcement loop is mostly **learning in context**, not only weight training.
+pwn-ai’s reinforced learning loop is less a classic offline RL trainer and more a living, multi-store control system wrapped around an agent turn. My take is that it is one of the more complete in-context self-improvement stacks I’ve seen in an agent harness, and also that its real power and its main failure modes come from the same place: it learns loudly in the prompt long before it learns quietly in weights.
 
-On every turn the agent acts with tools. Each result is scored in a few ways: quick “did this tool call really fail?” checks, longer-term tool success stats, and—when a final answer lands—a judge that scores whether the *goal* was actually met, plus per-step credit for which tool calls helped or hurt. Failures become fingerprints (mistakes) with fixes; wins become outcomes, exemplars, memory lessons, and sometimes skills. All of that is written back into the next prompt as “what worked,” “what not to repeat,” and “which tools pay off,” so behavior improves on the following run without waiting for a model train.
+## Bottom line
 
-Around that core sit self-checks: a sentinel that distrusts inflated success rates when the judge disagrees, night jobs that practice the worst repeating mistakes, and optional export of preference pairs for a gated LoRA update when a trainer and GPU exist. So the loop is: **act → measure honestly → remember (and fix) → bias the next act**—with real weight updates as an optional outer ring, not the main daily path.
+My take: pwn-ai implements a **closed-loop, dual-horizon, self-and-world-aware reinforcement system** around an LLM agent. The clever part is not that it has a reward model. The clever part is that it treats agent work as an ongoing control problem with:
+
+- fast aversive conditioning (Mistakes),
+- value estimates for actions (Metrics),
+- episode scoring and replay (Learning/Reward),
+- deliberate practice (Curriculum),
+- and an external reality check (Extrospection),
+- with a slower supervised/DPO hatch only when the diet and gates look sane.
+
+It feels less like “fine-tune the model forever” and more like giving the agent a nervous system: pain, habit, memory, practice, and a rudimentary sense of whether the world changed. That is why it can improve overnight on a host with no trainer. It is also why health has to be measured by judge gap, repeating-mistake trend, trajectory fraction, and resolved scars rather than by tool success_rate alone.
 ```
 
 Offensive work is hard because the *tools* do not fit together. PWN's fix is

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'securerandom'
 
 module PWN
   module AI
@@ -118,6 +119,165 @@ module PWN
           raise ArgumentError, "invalid JSON arguments: #{e.message}"
         end
 
+        # Supported Method Parameters::
+        # calls = PWN::AI::Agent::Dispatch.tool_calls_from_text(
+        #   text: 'required - assistant plain-text that may embed shell(...) / JSON tool forms'
+        # )
+        #
+        # Local / abliterated models often print tool invocations as content
+        # instead of native message.tool_calls. Supported shapes include:
+        #   shell(command="id") / shell({"command":"id"}) / shell("id")
+        #   {"name":"shell","arguments":{...}} / {"function":{"name":...}}
+        #   {"tool":"shell","arguments":{...}} / {"call":"shell","arguments":{...}}
+        #   call:shell{command: "uname -s"} / tool:shell{"command":"id"}
+        # When structured tool_calls are empty, Loop coerces those strings into
+        # OpenAI-shaped tool_call hashes so Dispatch runs them instead of
+        # treating the string as a FINAL answer.
+
+        public_class_method def self.tool_calls_from_text(opts = {})
+          text = opts[:text].to_s
+          return [] if text.strip.empty?
+
+          Registry.discover if defined?(Registry) && Registry.respond_to?(:discover)
+          known = if defined?(Registry)
+                    Registry.all.map { |e| e.name.to_s }.reject(&:empty?)
+                  else
+                    %w[shell pwn_eval]
+                  end
+          return [] if known.empty?
+
+          names_alt = known.map { |n| Regexp.escape(n) }.join('|')
+          calls = []
+          seen = {}
+
+          add = lambda do |name, args|
+            name = name.to_s
+            next unless known.include?(name)
+
+            args_h = case args
+                     when Hash then symbolize(hash: args)
+                     when String
+                       s = args.strip
+                       begin
+                         parsed = JSON.parse(s, symbolize_names: true)
+                         parsed.is_a?(Hash) ? parsed : { value: parsed }
+                       rescue JSON::ParserError
+                         h = {}
+                         s.scan(/([A-Za-z_]\w*)\s*[:=]\s*(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s,)}{]+))/) do
+                           k = Regexp.last_match(1)
+                           h[k.to_sym] = Regexp.last_match(2) || Regexp.last_match(3) || Regexp.last_match(4)
+                         end
+                         if h.empty?
+                           entry = (Registry.lookup(name: name) if defined?(Registry))
+                           req = Array(entry&.schema&.dig(:parameters, :required))
+                           h = req.length == 1 ? { req.first.to_sym => s } : { command: s }
+                         end
+                         h
+                       end
+                     else
+                       {}
+                     end
+            key = "#{name}|#{JSON.generate(args_h)}"
+            next if seen[key]
+
+            seen[key] = true
+            calls << {
+              id: "textcall_#{calls.length + 1}_#{SecureRandom.hex(3)}",
+              type: 'function',
+              function: {
+                name: name,
+                # OpenAI/xAI wire format requires a JSON string, not a map.
+                arguments: JSON.generate(args_h)
+              }
+            }
+          end
+
+          # Balanced-delimiter extractor used for name(...) and call:name{...}.
+          extract_balanced = lambda do |open_ch, close_ch, from|
+            depth = 1
+            i = from
+            in_s = nil
+            esc = false
+            while i < text.length && depth.positive?
+              ch = text[i]
+              if in_s
+                if esc
+                  esc = false
+                elsif ch == '\\'
+                  esc = true
+                elsif ch == in_s
+                  in_s = nil
+                end
+              elsif ['"', "'"].include?(ch)
+                in_s = ch
+              elsif ch == open_ch
+                depth += 1
+              elsif ch == close_ch
+                depth -= 1
+              end
+              i += 1
+            end
+            depth.zero? ? [text[from...(i - 1)].to_s.strip, i] : nil
+          end
+
+          # JSON object forms:
+          #   {"name":"shell","arguments":{...}}
+          #   {"function":{"name":"shell","arguments":{...}}}
+          #   {"tool":"shell","arguments":{...}} / {"call":"shell",...}
+          #   {"type":"call","name":"shell",...}
+          text.scan(/\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/m).each do |blob|
+            begin
+              j = JSON.parse(blob, symbolize_names: true)
+            rescue JSON::ParserError
+              next
+            end
+            next unless j.is_a?(Hash)
+
+            name = (
+              j[:name] || j[:tool] || j[:call] ||
+              j.dig(:function, :name) || j.dig(:tool_call, :name)
+            ).to_s
+            # Skip pure type tags mistaken as names (e.g. {"call":{...}} trees).
+            next if name.empty? || %w[function tool_call].include?(name)
+
+            args = j[:arguments] || j[:args] || j[:parameters] ||
+                   j.dig(:function, :arguments) || j.dig(:tool_call, :arguments) || {}
+            add.call(name, args)
+          end
+
+          # Colon-brace forms (OpenWebUI / abliterated dumps):
+          #   call:shell{command: "uname -s"}
+          #   tool:shell{"command":"id"}
+          #   call:shell{command="id"}
+          rx_colon = /\b(?:call|tool)\s*:\s*(#{names_alt})\s*\{/i
+          idx = 0
+          while (m = text.match(rx_colon, idx))
+            name = m[1]
+            extracted = extract_balanced.call('{', '}', m.end(0))
+            if extracted
+              # Re-wrap: balanced extractor yields the interior only. Paren form
+              # shell({...}) keeps braces inside (...); brace form must restore
+              # them so JSON.parse / kwarg scan see a full object body.
+              add.call(name, "{#{extracted[0]}}")
+            end
+            idx = m.begin(0) + 1
+          end
+
+          # Call forms: shell(command="...") / shell({"command":"id"}) / shell("id")
+          rx = /\b(#{names_alt})\s*\(/i
+          idx = 0
+          while (m = text.match(rx, idx))
+            name = m[1]
+            extracted = extract_balanced.call('(', ')', m.end(0))
+            add.call(name, extracted[0]) if extracted
+            idx = m.begin(0) + 1
+          end
+
+          calls
+        rescue StandardError
+          []
+        end
+
         private_class_method def self.symbolize(opts = {})
           hash = opts[:hash] ||= {}
           hash.each_with_object({}) { |(k, v), m| m[k.to_sym] = v }
@@ -143,6 +303,7 @@ module PWN
               )
 
               PWN::AI::Agent::Dispatch.repair_name(name: 'run_shell')  # => 'shell'
+              PWN::AI::Agent::Dispatch.tool_calls_from_text(text: 'shell(command="id")')
 
               #{self}.authors
           USAGE

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

@@ -1189,7 +1189,8 @@ module PWN
 
               bin = m[:name].to_s.split('_').first
               tc  = Array(delta[:changed]).find { |c| c[:path].to_s.include?("toolchain.#{bin}") }
-              miss = snap.dig(:toolchain, bin.to_sym).to_s.empty?
+              tc_map = snap[:toolchain].is_a?(Hash) ? snap[:toolchain] : {}
+              miss = tc_map[bin.to_sym].to_s.empty?
               next unless tc || miss
 
               findings << { kind: :tool_env_mismatch, tool: m[:name], success_rate: m[:success_rate], evidence: tc || "binary '#{bin}' not found in PATH", advice: "Re-verify `which #{bin}` / reinstall before relying on #{m[:name]}." }
@@ -1206,7 +1207,7 @@ module PWN
           end
 
           # 3) intel observations matching installed components
-          pkgs = snap[:toolchain] || {}
+          pkgs = snap[:toolchain].is_a?(Hash) ? snap[:toolchain] : {}
           observations(category: 'intel', limit: 100).each do |ob|
             blob = ob[:data].to_s.downcase
             pkgs.each do |bin, ver|
@@ -1218,7 +1219,7 @@ module PWN
           end
 
           # 4) :rf observations vs missing SDR hardware / binaries
-          rf = snap[:rf] || {}
+          rf = snap[:rf].is_a?(Hash) ? snap[:rf] : {}
           hw_present = %i[rtl_sdr hackrf flipper gqrx_sock].any? { |k| rf_present?(val: rf[k]) }
           observations(category: 'rf', limit: 50).each do |ob|
             miss = RF_BINS.select { |b| pkgs[b.to_sym].to_s.empty? }
@@ -1240,7 +1241,10 @@ module PWN
               Learning.outcomes(limit: 30, success: false).each do |o|
                 next unless o[:task].to_s.include?(host) || o[:details].to_s.include?(host)
 
-                findings << { kind: :target_web_drift, target: tgt, dom_sha: ob.dig(:data, :dom_sha), task: o[:task], advice: "Target #{host} DOM changed (#{ob[:timestamp]}) around this failure - re-recon before assuming your technique is wrong." }
+                dom_sha = case ob[:data]
+                          when Hash then ob[:data][:dom_sha] || ob[:data]['dom_sha']
+                          end
+                findings << { kind: :target_web_drift, target: tgt, dom_sha: dom_sha, task: o[:task], advice: "Target #{host} DOM changed (#{ob[:timestamp]}) around this failure - re-recon before assuming your technique is wrong." }
               end
             end
           end
@@ -1253,7 +1257,7 @@ module PWN
           end
 
           # 7) :intel observations whose source anchor is currently probe_web-unreachable -> downgrade
-          web = snap[:web] || {}
+          web = snap[:web].is_a?(Hash) ? snap[:web] : {}
           web.each do |host, fp|
             next unless fp.is_a?(Hash) && (fp[:reachable] == false || fp[:status].to_i >= 500)
 

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

@@ -1088,7 +1088,8 @@ module PWN
         # Mistakes(tool:'assumption') so KNOWN MISTAKES warns every future
         # run off that specific hallucination.
         private_class_method def self.fact_check_local_final(opts = {})
-          return unless defined?(PWN::Env) && PWN::Env.dig(:ai, :active).to_s.downcase.to_sym == :ollama
+          eng = defined?(PWN::Env) ? PWN::Env.dig(:ai, :active).to_s.downcase.to_sym : nil
+          return unless %i[ollama openwebui].include?(eng)
           return unless defined?(Extrospection) && Extrospection.respond_to?(:verify)
 
           claims = opts[:final].to_s.scan(CLAIM_RX).flatten.compact.uniq