pwn 0.5.618 → 0.5.621

data/documentation/pwn-ai-Agent.md

@@ -2,15 +2,16 @@
 
 `pwn-ai` is a natural-language front end to everything in `PWN::`. You describe
 the goal; the agent plans a sequence of tool calls (`pwn_eval`, `shell`,
-`memory_*`, `skill_*`, `extro_*`, `agent_*`, …), executes them against the live
-process, observes the results, and loops until it can give you a final answer.
+`memory_*`, `skill_*`, `mistakes_*`, `extro_*`, `agent_*`, …), executes them
+against the live process, observes the results, and loops until it can give you
+a final answer — **learning from every failure so it doesn't repeat it**.
 
 ## Two ways to run it
 
 ```text
 # 1. Interactive TUI (inside the pwn REPL)
-pwn[v0.5.616]:001 >>> pwn-ai
-✨ pwn-ai · anthropic · session 20260707_220802_3f39791f
+pwn[v0.5.618]:001 >>> pwn-ai
+✨ pwn-ai · anthropic · session 20260707_225041_d7f2f3bb
 > Use NmapIt to sweep 10.0.0.0/24, then TransparentBrowser via Burp on any
   host with 443 open, active-scan, and give me a Reports::SAST summary.
 ```
@@ -23,12 +24,21 @@ $ pwn --ai "run bin/pwn_sast against ./src and push findings to DefectDojo"
 ## Anatomy of a turn
 
 1. **PromptBuilder** assembles the system prompt: your request + MEMORY block +
-   SKILLS list + LEARNING stats + EXTROSPECTION block.
-2. **Loop** sends it to the active `PWN::AI::<Engine>` client.
-3. Provider replies with `tool_calls` → **Dispatch** executes each one via the
-   [Registry](Agent-Tool-Registry.md), **Metrics** records duration/success.
-4. Results are appended to the message list; go to 2.
-5. When the reply has *no* tool_calls it's the **final answer** →
+   SKILLS list + LEARNING stats + **KNOWN MISTAKES / KNOWN FIXES** +
+   TOOL EFFECTIVENESS + EXTROSPECTION block.
+2. **Loop** checks the incoming message against `Mistakes::CORRECTION_RX` — if
+   it reads like *"no, that's wrong"* the previous outcome is flipped to
+   `success:false` and fingerprinted.
+3. Loop sends the prompt to the active `PWN::AI::<Engine>` client.
+4. Provider replies with `tool_calls` → **Dispatch** executes each one via the
+   [Registry](Agent-Tool-Registry.md); **Metrics** records duration/success.
+   Any *failure* is fingerprinted into **Mistakes** (`count++`, cross-session)
+   and the tool result gets an inline `correction_hint` (`seen N×, sig=…,
+   KNOWN FIX: …`) so the very next iteration self-corrects. If the persistent
+   count ≥ 3, `guard_repeated_failure` interrupts with an explicit
+   *change-approach* instruction.
+5. Results are appended to the message list; go to 3.
+6. When the reply has *no* tool_calls it's the **final answer** →
    `Learning.auto_reflect` and `Extrospection.auto_extrospect` fire (if
    enabled), transcript is flushed to `~/.pwn/sessions/`.
 
@@ -36,7 +46,7 @@ $ pwn --ai "run bin/pwn_sast against ./src and push findings to DefectDojo"
 
 ## What the agent can call
 
-10 toolsets · 45+ tools — full table at
+10 toolsets · 54 tools — full table at
 [Agent Tool Registry](Agent-Tool-Registry.md).
 
 The two that matter most:
@@ -46,9 +56,9 @@ The two that matter most:
 | `pwn_eval` | **Any** Ruby in-process — the whole `PWN::` namespace, `require`, monkey-patch, everything |
 | `shell` | **Any** OS command on the host |
 
-Everything else (memory, skills, learning, extrospection, cron, swarm,
-sessions, metrics) is a convenience wrapper the model can discover from the
-schema alone.
+Everything else (memory, skills, learning, **mistakes**, extrospection, cron,
+swarm, sessions, metrics) is a convenience wrapper the model can discover from
+the schema alone.
 
 ## Delegating to other agents
 
@@ -64,9 +74,12 @@ full `Loop.run` under a persona overlay) that share a JSONL bus. See
 - Disable `auto_reflect` during noisy fuzz loops
   (`learning_auto_reflect_toggle(enabled: false)`), re-enable for the summary
   turn.
+- Run `mistakes_list` before retrying something that failed last session — the
+  fix may already be recorded.
 
 **See also:** [AI Integration](AI-Integration.md) ·
 [Skills, Memory & Learning](Skills-Memory-Learning.md) ·
-[Extrospection](Extrospection.md) · [Swarm](Swarm.md) · [Cron](Cron.md)
+[Mistakes](Mistakes.md) · [Extrospection](Extrospection.md) ·
+[Swarm](Swarm.md) · [Cron](Cron.md)
 
 [← Home](Home.md)

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

@@ -9,6 +9,7 @@ require 'open3'
 require 'etc'
 require 'uri'
 require 'shellwords'
+require 'timeout'
 
 module PWN
   module AI
@@ -41,7 +42,14 @@ 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
+        WEB_SHOT_DIR = File.join(Dir.home, '.pwn', 'extrospection', 'web')
+        DEFAULT_WEB_ANCHORS = %w[
+          https://services.nvd.nist.gov/rest/json/cves/2.0
+          https://www.exploit-db.com/
+          https://raw.githubusercontent.com/0dayinc/pwn/master/lib/pwn/version.rb
+        ].freeze
 
         # Supported Method Parameters::
         # store = PWN::AI::Agent::Extrospection.load
@@ -71,7 +79,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, :web] (default all except :web)'
         # )
         #
         # Captures a fingerprint of the OUTSIDE world. When persist:true the
@@ -84,7 +92,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 +100,8 @@ 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[:web]       = probe_web       if sections.include?(:web)
           snap[:captured_at] = Time.now.utc.iso8601
           snap[:fingerprint] = Digest::SHA256.hexdigest(JSON.generate(snap.except(:captured_at)))[0, 16]
 
@@ -110,7 +120,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, :web, :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)'
@@ -236,6 +246,189 @@ module PWN
           { query: query, feeds: feeds, results: results, total: results.values.flatten.compact.length }
         end
 
+        # Supported Method Parameters::
+        # verdict = PWN::AI::Agent::Extrospection.verify(
+        #   claim:  'required - factual claim to fact-check against the live web',
+        #   kind:   'optional - :cve | :version | :doc | :generic (default auto-detect)',
+        #   url:    'optional - explicit URL the claim cites (forces kind: :doc)',
+        #   commit: 'optional - write Mistakes/Memory/observe on refute/confirm (default true)',
+        #   proxy:  'optional - upstream proxy for TransparentBrowser (e.g. "tor")'
+        # )
+        #
+        # Browser-backed self fact-checking. Drives PWN::Plugins::TransparentBrowser
+        # in :headless mode against a canonical source for the claim class,
+        # renders the DOM (JS executed), and returns:
+        #
+        #   { claim:, kind:, verdict: :confirmed|:refuted|:unknown,
+        #     confidence: 0.0..1.0,
+        #     evidence: [{url:, title:, excerpt:, dom_sha:, screenshot:}],
+        #     action_taken: :mistakes_record | :extro_observe | :learning_note | nil }
+        #
+        # On :refuted  -> Mistakes.record(tool:'assumption', error:claim) so the
+        #                 KNOWN MISTAKES block warns every future run.
+        # On :confirmed-> observe(category::intel, ttl:30d) reinforces w/ freshness.
+        # On :unknown  -> Learning.note_outcome(success:false, tags:['needs_human']).
+        #
+        # This is the extrospective mirror of Mistakes: a PROACTIVE trigger that
+        # catches the model being wrong about the world before a human does.
+
+        public_class_method def self.verify(opts = {})
+          claim = opts[:claim].to_s.strip
+          raise 'ERROR: claim is required' if claim.empty?
+
+          kind   = (opts[:kind] || detect_claim_kind(claim: claim, url: opts[:url])).to_sym
+          commit = opts.key?(:commit) ? !opts[:commit].nil? && opts[:commit] != false : true
+          proxy  = opts[:proxy] || web_config[:proxy]
+
+          evidence = []
+          verdict  = :unknown
+          conf     = 0.0
+
+          with_headless_browser(proxy: proxy) do |bo|
+            case kind
+            when :cve
+              cve = claim[/CVE-\d{4}-\d{4,}/i].to_s.upcase
+              %W[https://nvd.nist.gov/vuln/detail/#{cve} https://www.cve.org/CVERecord?id=#{cve}].each do |u|
+                fp = fingerprint_page(browser_obj: bo, url: u)
+                evidence << fp if fp
+              end
+              body = evidence.map { |e| e[:text].to_s }.join(' ')
+              if evidence.empty? || evidence.all? { |e| e[:status].to_i >= 400 } || body =~ /could not be found|does not exist|reserved but/i
+                verdict = :refuted
+                conf = 0.8
+              else
+                prod = claim.sub(/CVE-\d{4}-\d{4,}/i, '').gsub(/affects?|is|in|the/i, ' ').split.select { |w| w.length > 2 }
+                hit  = prod.count { |w| body.downcase.include?(w.downcase) }
+                if prod.empty? || hit.to_f / prod.length >= 0.5
+                  verdict = :confirmed
+                  conf = prod.empty? ? 0.6 : [0.5 + (hit.to_f / prod.length * 0.5), 0.95].min
+                else
+                  verdict = :refuted
+                  conf = 0.6
+                end
+              end
+            when :doc
+              u = opts[:url] || claim[URI::DEFAULT_PARSER.make_regexp(%w[http https])]
+              fp = fingerprint_page(browser_obj: bo, url: u)
+              evidence << fp if fp
+              if fp.nil? || fp[:status].to_i >= 400 || fp[:reachable] == false
+                verdict = :refuted
+                conf = 0.7
+              else
+                snippet = claim.sub(u.to_s, '').strip
+                overlap = fuzzy_overlap(needle: snippet, haystack: fp[:text].to_s)
+                if fp[:title].to_s =~ /not found|404|error/i && overlap < 0.2
+                  verdict = :refuted
+                  conf = 0.7
+                else
+                  verdict = overlap >= 0.4 ? :confirmed : :unknown
+                  conf    = overlap
+                end
+              end
+            when :version
+              proj = claim[/[A-Za-z][\w.+-]{2,}/].to_s
+              ver  = claim[/v?\d+\.\d+(?:\.\d+)?/].to_s
+              %W[https://rubygems.org/gems/#{proj} https://pypi.org/project/#{proj}/ https://github.com/search?q=#{URI.encode_www_form_component(proj)}&type=repositories].each do |u|
+                fp = fingerprint_page(browser_obj: bo, url: u)
+                evidence << fp if fp
+              end
+              body = evidence.map { |e| e[:text].to_s }.join(' ')
+              if !ver.empty? && body.include?(ver)
+                verdict = :confirmed
+                conf = 0.7
+              elsif body =~ /\d+\.\d+(?:\.\d+)?/
+                verdict = :unknown
+                conf = 0.3
+              end
+            else
+              q  = URI.encode_www_form_component(claim)
+              fp = fingerprint_page(browser_obj: bo, url: "https://html.duckduckgo.com/html/?q=#{q}")
+              evidence << fp if fp
+              overlap = fuzzy_overlap(needle: claim, haystack: fp ? fp[:text].to_s : '')
+              verdict = overlap >= 0.5 ? :confirmed : :unknown
+              conf    = overlap
+            end
+          end
+
+          evidence.each { |e| e.delete(:text) }
+          action = commit ? commit_verdict(claim: claim, kind: kind, verdict: verdict, confidence: conf, evidence: evidence) : nil
+          { claim: claim, kind: kind, verdict: verdict, confidence: conf.round(2), evidence: evidence, action_taken: action }
+        rescue StandardError => e
+          { claim: claim, kind: kind, verdict: :unknown, confidence: 0.0, evidence: evidence, error: "#{e.class}: #{e.message}", action_taken: nil }
+        end
+
+        # Supported Method Parameters::
+        # obs = PWN::AI::Agent::Extrospection.watch(
+        #   url:      'required - URL to render and fingerprint',
+        #   selector: 'optional - CSS selector whose innerText to hash (default full body)',
+        #   ttl:      'optional - seconds until stale (default 7 days)',
+        #   proxy:    'optional - upstream proxy for TransparentBrowser'
+        # )
+        #
+        # Passive change-detection on an external artefact you care about
+        # (target /api/version, vendor changelog, bounty scope page).
+        # Renders headless, hashes the DOM text, screenshots, and persists as
+        # observe(category: :web). On subsequent snapshot(sections:[:web]) or
+        # watch of the same URL, a hash mismatch surfaces in drift() as
+        # ~web.<host>.dom_sha exactly like ~toolchain.nmap today.
+
+        public_class_method def self.watch(opts = {})
+          url = opts[:url].to_s
+          raise 'ERROR: url is required' if url.empty?
+
+          ttl   = opts[:ttl] || (7 * 24 * 3600)
+          proxy = opts[:proxy] || web_config[:proxy]
+          fp    = nil
+          with_headless_browser(proxy: proxy) do |bo|
+            fp = fingerprint_page(browser_obj: bo, url: url, selector: opts[:selector], screenshot: true)
+          end
+          raise "unreachable: #{url}" unless fp
+
+          prior = observations(category: 'web', target: url, limit: 1).first
+          changed = prior && prior.dig(:data, :dom_sha) && prior.dig(:data, :dom_sha) != fp[:dom_sha]
+          data = fp.slice(:status, :final_url, :title, :dom_sha, :cert_fp, :cert_not_after, :screenshot).merge(excerpt: fp[:text].to_s[0, 200])
+          observe(source: 'transparent_browser', category: :web, target: url, data: data, tags: (['watch'] + Array(opts[:tags])).compact, ttl: ttl)
+          { url: url, changed: changed, prior_sha: prior && prior.dig(:data, :dom_sha), current: data }
+        end
+
+        # Supported Method Parameters::
+        # report = PWN::AI::Agent::Extrospection.revalidate_memory(
+        #   limit: 'optional - max :fact entries to check (default 25)',
+        #   proxy: 'optional - upstream proxy for TransparentBrowser'
+        # )
+        #
+        # The browser as garbage-collector for PWN::Memory. Walks :fact entries
+        # containing a CVE id, version string or URL, runs verify() on each and
+        # prefixes stale ones with [UNVERIFIED yyyy-mm-dd] so the injected
+        # MEMORY block stops calcifying into confidently-wrong priors.
+        # Designed to be scheduled: cron_create(schedule:'0 4 * * 0',
+        #   ruby:'PWN::AI::Agent::Extrospection.revalidate_memory')
+
+        public_class_method def self.revalidate_memory(opts = {})
+          return { checked: 0, refuted: [], confirmed: [], unknown: [] } unless defined?(PWN::Memory)
+
+          lim   = opts[:limit] || 25
+          proxy = opts[:proxy] || web_config[:proxy]
+          rx    = %r{(CVE-\d{4}-\d{4,}|v?\d+\.\d+\.\d+|https?://\S+)}i
+          out   = { checked: 0, refuted: [], confirmed: [], unknown: [] }
+
+          PWN::Memory.load.each do |key, v|
+            break if out[:checked] >= lim
+            next unless v.is_a?(Hash) && v[:category].to_s == 'fact' && v[:value].to_s =~ rx
+            next if v[:value].to_s.start_with?('[UNVERIFIED')
+
+            res = verify(claim: v[:value].to_s[0, 400], commit: false, proxy: proxy)
+            out[:checked] += 1
+            out[res[:verdict]] << key
+            next unless res[:verdict] == :refuted && res[:confidence] >= 0.6
+
+            stamp = Time.now.utc.strftime('%Y-%m-%d')
+            PWN::Memory.remember(key: key, value: "[UNVERIFIED #{stamp}] #{v[:value]}", category: :fact)
+            observe(source: 'extro_verify', category: :web, target: key.to_s, data: "Memory :fact '#{key}' failed re-validation (#{res[:confidence]})", tags: %w[stale memory])
+          end
+          out
+        end
+
         # Supported Method Parameters::
         # findings = PWN::AI::Agent::Extrospection.correlate(
         #   limit: 'optional - max findings returned (default 10)'
@@ -288,7 +481,54 @@ 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) :web drift on a target the same day a Learning failure references it —
+          #    "your exploit stopped working because the TARGET changed, not your approach"
+          if defined?(Learning)
+            observations(category: 'web', limit: 50).each do |ob|
+              tgt  = ob[:target].to_s
+              host = safe_host(url: tgt)
+              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." }
+              end
+            end
+          end
+
+          # 6) extro_verify refutations whose claim substring appears in a PWN::Memory :fact -> stale memory
+          if defined?(PWN::Memory)
+            observations(category: 'web', tag: 'stale', limit: 50).each do |ob|
+              findings << { kind: :stale_memory_fact, key: ob[:target], evidence: ob[:data], advice: "PWN::Memory[:#{ob[:target]}] failed browser re-verification — audit or memory_forget it before it poisons future prompts." }
+            end
+          end
+
+          # 7) :intel observations whose source anchor is currently probe_web-unreachable -> downgrade
+          web = snap[:web] || {}
+          web.each do |host, fp|
+            next unless fp.is_a?(Hash) && (fp[:reachable] == false || fp[:status].to_i >= 500)
+
+            observations(category: 'intel', limit: 100).each do |ob|
+              next unless ob[:source].to_s.include?(host.to_s) || ob[:data].to_s.include?(host.to_s)
+
+              findings << { kind: :intel_source_unreachable, source: host, status: fp[:status], intel: ob[:data].to_s[0, 120], advice: "Feed anchor #{host} is currently unreachable (#{fp[:status] || 'down'}) — treat this :intel as stale until probe_web sees it 2xx again." }
+            end
+          end
+
+          # 8) 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 +586,9 @@ 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) },
+            web_anchors: (snap[:web] || {}).count { |_, v| v.is_a?(Hash) && v[:reachable] }
           }
         end
 
@@ -478,6 +720,243 @@ 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
+
+        # Rendered-DOM fingerprint of a small, config-declared set of canonical
+        # web anchors the agent depends on for truth (feed reachability,
+        # upstream drift, in-scope target tech fingerprint). OPT-IN — never
+        # part of the default auto_extrospect section set because a headless
+        # browser is ~1-3s cold vs ~50ms for probe_host.
+        private_class_method def self.probe_web
+          anchors = web_anchors
+          return { anchors: 0 } if anchors.empty?
+
+          out = {}
+          with_headless_browser(proxy: web_config[:proxy]) do |bo|
+            anchors.first(web_config[:max_anchors]).each do |u|
+              host = safe_host(url: u).tr('.', '_')
+              fp   = fingerprint_page(browser_obj: bo, url: u, screenshot: web_config[:screenshot])
+              out[host.to_sym] = fp ? fp.slice(:status, :final_url, :title, :dom_sha, :server, :generator, :cert_fp, :cert_not_after, :reachable, :screenshot) : { reachable: false }
+            end
+          end
+          out
+        rescue StandardError => e
+          { error: "#{e.class}: #{e.message}" }
+        end
+
+        private_class_method def self.web_config
+          cfg = (PWN::Env.dig(:ai, :agent, :extrospection, :web) if defined?(PWN::Env) && PWN::Env.is_a?(Hash)) || {}
+          {
+            anchors: Array(cfg[:anchors] || cfg[:web_anchors]),
+            proxy: cfg[:proxy],
+            max_anchors: (cfg[:max_anchors] || 8).to_i,
+            per_page_timeout: (cfg[:per_page_timeout] || 15).to_i,
+            screenshot: cfg.key?(:screenshot) ? !cfg[:screenshot].nil? && cfg[:screenshot] != false : false,
+            allow_targets: cfg[:allow_targets] ? true : false
+          }
+        rescue StandardError
+          { anchors: [], proxy: nil, max_anchors: 8, per_page_timeout: 15, screenshot: false, allow_targets: false }
+        end
+
+        private_class_method def self.web_anchors
+          a = web_config[:anchors]
+          a = DEFAULT_WEB_ANCHORS.dup if a.empty?
+          a += Array(PWN::Env[:targets]) if defined?(PWN::Env) && PWN::Env.is_a?(Hash) && web_config[:allow_targets]
+          a.compact.map(&:to_s).reject(&:empty?).uniq
+        rescue StandardError
+          DEFAULT_WEB_ANCHORS.dup
+        end
+
+        private_class_method def self.safe_host(opts = {})
+          URI.parse(opts[:url].to_s).host || opts[:url].to_s
+        rescue StandardError
+          opts[:url].to_s
+        end
+
+        # One shared headless browser per call — open once, reuse across
+        # anchors, always close in ensure. Prefers :headless (firefox) which
+        # is lightest; degrades to :rest (RestClient) if watir/selenium is
+        # unavailable so probe_web/verify/watch never hard-fail the loop.
+        private_class_method def self.with_headless_browser(opts = {})
+          require 'pwn/plugins/transparent_browser'
+          bo = nil
+          begin
+            bo = PWN::Plugins::TransparentBrowser.open(browser_type: :headless, proxy: opts[:proxy])
+          rescue StandardError
+            bo = PWN::Plugins::TransparentBrowser.open(browser_type: :rest, proxy: opts[:proxy])
+          end
+          yield bo
+        ensure
+          begin
+            PWN::Plugins::TransparentBrowser.close(browser_obj: bo) if bo
+          rescue StandardError
+            nil
+          end
+        end
+
+        private_class_method def self.fingerprint_page(opts = {})
+          bo  = opts[:browser_obj]
+          url = opts[:url].to_s
+          return nil if bo.nil? || url.empty?
+
+          tmo = web_config[:per_page_timeout]
+          b   = bo[:browser]
+          if bo[:type] == :rest
+            resp = b.get(url) { |r, _rq, _res| r }
+            body = resp.body.to_s
+            require 'nokogiri'
+            doc  = Nokogiri::HTML.parse(body)
+            text = doc.text.to_s
+            cfp, cna = tls_fingerprint(url: url)
+            return { url: url, final_url: url, status: resp.code.to_i, title: doc.title.to_s,
+                     server: resp.headers[:server].to_s, generator: doc.at('meta[name="generator"]')&.[]('content').to_s,
+                     dom_sha: Digest::SHA256.hexdigest(text)[0, 16], text: text, cert_fp: cfp,
+                     cert_not_after: cna, reachable: resp.code.to_i < 400 }
+          end
+          Timeout.timeout(tmo) { b.goto(url) }
+          text  = extract_text(browser: b, selector: opts[:selector])
+          title = safe_attr(browser: b, meth: :title)
+          final = safe_attr(browser: b, meth: :url) || url
+          gen   = safe_meta(browser: b, name: 'generator')
+          shot  = opts[:screenshot] ? capture_screenshot(browser: b, url: url) : nil
+          cfp, cna = tls_fingerprint(url: final)
+          { url: url, final_url: final, status: 200, title: title.to_s, generator: gen.to_s, server: nil,
+            dom_sha: Digest::SHA256.hexdigest(text.to_s)[0, 16], text: text.to_s,
+            cert_fp: cfp, cert_not_after: cna, screenshot: shot, reachable: true }
+        rescue StandardError => e
+          { url: url, reachable: false, status: 0, error: "#{e.class}: #{e.message.to_s[0, 120]}", text: '' }
+        end
+
+        private_class_method def self.extract_text(opts = {})
+          b   = opts[:browser]
+          sel = opts[:selector]
+          return b.element(css: sel).text if sel && b.element(css: sel).exists?
+
+          b.text
+        rescue StandardError
+          b.respond_to?(:text) ? b.text.to_s : ''
+        end
+
+        private_class_method def self.safe_attr(opts = {})
+          opts[:browser].public_send(opts[:meth])
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.safe_meta(opts = {})
+          el = opts[:browser].element(css: "meta[name=\"#{opts[:name]}\"]")
+          el.exists? ? el.attribute_value('content') : ''
+        rescue StandardError
+          ''
+        end
+
+        private_class_method def self.capture_screenshot(opts = {})
+          FileUtils.mkdir_p(WEB_SHOT_DIR)
+          host = safe_host(url: opts[:url]).gsub(/[^\w.-]/, '_')
+          path = File.join(WEB_SHOT_DIR, "#{host}.png")
+          opts[:browser].screenshot.save(path)
+          path
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.tls_fingerprint(opts = {})
+          u = URI.parse(opts[:url].to_s)
+          return [nil, nil] unless u.scheme == 'https'
+
+          require 'openssl'
+          ssl = tcp = nil
+          tcp = TCPSocket.new(u.host, u.port || 443)
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          ssl = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
+          ssl.hostname = u.host
+          ssl.connect
+          cert = ssl.peer_cert
+          [Digest::SHA256.hexdigest(cert.to_der)[0, 16], cert.not_after.utc.iso8601]
+        rescue StandardError
+          [nil, nil]
+        ensure
+          ssl&.close
+          tcp&.close
+        end
+
+        private_class_method def self.fuzzy_overlap(opts = {})
+          needle = opts[:needle].to_s.downcase.scan(/[a-z0-9]{3,}/).uniq
+          hay    = opts[:haystack].to_s.downcase
+          return 0.0 if needle.empty?
+
+          hit = needle.count { |w| hay.include?(w) }
+          hit.to_f / needle.length
+        end
+
+        private_class_method def self.detect_claim_kind(opts = {})
+          c = opts[:claim].to_s
+          return :doc     if opts[:url] || c =~ URI::DEFAULT_PARSER.make_regexp(%w[http https])
+          return :cve     if c =~ /CVE-\d{4}-\d{4,}/i
+          return :version if c =~ /\bv?\d+\.\d+(?:\.\d+)?\b/
+
+          :generic
+        end
+
+        private_class_method def self.commit_verdict(opts = {})
+          claim = opts[:claim]
+          ev    = Array(opts[:evidence]).first
+          case opts[:verdict]
+          when :refuted
+            Mistakes.record(tool: 'assumption', error: "REFUTED (extro_verify #{opts[:kind]}, conf=#{opts[:confidence].round(2)}): #{claim}", args: ev&.dig(:final_url), source: :model) if defined?(Mistakes)
+            observe(source: 'extro_verify', category: :web, target: ev&.dig(:final_url), data: "REFUTED: #{claim}", tags: %w[verify refuted], ttl: 30 * 24 * 3600)
+            :mistakes_record
+          when :confirmed
+            observe(source: 'extro_verify', category: :intel, target: ev&.dig(:final_url), data: claim, tags: %w[verify confirmed], ttl: 30 * 24 * 3600)
+            :extro_observe
+          else
+            Learning.note_outcome(task: "extro_verify: #{claim[0, 120]}", success: false, details: 'verdict :unknown — needs human review', tags: %w[needs_human extro_verify]) if defined?(Learning) && Learning.respond_to?(:note_outcome)
+            :learning_note
+          end
+        rescue StandardError
+          nil
+        end
+
         private_class_method def self.flatten(opts = {})
           hash   = opts[:hash] || {}
           prefix = opts[:prefix].to_s
@@ -598,17 +1077,26 @@ 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
               PWN::AI::Agent::Extrospection.to_context                        # injected by PromptBuilder
               PWN::AI::Agent::Extrospection.stats
               PWN::AI::Agent::Extrospection.auto_extrospect(session_id: sid)  # called from Learning.auto_reflect
+              PWN::AI::Agent::Extrospection.snapshot(sections: %i[web])        # opt-in browser probe of web_anchors
+              PWN::AI::Agent::Extrospection.watch(url: 'https://target/api/version')
+              PWN::AI::Agent::Extrospection.verify(claim: 'CVE-2026-12345 affects OpenSSL 3.2.1')
+              PWN::AI::Agent::Extrospection.revalidate_memory                  # cron: GC stale PWN::Memory :fact entries
               PWN::AI::Agent::Extrospection.reset
 
               Enable end-of-run auto-extrospection with:
                 PWN::Env[:ai][:agent][:auto_extrospect] = true
 
+              Configure browser-backed :web probe / verify / watch with:
+                PWN::Env[:ai][:agent][:extrospection][:web] =
+                  { anchors: [...], proxy: 'tor', max_anchors: 8, per_page_timeout: 15, screenshot: false, allow_targets: false }
+
               #{self}.authors
           USAGE
         end