pwn 0.5.617 → 0.5.620

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

@@ -41,7 +41,8 @@ module PWN
       module Extrospection
         EXTRO_FILE = File.join(Dir.home, '.pwn', 'extrospection.json')
         MAX_OBSERVATIONS = 500
-        PROBE_BINS = %w[nmap curl git ruby python3 gcc msfconsole sqlmap burpsuite zaproxy openssl docker].freeze
+        RF_BINS    = %w[rtl_sdr rtl_test rtl_433 hackrf_info gqrx dump1090 multimon-ng SoapySDRUtil].freeze
+        PROBE_BINS = (%w[nmap curl git ruby python3 gcc msfconsole sqlmap burpsuite zaproxy openssl docker] + RF_BINS).freeze
 
         # Supported Method Parameters::
         # store = PWN::AI::Agent::Extrospection.load
@@ -71,7 +72,7 @@ module PWN
         # Supported Method Parameters::
         # snap = PWN::AI::Agent::Extrospection.snapshot(
         #   persist: 'optional - Boolean, write snapshot to disk & rotate previous (default true)',
-        #   sections: 'optional - Array subset of [:host, :net, :toolchain, :repo, :env] (default all)'
+        #   sections: 'optional - Array subset of [:host, :net, :toolchain, :repo, :env, :rf] (default all)'
         # )
         #
         # Captures a fingerprint of the OUTSIDE world. When persist:true the
@@ -84,7 +85,7 @@ module PWN
                        true
                      end
           sections = Array(opts[:sections]).map(&:to_sym)
-          sections = %i[host net toolchain repo env] if sections.empty?
+          sections = %i[host net toolchain repo env rf] if sections.empty?
 
           snap = {}
           snap[:host]      = probe_host      if sections.include?(:host)
@@ -92,6 +93,7 @@ module PWN
           snap[:toolchain] = probe_toolchain if sections.include?(:toolchain)
           snap[:repo]      = probe_repo      if sections.include?(:repo)
           snap[:env]       = probe_env       if sections.include?(:env)
+          snap[:rf]        = probe_rf        if sections.include?(:rf)
           snap[:captured_at] = Time.now.utc.iso8601
           snap[:fingerprint] = Digest::SHA256.hexdigest(JSON.generate(snap.except(:captured_at)))[0, 16]
 
@@ -110,7 +112,7 @@ module PWN
         # obs = PWN::AI::Agent::Extrospection.observe(
         #   source: 'required - where the observation came from (nmap, shodan, burp, cve, human, ...)',
         #   data: 'required - the observation payload (String or Hash)',
-        #   category: 'optional - :recon, :vuln, :intel, :target, :network, :misc (default :misc)',
+        #   category: 'optional - :recon, :vuln, :intel, :target, :network, :env, :rf, :misc (default :misc)',
         #   target: 'optional - host/ip/url/asset the observation is about',
         #   tags: 'optional - Array of String labels',
         #   ttl: 'optional - seconds until this observation is considered stale (default nil = forever)'
@@ -288,7 +290,21 @@ module PWN
             end
           end
 
-          # 4) raw drift as low-priority findings when nothing else matched
+          # 4) :rf observations vs missing SDR hardware / binaries
+          rf = 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? }
+            if !hw_present
+              findings << { kind: :rf_no_hardware, observation: ob[:data], source: ob[:source], target: ob[:target], advice: 'RF observation recorded but no SDR hardware detected in snapshot — plug in RTL-SDR/HackRF/Flipper or start gqrx (`-r`) before trusting RF results.' }
+            elsif rf[:gqrx_sock] == false && ob[:source].to_s == 'gqrx'
+              findings << { kind: :rf_gqrx_down, observation: ob[:data], target: ob[:target], advice: 'gqrx remote-control socket (127.0.0.1:7356) is closed — start gqrx with remote control enabled before re-running the scan.' }
+            elsif !miss.empty?
+              findings << { kind: :rf_toolchain_gap, missing: miss, observation: ob[:data], advice: "SDR toolchain gap: install #{miss.join(', ')} to decode/act on this RF observation." }
+            end
+          end
+
+          # 5) raw drift as low-priority findings when nothing else matched
           Array(delta[:added]).first(5).each   { |c| findings << { kind: :env_added,   detail: c } } if findings.empty?
           Array(delta[:removed]).first(5).each { |c| findings << { kind: :env_removed, detail: c } } if findings.empty?
 
@@ -346,7 +362,8 @@ module PWN
             drift_added: Array(delta[:added]).length,
             drift_removed: Array(delta[:removed]).length,
             toolchain_bins: (snap[:toolchain] || {}).count { |_, v| !v.to_s.empty? },
-            listening_ports: Array(snap.dig(:net, :listening)).length
+            listening_ports: Array(snap.dig(:net, :listening)).length,
+            rf_devices: (snap[:rf] || {}).values_at(:rtl_sdr, :hackrf, :flipper, :gqrx_sock).count { |v| rf_present?(val: v) }
           }
         end
 
@@ -478,6 +495,47 @@ module PWN
           { cwd: Dir.pwd, ruby: RUBY_VERSION }
         end
 
+        # Passive RF / SDR hardware inventory. NO transmit, NO active spectrum
+        # scan — this is the RF analogue of probe_toolchain: "what radios and
+        # SDR plumbing are attached / reachable right now?" so drift can flag
+        # "HackRF unplugged", "gqrx remote-control down", "new RTL dongle".
+        private_class_method def self.probe_rf
+          {
+            rtl_sdr: sh(cmd: 'timeout 3 rtl_test -t 2>&1 | head -5'),
+            hackrf: sh(cmd: 'timeout 3 hackrf_info 2>&1 | head -8'),
+            soapy: sh(cmd: 'timeout 3 SoapySDRUtil --find 2>&1 | head -10'),
+            gqrx_sock: tcp_open?(host: '127.0.0.1', port: 7356),
+            flipper: Dir.glob('/dev/serial/by-id/*Flipper*').any?,
+            serial_devs: Dir.glob('/dev/{ttyUSB,ttyACM}*'),
+            band_plans: rf_band_plan_keys.length
+          }
+        rescue StandardError => e
+          { error: "#{e.class}: #{e.message}" }
+        end
+
+        private_class_method def self.tcp_open?(opts = {})
+          host = opts[:host] || '127.0.0.1'
+          port = opts[:port].to_i
+          Socket.tcp(host, port, connect_timeout: 1, &:close)
+          true
+        rescue StandardError
+          false
+        end
+
+        private_class_method def self.rf_present?(opts = {})
+          v = opts[:val]
+          return false if v.nil? || v == false || v.to_s.strip.empty?
+
+          v.to_s !~ /no\s+.*devices|no\s+hackrf|not\s+found|no\s+such\s+file|command\s+not\s+found|^false$/i
+        end
+
+        private_class_method def self.rf_band_plan_keys
+          require 'pwn/sdr/frequency_allocation' unless defined?(PWN::SDR::FrequencyAllocation)
+          PWN::SDR::FrequencyAllocation.band_plans.keys.map(&:to_s).sort
+        rescue StandardError
+          []
+        end
+
         private_class_method def self.flatten(opts = {})
           hash   = opts[:hash] || {}
           prefix = opts[:prefix].to_s
@@ -598,6 +656,7 @@ module PWN
               PWN::AI::Agent::Extrospection.snapshot                          # probe host, persist, return {snapshot:, drift:}
               PWN::AI::Agent::Extrospection.drift(live: true)                 # what changed vs last snapshot
               PWN::AI::Agent::Extrospection.observe(source: 'nmap', category: :recon, target: '10.0.0.5', data: '22/tcp open ssh 9.6')
+              PWN::AI::Agent::Extrospection.observe(source: 'gqrx', category: :rf, target: '433.920MHz', data: 'peak -34.2 dBFS bw=200k')
               PWN::AI::Agent::Extrospection.observations(category: 'recon', target: '10.0.0.5')
               PWN::AI::Agent::Extrospection.intel(query: 'openssl 3.0', record: true)
               PWN::AI::Agent::Extrospection.correlate                         # introspection x extrospection findings

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

@@ -112,16 +112,19 @@ module PWN
 
         public_class_method def self.to_context(opts = {})
           limit = opts[:limit] || 5
-          rows = outcomes(limit: limit)
-          return '' if rows.empty?
+          rows  = outcomes(limit: limit)
+          fails = outcomes(limit: 200, success: false).first(limit)
+          return '' if rows.empty? && fails.empty?
 
-          lines = rows.map do |r|
+          fmt = lambda do |r|
             flag = r[:success] ? '✓' : '✗'
-            "  #{flag} #{r[:task][0, 100]} (#{r[:timestamp]})"
+            "  #{flag} #{r[:task].to_s[0, 100]} (#{r[:timestamp]})"
           end
-          s = stats
+          s   = stats
           hdr = "RECENT OUTCOMES (success_rate=#{(s[:success_rate] * 100).round(1)}% over #{s[:total_outcomes]} attempts)"
-          "#{hdr}\n#{lines.join("\n")}\n\n"
+          out = "#{hdr}\n#{rows.map(&fmt).join("\n")}\n"
+          out += "RECENT FAILURES (learn from these — do not repeat)\n#{fails.map(&fmt).join("\n")}\n" unless fails.empty?
+          "#{out}\n"
         end
 
         # Supported Method Parameters::
@@ -204,9 +207,10 @@ module PWN
           return unless session_id
           return unless auto_reflect_enabled?
 
+          ok = infer_success(session_id: session_id, final: opts[:final])
           note_outcome(
             task: opts[:request].to_s[0, 120],
-            success: !opts[:final].to_s.strip.empty?,
+            success: ok,
             details: opts[:final].to_s[0, 300],
             session_id: session_id,
             tags: %w[auto loop]
@@ -218,6 +222,37 @@ module PWN
           nil
         end
 
+        # Supported Method Parameters::
+        # PWN::AI::Agent::Learning.flip_last_outcome(
+        #   session_id: 'optional - only flip if the newest outcome belongs to this session',
+        #   reason: 'optional - why it is being flipped (usually the user correction text)'
+        # )
+        #
+        # Rewrites the most-recently-appended learning.jsonl entry from
+        # success:true to success:false. Called by Mistakes.check_user_correction
+        # when the user's next message rejects the previous answer, so the
+        # 100 %-success illusion is broken and the failure enters the corpus.
+
+        public_class_method def self.flip_last_outcome(opts = {})
+          return { flipped: false } unless File.exist?(LEARNING_FILE)
+
+          lines = File.readlines(LEARNING_FILE)
+          return { flipped: false } if lines.empty?
+
+          last = JSON.parse(lines.last, symbolize_names: true)
+          return { flipped: false } if opts[:session_id] && last[:session_id] && last[:session_id] != opts[:session_id]
+          return { flipped: false } unless last[:success]
+
+          last[:success]    = false
+          last[:flipped_by] = 'user_correction'
+          last[:details]    = "#{last[:details]} | CORRECTED: #{opts[:reason].to_s[0, 200]}".strip
+          lines[-1] = "#{JSON.generate(last)}\n"
+          File.write(LEARNING_FILE, lines.join)
+          { flipped: true, id: last[:id] }
+        rescue StandardError
+          { flipped: false }
+        end
+
         # Supported Method Parameters::
         # removed = PWN::AI::Agent::Learning.consolidate(
         #   max_entries: 'optional - hard cap on PWN::Memory size (default MAX_MEMORY_ENTRIES)'
@@ -274,6 +309,31 @@ module PWN
           false
         end
 
+        FAILURE_FINAL_RX = /\[pwn-ai\] (iteration budget exhausted|engine returned no message)|\b(i (was )?unable to|i could not|i couldn'?t|cannot proceed|failed to)\b/i
+
+        # Derive a success signal stronger than "final answer non-empty":
+        # look at the tool-failure ratio inside the just-completed turn AND
+        # scan the final text for self-reported failure language. Without
+        # this, auto_reflect logs ~100 % success and the negative-feedback
+        # side of the learning loop never fires.
+        private_class_method def self.infer_success(opts = {})
+          final = opts[:final].to_s
+          return false if final.strip.empty?
+          return false if final.match?(FAILURE_FINAL_RX)
+
+          sid = opts[:session_id]
+          return true unless sid && defined?(PWN::Sessions)
+
+          entries = PWN::Sessions.load(session_id: sid).last(200)
+          tool    = entries.select { |e| e[:role].to_s == 'tool' }
+          return true if tool.empty?
+
+          bad = tool.count { |e| e[:content].to_s.include?('"success":false') || e[:content].to_s.match?(/"exit":[1-9]/) }
+          (bad.to_f / tool.length) < 0.5
+        rescue StandardError
+          !final.strip.empty?
+        end
+
         private_class_method def self.skills_dir
           if defined?(PWN::Config) && PWN::Config.respond_to?(:pwn_skills_path)
             PWN::Config.pwn_skills_path

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'digest'
+require 'pwn/ai/agent/mistakes'
 
 module PWN
   module AI
@@ -14,6 +16,22 @@ module PWN
       # native function-calling. State (memory, skills, sessions) is all
       # externalised — Loop.run is stateless aside from the messages array it
       # builds.
+      #
+      # NEGATIVE-FEEDBACK CLOSURE
+      # -------------------------
+      # Loop.run is where "learn from mistakes, don't repeat them" is
+      # actually enforced. On EVERY failed dispatch it:
+      #   1. Records the (tool, normalised_error) fingerprint into
+      #      PWN::AI::Agent::Mistakes with a PERSISTENT cross-session count.
+      #   2. Reads that count back and, if it OR the in-turn count reaches
+      #      REPEAT_THRESHOLD, prepends a hard "REPEATED FAILURE — change
+      #      approach" guard to the tool result the model sees next.
+      #   3. Appends Mistakes.correction_hint (seen N×, sig, KNOWN FIX: …)
+      #      so a previously-discovered fix is handed straight back to the
+      #      model on the FIRST recurrence in a new session — it does not
+      #      have to fail 3× again to re-learn what it already knew.
+      # PromptBuilder.mistakes_block re-injects the top open mistakes and
+      # top known fixes into the system prompt of every future turn.
       module Loop
         DEFAULT_MAX_ITERS = 777
 
@@ -49,16 +67,26 @@ module PWN
           DEFAULT_MAX_ITERS
         end
 
+        # Record per-tool telemetry AND, when the dispatch failed, fingerprint
+        # the failure into PWN::AI::Agent::Mistakes so recurring errors are
+        # counted, surfaced in the system prompt, and can be resolved with an
+        # explicit fix. Returns { ok:, err:, mistake: } — :mistake carries the
+        # PERSISTED entry (with cumulative :count and any prior :fix) so the
+        # caller drives cross-session repeat detection, not just per-turn.
         private_class_method def self.record_metrics(opts = {})
           name    = opts[:name]
           started = opts[:started]
           raw     = opts[:raw].to_s
-          ok      = raw.include?('"success":true')
+          ok      = raw.include?('"success":true') && !raw.match?(/"exit":[1-9]/)
           err     = raw[/"error":"([^"]{1,300})"/, 1]
+          err   ||= raw[/"stderr":"([^"]{4,300})"/, 1] unless ok
           dur     = started ? (Time.now - started) : 0.0
           Metrics.record(name: name, success: ok, duration: dur, error: err) if defined?(Metrics)
+          m = nil
+          m = Mistakes.record(tool: name, error: err || raw[0, 300], args: opts[:args], session_id: opts[:session_id], source: :tool) if !ok && defined?(Mistakes)
+          { ok: ok, err: err, mistake: m }
         rescue StandardError
-          nil
+          { ok: true, err: nil, mistake: nil }
         end
 
         # Stash the active session_id under PWN::Env[:ai][:session_id] so
@@ -88,6 +116,26 @@ module PWN
           nil
         end
 
+        # Repeat circuit-breaker. `count` is max(per-turn, persistent) so a
+        # signature that already failed in a PREVIOUS session trips the guard
+        # on its FIRST recurrence here — the agent does not get to burn the
+        # iteration budget re-learning a lesson it already recorded.
+        private_class_method def self.guard_repeated_failure(opts = {})
+          count  = opts[:count].to_i
+          result = opts[:result].to_s
+          hint   = opts[:hint].to_s
+          thresh = defined?(Mistakes) ? Mistakes::REPEAT_THRESHOLD : 3
+          result = "#{result}\n#{hint}" unless hint.empty?
+          return result if count < thresh
+
+          guard = "[pwn-ai/mistakes] REPEATED FAILURE — this #{opts[:name]} failure signature has " \
+                  "occurred #{count}× (across sessions). DO NOT retry it verbatim; change " \
+                  'arguments, pick a different tool, apply the KNOWN FIX below if present, or ' \
+                  'explain why it cannot succeed. Once a working alternative is found, call ' \
+                  'mistakes_resolve(signature:, fix:) so future runs skip straight to it.'
+          "#{guard}\n#{result}"
+        end
+
         # Supported Method Parameters::
         # msg = PWN::AI::Agent::Loop.normalize_llm(
         #   response: 'required - chat_with_tools response Hash from any provider'
@@ -172,6 +220,7 @@ module PWN
 
           Registry.discover
           expose_current_session(session_id: session_id)
+          Mistakes.check_user_correction(request: request, session_id: session_id) if defined?(Mistakes)
 
           tools    = Registry.definitions(enabled: opts[:enabled_toolsets])
           messages = [
@@ -180,6 +229,8 @@ module PWN
           ]
           append_session(session_id: session_id, role: 'user', content: request)
 
+          turn_fails = Hash.new(0)
+
           max_iters.times do |i|
             msg = call_engine(messages: messages, tools: tools)
             return '[pwn-ai] engine returned no message' if msg.nil?
@@ -196,13 +247,27 @@ module PWN
 
             calls.each do |tc|
               name    = tc.dig(:function, :name).to_s
+              args    = tc.dig(:function, :arguments)
               entry   = Registry.lookup(name: name)
               started = Time.now
               raw     = Dispatch.call(tool_call: tc)
-              record_metrics(name: name, started: started, raw: raw)
-              result = Result.condition(content: raw, entry: entry)
-
-              on_tool&.call(name, tc.dig(:function, :arguments), result)
+              tele    = record_metrics(name: name, started: started, raw: raw, args: args, session_id: session_id)
+              result  = Result.condition(content: raw, entry: entry)
+
+              unless tele[:ok]
+                fkey = Digest::SHA256.hexdigest("#{name}|#{args}")[0, 16]
+                turn_fails[fkey] += 1
+                persist = tele.dig(:mistake, :count).to_i
+                hint    = defined?(Mistakes) ? Mistakes.correction_hint(tool: name, error: tele[:err] || raw[0, 300]) : ''
+                result  = guard_repeated_failure(
+                  name: name,
+                  count: [turn_fails[fkey], persist].max,
+                  hint: hint,
+                  result: result
+                )
+              end
+
+              on_tool&.call(name, args, result)
 
               messages << {
                 role: 'tool',
@@ -218,6 +283,7 @@ module PWN
             end
           end
 
+          Mistakes.record(tool: 'agent_loop', error: 'iteration budget exhausted without a final answer', session_id: session_id, source: :loop) if defined?(Mistakes)
           '[pwn-ai] iteration budget exhausted'
         end