pwn 0.5.621 → 0.5.626

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

@@ -3,7 +3,7 @@
 module PWN
   module AI
     module Agent
-      # This module is an AI agent designed to analyze signal data captured by a software-defined-radio using GQRX. It uses the PWN::AI::Agent::Introspection.reflect_on method to analyze the signal data and provide insights based on the location where the data was captured. The agent can determine if the frequency is licensed or unlicensed based on FCC records and provide relevant information about the transmission. This module is useful for security professionals, researchers, and hobbyists interested in analyzing radio signals and understanding their context.
+      # This module is an AI agent designed to analyze signal data captured by a software-defined-radio using GQRX. It uses the PWN::AI::Agent::Reflect.on method to analyze the signal data and provide insights based on the location where the data was captured. The agent can determine if the frequency is licensed or unlicensed based on FCC records and provide relevant information about the transmission. This module is useful for security professionals, researchers, and hobbyists interested in analyzing radio signals and understanding their context.
       module GQRX
         # Supported Method Parameters::
         # ai_analysis = PWN::AI::Agent::GQRX.analyze(
@@ -20,7 +20,7 @@ module PWN
 
           system_role_content = "Analyze signal data captured by a software-defined-radio using GQRX at the following location: #{location}. Respond with just FCC information about the transmission if available.  If the frequency is unlicensed or not found in FCC records, state that clearly.  Be clear and concise in your analysis."
 
-          PWN::AI::Agent::Introspection.reflect_on(
+          PWN::AI::Agent::Reflect.on(
             system_role_content: system_role_content,
             request: request,
             suppress_pii_warning: true

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

@@ -29,7 +29,7 @@ module PWN
             raise "ERROR: type parameter value of #{type} is not supported"
           end
 
-          PWN::AI::Agent::Introspection.reflect_on(
+          PWN::AI::Agent::Reflect.on(
             system_role_content: system_role_content,
             request: request,
             spinner: true,

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

@@ -16,7 +16,7 @@ module PWN
       #
       # Data flows:
       #   Loop.run --(tool telemetry)--> Metrics.record
-      #   Loop.run --(final answer)----> Learning.auto_reflect (opt-in)
+      #   Loop.run --(final answer)----> Learning.auto_introspect (opt-in)
       #   model    --(tool calls)------> learning_note_outcome / _distill_skill
       #   PromptBuilder <----------------- Learning.to_context + Metrics.to_context
       #
@@ -164,9 +164,9 @@ module PWN
         #   dry_run: 'optional - when true, do not write to Memory/Skills (default false)'
         # )
         #
-        # Uses PWN::AI::Agent::Introspection (when available) to LLM-summarise the
+        # Uses PWN::AI::Agent::Reflect (when available) to LLM-summarise the
         # session into structured lessons. Falls back to a heuristic
-        # extractor when introspection is disabled so learning never stops.
+        # extractor when module_reflection is disabled so learning never stops.
 
         public_class_method def self.reflect(opts = {})
           session_id = opts[:session_id]
@@ -193,19 +193,19 @@ module PWN
         end
 
         # Supported Method Parameters::
-        # PWN::AI::Agent::Learning.auto_reflect(
+        # PWN::AI::Agent::Learning.auto_introspect(
         #   session_id: 'required - id of the just-completed session',
         #   request: 'optional - original user request (for outcome logging)',
         #   final: 'optional - final assistant answer (for outcome logging)'
         # )
         #
-        # Called by Loop.run when PWN::Env[:ai][:agent][:auto_reflect] is
+        # Called by Loop.run when PWN::Env[:ai][:agent][:auto_introspect] is
         # truthy. Never raises — learning must not break the primary loop.
 
-        public_class_method def self.auto_reflect(opts = {})
+        public_class_method def self.auto_introspect(opts = {})
           session_id = opts[:session_id]
           return unless session_id
-          return unless auto_reflect_enabled?
+          return unless auto_introspect_enabled?
 
           ok = infer_success(session_id: session_id, final: opts[:final])
           note_outcome(
@@ -218,7 +218,7 @@ module PWN
           reflect(session_id: session_id)
           Extrospection.auto_extrospect(session_id: session_id) if defined?(Extrospection)
         rescue StandardError => e
-          warn "[pwn-ai/learning] auto_reflect swallowed: #{e.class}: #{e.message}"
+          warn "[pwn-ai/learning] auto_introspect swallowed: #{e.class}: #{e.message}"
           nil
         end
 
@@ -301,10 +301,10 @@ module PWN
         # privates
         # -------------------------------------------------------------
 
-        private_class_method def self.auto_reflect_enabled?
+        private_class_method def self.auto_introspect_enabled?
           return false unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
 
-          PWN::Env.dig(:ai, :agent, :auto_reflect) ? true : false
+          PWN::Env.dig(:ai, :agent, :auto_introspect) ? true : false
         rescue StandardError
           false
         end
@@ -314,7 +314,7 @@ module PWN
         # 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
+        # this, auto_introspect 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
@@ -353,11 +353,11 @@ module PWN
 
         private_class_method def self.introspective_lessons(opts = {})
           transcript = opts[:transcript] || []
-          return [] unless defined?(PWN::AI::Agent::Introspection)
-          return [] unless defined?(PWN::Env) && PWN::Env.is_a?(Hash) && PWN::Env.dig(:ai, :introspection)
+          return [] unless defined?(PWN::AI::Agent::Reflect)
+          return [] unless defined?(PWN::Env) && PWN::Env.is_a?(Hash) && PWN::Env.dig(:ai, :module_reflection)
 
           req = "Analyse this pwn-ai session transcript and emit up to 5 durable, generalizable lessons (one per line, no numbering, imperative voice) that would make future runs faster or more reliable. Focus on tool selection, error recovery, and target-agnostic technique. Ignore trivia.\n\nTRANSCRIPT:\n#{transcript_text(transcript: transcript)}"
-          resp = PWN::AI::Agent::Introspection.reflect_on(request: req, suppress_pii_warning: true)
+          resp = PWN::AI::Agent::Reflect.on(request: req, suppress_pii_warning: true)
           resp.to_s.lines.map(&:strip).reject(&:empty?).first(5)
         rescue StandardError
           []
@@ -420,7 +420,7 @@ module PWN
               PWN::AI::Agent::Learning.note_outcome(task: 'nmap sweep 10.0.0.0/24', success: true, details: '12 hosts up')
               PWN::AI::Agent::Learning.outcomes(limit: 20, success: false)
               PWN::AI::Agent::Learning.reflect(session_id: sid)              # LLM or heuristic → PWN::Memory
-              PWN::AI::Agent::Learning.auto_reflect(session_id: sid, request: req, final: text)
+              PWN::AI::Agent::Learning.auto_introspect(session_id: sid, request: req, final: text)
               PWN::AI::Agent::Learning.distill_skill(name: 'quick_recon', session_id: sid)
               PWN::AI::Agent::Learning.consolidate(max_entries: 200)         # dedupe + prune Memory
               PWN::AI::Agent::Learning.to_context(limit: 5)                  # injected by PromptBuilder
@@ -428,7 +428,7 @@ module PWN
               PWN::AI::Agent::Learning.reset
 
               Enable end-of-run auto-learning with:
-                PWN::Env[:ai][:agent][:auto_reflect] = true
+                PWN::Env[:ai][:agent][:auto_introspect] = true
 
               #{self}.authors
           USAGE

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

@@ -241,7 +241,7 @@ module PWN
             if calls.empty?
               text = msg[:content].to_s
               append_session(session_id: session_id, role: 'assistant', content: text)
-              Learning.auto_reflect(session_id: session_id, request: request, final: text) if defined?(Learning)
+              Learning.auto_introspect(session_id: session_id, request: request, final: text) if defined?(Learning)
               return text
             end
 

data/lib/pwn/ai/agent/{introspection.rb → reflect.rb}

@@ -5,14 +5,14 @@ require 'json'
 module PWN
   module AI
     module Agent
-      # PWN::AI::Agent::Introspection is the inward-facing counterpart to
+      # PWN::AI::Agent::Reflect is the inward-facing counterpart to
       # PWN::AI::Agent::Extrospection. Where Extrospection looks OUTWARD at
       # the world the agent operates in (host state, toolchain, network,
-      # threat-intel), Introspection looks INWARD - it lets pwn hand a
-      # request to the active AI engine and reflect on its own artifacts,
-      # transcripts, findings, code, or decisions.
+      # threat-intel), Reflect looks INWARD - it lets pwn hand a request to
+      # the active AI engine and reflect on its own artifacts, transcripts,
+      # findings, code, or decisions.
       #
-      # This module is gated by `PWN::Env[:ai][:introspection]` so that
+      # This module is gated by `PWN::Env[:ai][:module_reflection]` so that
       # potentially-sensitive local data is never shipped to a remote LLM
       # unless the operator has explicitly opted in via pwn-vault / config.
       #
@@ -21,16 +21,16 @@ module PWN
       # through when it wants an LLM opinion on locally-produced data, and
       # it is also what PWN::AI::Agent::Learning.reflect uses to distill
       # session transcripts into durable PWN::Memory lessons.
-      module Introspection
+      module Reflect
         # Supported Method Parameters::
-        # response = PWN::AI::Agent::Introspection.reflect_on(
+        # response = PWN::AI::Agent::Reflect.on(
         #   request: 'required - String - What you want the AI to reflect on',
         #   system_role_content: 'optional - context to set up the model behavior for reflection',
         #   spinner: 'optional - Boolean - Display spinner during operation (default: false)',
         #   suppress_pii_warning: 'optional - Boolean - Suppress PII Warnings (default: false)'
         # )
 
-        public_class_method def self.reflect_on(opts = {})
+        public_class_method def self.on(opts = {})
           request = opts[:request]
           raise 'ERROR: request must be provided' if request.nil?
 
@@ -42,14 +42,14 @@ module PWN
 
           response = nil
 
-          ai_introspection = PWN::Env[:ai][:introspection]
+          ai_module_reflection = PWN::Env[:ai][:module_reflection]
 
-          if ai_introspection && request.length.positive?
+          if ai_module_reflection && request.length.positive?
             engine = PWN::Env[:ai][:active].to_s.downcase.to_sym
             valid_ai_engines = PWN::AI.help.reject { |e| e.downcase == :agent }.map(&:downcase)
             raise "ERROR: Unsupported AI engine. Supported engines are: #{valid_ai_engines}" unless valid_ai_engines.include?(engine)
 
-            warn "AI Introspection is enabled.  Ensure #{engine} has been authorized for use and/or requests are sanitized properly." unless suppress_pii_warning
+            warn "AI Reflection is enabled.  Ensure #{engine} has been authorized for use and/or requests are sanitized properly." unless suppress_pii_warning
             response = PWN::AI::Agent::Loop.run(
               request: request.chomp,
               system_role_content: system_role_content,
@@ -75,7 +75,7 @@ module PWN
 
         public_class_method def self.help
           puts "USAGE:
-            #{self}.reflect_on(
+            #{self}.on(
               request: 'required - String - What you want the AI to reflect on',
               system_role_content: 'optional - context to set up the model behavior for reflection',
               spinner: 'optional - Boolean - Display spinner during operation (default: false)',

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

@@ -16,7 +16,7 @@ module PWN
 
           system_role_content = 'Your sole purpose is to analyze source code snippets and generate an Exploit Prediction Scoring System (EPSS) score between 0% - 100%.  Just generate a score unless score is >= 75% in which a PoC and code fix should also be included.'
 
-          PWN::AI::Agent::Introspection.reflect_on(
+          PWN::AI::Agent::Reflect.on(
             system_role_content: system_role_content,
             request: request,
             suppress_pii_warning: true

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

@@ -29,7 +29,7 @@ PWN::AI::Agent::Registry.register(
       type: 'object',
       properties: {
         persist: { type: 'boolean', default: true, description: 'Write to disk & rotate previous baseline.' },
-        sections: { type: 'array', items: { type: 'string', enum: %w[host net toolchain repo env rf web] }, description: 'Subset of probes to run (default all).' }
+        sections: { type: 'array', items: { type: 'string', enum: %w[host net toolchain repo env rf web osint serial telecomm packet vision voice] }, description: 'Subset of probes (default all except web). auto_extrospect uses host/repo/env only; toolchain never launches GUI bins.' }
       },
       required: []
     }
@@ -86,7 +86,7 @@ PWN::AI::Agent::Registry.register(
       properties: {
         source: { type: 'string', description: 'Where it came from (nmap, shodan, burp, cve, human, ...).' },
         data: { type: 'string', description: 'The observation itself.' },
-        category: { type: 'string', enum: %w[recon vuln intel target network env rf web misc], default: 'misc' },
+        category: { type: 'string', enum: %w[recon vuln intel target network env rf web osint serial telecomm packet vision voice misc], default: 'misc' },
         target: { type: 'string', description: 'Host / IP / URL / asset the observation is about.' },
         tags: { type: 'array', items: { type: 'string' } },
         ttl: { type: 'integer', description: 'Seconds until stale (omit = forever).' }
@@ -256,12 +256,13 @@ PWN::AI::Agent::Registry.register(
   toolset: 'extrospection',
   schema: {
     name: 'extro_auto_toggle',
-    description: 'Enable/disable end-of-run auto-extrospection ' \
-                 '(PWN::Env[:ai][:agent][:auto_extrospect]). When enabled, ' \
-                 'Learning.auto_reflect ALSO calls Extrospection.auto_' \
-                 'extrospect after every final answer, so host drift is ' \
-                 'captured continuously without an explicit extro_snapshot ' \
-                 'call. Omit `enabled` to just read the current state.',
+    description: 'Enable/disable OPTIONAL ambient baseline after every ' \
+                 'final answer (PWN::Env[:ai][:agent][:auto_extrospect]). ' \
+                 'When on, Learning.auto_introspect runs Extrospection.' \
+                 'auto_extrospect with AUTO_SECTIONS (host/repo/env only) — ' \
+                 'never toolchain/rf/web, never launches burpsuite/zaproxy/' \
+                 'msfconsole/gqrx. Primary sensing stays on-demand (intel/' \
+                 'verify/watch/observe). Omit `enabled` to only query.',
     parameters: {
       type: 'object',
       properties: {
@@ -363,3 +364,305 @@ PWN::AI::Agent::Registry.register(
     )
   }
 )
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_rf_tune',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_rf_tune',
+    description: 'RF sense organ — the radio analogue of extro_watch / ' \
+                 'extro_verify. Tunes a *running* GQRX instance (remote ' \
+                 'control, never launches the GUI), demodulates, measures ' \
+                 'signal strength, and samples RDS (PI / PS / RadioText) so ' \
+                 'questions like "what\'s playing on 101.1 FM?" get a live ' \
+                 'answer. Auto-detects band plan (fm_radio → WFM_ST + RDS). ' \
+                 'Returns {ok:, freq:, hz:, strength_dbfs:, demodulator_mode:, ' \
+                 'rds:{pi,ps_name,radiotext,station}, now_playing:, station:, ' \
+                 'summary:}. On success also observe(category: :rf) so the ' \
+                 'EXTROSPECTION prompt block and extro_correlate see it. ' \
+                 'Requires GQRX remote control listening (default 7356) + ' \
+                 'an SDR attached; fails fast with actionable advice otherwise.',
+    parameters: {
+      type: 'object',
+      properties: {
+        freq: {
+          type: 'string',
+          description: 'Frequency to tune. Free-form: "101.1", "101.1 FM", ' \
+                       '"101.1 MHz", "101.100.000", "101100000", "433.92", …'
+        },
+        host: { type: 'string', description: 'GQRX remote-control host (default 127.0.0.1).' },
+        port: { type: 'integer', description: 'GQRX remote-control port (default 7356).' },
+        settle_secs: {
+          type: 'number',
+          description: 'Seconds to sample RDS after tuning (default 8, max 30).'
+        },
+        rds: {
+          type: 'boolean',
+          description: 'Force RDS sampling on/off. Default: auto (on for FM ' \
+                       'broadcast / band-plans with decoder: :rds).'
+        },
+        demodulator_mode: {
+          type: 'string',
+          description: 'Override demod (WFM_ST, WFM, FM, AM, USB, LSB, …). ' \
+                       'Default from band-plan / FM range heuristic.'
+        },
+        bandwidth: {
+          type: 'string',
+          description: 'Passband e.g. "200.000" (Hz, PWN dotted form). Default from band-plan.'
+        },
+        record: {
+          type: 'boolean',
+          default: true,
+          description: 'Also observe(category: :rf) so it hits EXTROSPECTION (default true).'
+        },
+        ttl: {
+          type: 'integer',
+          description: 'Observation TTL seconds (default 300 — radio content is ephemeral).'
+        }
+      },
+      required: %w[freq]
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:rf_tune) },
+  handler: lambda { |args|
+    o = { freq: args[:freq] }
+    o[:host]             = args[:host]             if args[:host]
+    o[:port]             = args[:port]             if args[:port]
+    o[:settle_secs]      = args[:settle_secs]      if args[:settle_secs]
+    o[:rds]              = args[:rds]              if args.key?(:rds)
+    o[:demodulator_mode] = args[:demodulator_mode] if args[:demodulator_mode]
+    o[:bandwidth]        = args[:bandwidth]        if args[:bandwidth]
+    o[:record]           = args[:record]           if args.key?(:record)
+    o[:ttl]              = args[:ttl]              if args[:ttl]
+    PWN::AI::Agent::Extrospection.rf_tune(o)
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_osint',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_osint',
+    description: 'OSINT sense organ — aggregates public open APIs (also drawn ' \
+                 'from public-api-lists) for reverse phone, IP/geo/ASN/BGP + ' \
+                 'threat reputation (ipapi.is/iplocate/ipwho.is/AbuseIPDB/' \
+                 'GreyNoise), DNS/WHOIS/RDAP, CT (crt.sh + Cert Spotter), FCC ' \
+                 'ID, patent, VIN (NHTSA), MAC OUI, ham callsign (Callook), ' \
+                 'person / missing-person (Wikipedia/Wikidata/OpenSanctions + ' \
+                 'NamUs/FBI/Charley), username pivots (GitHub/GitLab/Reddit), ' \
+                 'name demographics (Agify/Genderize/Nationalize), Shodan/' \
+                 'Hunter/VirusTotal/HIBP/SecurityTrails (keyed), Wayback, ' \
+                 'OTX/URLHaus/ThreatFox/urlscan, HackerTarget, openFDA, NPPES, ' \
+                 'Nominatim, OpenCorporates, CourtListener, SEC EDGAR, Federal ' \
+                 'Register, UK Police, EPSS + CISA KEV, Microlink unfurl, ' \
+                 'universities, and vital-records plans. kind auto-detects. ' \
+                 'Best-effort per-feed; unreachable → error hashes. ' \
+                 'observe(category: :osint) by default.',
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Phone, IP, domain, email, URL, person name, company, CIK, FCC ID, patent number, username, address, …' },
+        kind: {
+          type: 'string',
+          enum: %w[auto ip geo dns whois rdap crtsh bgp shodan hunter phone fcc_id patent person username github wayback email domain url company cik openfda vital_records threat vin mac callsign npi cve],
+          description: 'Force an OSINT kind. Omit / auto to detect from query shape.'
+        },
+        feeds: {
+          type: 'array',
+          items: { type: 'string', enum: %w[ip geo dns whois rdap crtsh bgpview shodan hunter phone fcc_id patent person username github wayback otx urlhaus threatfox urlscan hackertarget openfda nominatim opencorporates courtlistener sec_edgar vital_records ipapi_is iplocate ipwhois abuseipdb virustotal greynoise certspotter epss cisa_kev nhtsa nppes federal_register uk_police callook mac_vendor universities microlink agify genderize nationalize haveibeenpwned securitytrails] }
+        },
+        limit: { type: 'integer', default: 5 },
+        record: { type: 'boolean', default: true },
+        ttl: { type: 'integer', description: 'Observation TTL seconds (default 86400).' }
+      },
+      required: %w[query]
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:osint) },
+  handler: lambda { |args|
+    o = { query: args[:query] }
+    o[:kind]   = args[:kind]   if args[:kind]
+    o[:feeds]  = args[:feeds]  if args[:feeds]
+    o[:limit]  = args[:limit]  if args[:limit]
+    o[:record] = args[:record] if args.key?(:record)
+    o[:ttl]    = args[:ttl]    if args[:ttl]
+    PWN::AI::Agent::Extrospection.osint(o)
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_serial',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_serial',
+    description: 'Serial sense organ — open a USB-UART / modem / Arduino / ' \
+                 'RFID reader (PWN::Plugins::Serial), optional payload write ' \
+                 '(AT commands, hex bytes), drain response, disconnect. ' \
+                 'Returns text + hex + line-state + modem-params + device ' \
+                 'inventory. Never holds the port across calls. ' \
+                 'observe(category: :serial).',
+    parameters: {
+      type: 'object',
+      properties: {
+        block_dev: { type: 'string', description: 'Device path (default first /dev/ttyUSB* or /dev/ttyACM*).' },
+        baud: { type: 'integer', description: 'Baud rate (default 9600).' },
+        payload: { type: 'string', description: 'String payload to write (e.g. "ATI\\r"). For raw bytes use pwn_eval.' },
+        settle_secs: { type: 'number', description: 'Seconds to read after write (default 1.5, max 30).' },
+        data_bits: { type: 'integer', default: 8 },
+        stop_bits: { type: 'integer', default: 1 },
+        parity: { type: 'string', enum: %w[none even odd mark space], default: 'none' },
+        record: { type: 'boolean', default: true },
+        ttl: { type: 'integer' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:serial_sense) },
+  handler: lambda { |args|
+    o = {}
+    o[:block_dev]   = args[:block_dev]   if args[:block_dev]
+    o[:baud]        = args[:baud]        if args[:baud]
+    o[:payload]     = args[:payload]     if args[:payload]
+    o[:settle_secs] = args[:settle_secs] if args[:settle_secs]
+    o[:data_bits]   = args[:data_bits]   if args[:data_bits]
+    o[:stop_bits]   = args[:stop_bits]   if args[:stop_bits]
+    o[:parity]      = args[:parity]      if args[:parity]
+    o[:record]      = args[:record]      if args.key?(:record)
+    o[:ttl]         = args[:ttl]         if args[:ttl]
+    PWN::AI::Agent::Extrospection.serial_sense(o)
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_telecomm',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_telecomm',
+    description: 'Telecomm sense organ (SIP / VoIP / PSTN) — senses a running ' \
+                 'BareSIP instance over HTTP control (never launches it). ' \
+                 'Actions: :inventory / :status / :dial / :hangup. Dial is ' \
+                 'OPSEC-sensitive (real call). observe(category: :telecomm).',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: %w[inventory status dial hangup], default: 'inventory' },
+        target: { type: 'string', description: 'SIP URI or E.164 number for action:dial (e.g. sip:alice@example.com or +13125551212).' },
+        host: { type: 'string', description: 'BareSIP HTTP host (default 127.0.0.1).' },
+        port: { type: 'integer', description: 'BareSIP HTTP port (default 8000).' },
+        record: { type: 'boolean', default: true },
+        ttl: { type: 'integer' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:telecomm) },
+  handler: lambda { |args|
+    o = {}
+    o[:action] = args[:action] if args[:action]
+    o[:target] = args[:target] if args[:target]
+    o[:host]   = args[:host]   if args[:host]
+    o[:port]   = args[:port]   if args[:port]
+    o[:record] = args[:record] if args.key?(:record)
+    o[:ttl]    = args[:ttl]    if args[:ttl]
+    PWN::AI::Agent::Extrospection.telecomm(o)
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_packet',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_packet',
+    description: 'Packet sense organ — L2/L3 capture & pcap summarisation via ' \
+                 'tshark/tcpdump + PWN::Plugins::Packet. Actions: :inventory, ' \
+                 ':capture (bounded count/timeout → ~/.pwn/extrospection/packet/*.pcap), ' \
+                 ':summarize_pcap. observe(category: :packet).',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: %w[inventory capture summarize_pcap], default: 'inventory' },
+        iface: { type: 'string', description: 'Capture interface (default first non-lo or any).' },
+        filter: { type: 'string', description: 'BPF filter e.g. "tcp port 443".' },
+        count: { type: 'integer', description: 'Packets to capture (default 20, max 200).' },
+        timeout: { type: 'integer', description: 'Capture seconds (default 5, max 60).' },
+        path: { type: 'string', description: 'Existing pcap path for action:summarize_pcap.' },
+        record: { type: 'boolean', default: true },
+        ttl: { type: 'integer' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:packet_sense) },
+  handler: lambda { |args|
+    o = {}
+    %i[action iface filter count timeout path ttl].each { |k| o[k] = args[k] if args[k] }
+    o[:record] = args[:record] if args.key?(:record)
+    PWN::AI::Agent::Extrospection.packet_sense(o)
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_vision',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_vision',
+    description: 'Vision / OCR sense organ — OCR an image via PWN::Plugins::OCR ' \
+                 '(tesseract / RTesseract) or decode barcodes/QR via zbarimg. ' \
+                 'Actions: :ocr, :barcode, :inventory. observe(category: :vision).',
+    parameters: {
+      type: 'object',
+      properties: {
+        file: { type: 'string', description: 'Path to image (png/jpg/tiff/webp) for :ocr / :barcode.' },
+        action: { type: 'string', enum: %w[ocr barcode inventory], description: 'Default :ocr when file given, else :inventory.' },
+        lang: { type: 'string', description: 'Tesseract language (default eng).' },
+        record: { type: 'boolean', default: true },
+        ttl: { type: 'integer' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:vision) },
+  handler: lambda { |args|
+    o = {}
+    o[:file]   = args[:file]   if args[:file]
+    o[:action] = args[:action] if args[:action]
+    o[:lang]   = args[:lang]   if args[:lang]
+    o[:record] = args[:record] if args.key?(:record)
+    o[:ttl]    = args[:ttl]    if args[:ttl]
+    PWN::AI::Agent::Extrospection.vision(o)
+  }
+)
+
+PWN::AI::Agent::Registry.register(
+  name: 'extro_voice',
+  toolset: 'extrospection',
+  schema: {
+    name: 'extro_voice',
+    description: 'Voice sense organ — text-to-speech (espeak-ng / festival / ' \
+                 'spd-say via PWN::Plugins::Voice) and speech-to-text (whisper). ' \
+                 'Actions: :inventory, :tts, :stt. Artefacts under ' \
+                 '~/.pwn/extrospection/voice/. observe(category: :voice).',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: %w[inventory tts stt], default: 'inventory' },
+        text: { type: 'string', description: 'Text to speak for action:tts.' },
+        text_path: { type: 'string', description: 'Path to text file for action:tts.' },
+        audio: { type: 'string', description: 'Path to audio file for action:stt.' },
+        out: { type: 'string', description: 'Output wav path for action:tts.' },
+        engine: { type: 'string', enum: %w[espeak festival spd_say whisper], description: 'Force engine (auto by default).' },
+        model: { type: 'string', description: 'Whisper model for STT (default tiny).' },
+        record: { type: 'boolean', default: true },
+        ttl: { type: 'integer' }
+      },
+      required: []
+    }
+  },
+  check: -> { defined?(PWN::AI::Agent::Extrospection) && PWN::AI::Agent::Extrospection.respond_to?(:voice_sense) },
+  handler: lambda { |args|
+    o = {}
+    %i[action text text_path audio out engine model ttl].each { |k| o[k] = args[k] if args[k] }
+    o[:record] = args[:record] if args.key?(:record)
+    PWN::AI::Agent::Extrospection.voice_sense(o)
+  }
+)

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

@@ -190,13 +190,13 @@ PWN::AI::Agent::Registry.register(
 )
 
 PWN::AI::Agent::Registry.register(
-  name: 'learning_auto_reflect_toggle',
+  name: 'learning_auto_introspect_toggle',
   toolset: 'learning',
   schema: {
-    name: 'learning_auto_reflect_toggle',
+    name: 'learning_auto_introspect_toggle',
     description: 'Enable/disable end-of-run auto-reflection ' \
-                 '(PWN::Env[:ai][:agent][:auto_reflect]). When enabled, ' \
-                 'Loop.run calls Learning.auto_reflect on the session after ' \
+                 '(PWN::Env[:ai][:agent][:auto_introspect]). When enabled, ' \
+                 'Loop.run calls Learning.auto_introspect on the session after ' \
                  'every final answer. Disable during noisy fuzzing loops; ' \
                  're-enable for the summary turn. Omit `enabled` to just ' \
                  'read the current state.',
@@ -214,8 +214,8 @@ PWN::AI::Agent::Registry.register(
     raise 'PWN::Env[:ai] is unavailable or immutable' unless ai.is_a?(Hash) && !ai.frozen?
 
     ai[:agent] = (ai[:agent] || {}).dup if ai[:agent].nil? || ai[:agent].frozen?
-    prev = ai[:agent][:auto_reflect] ? true : false
-    ai[:agent][:auto_reflect] = (args[:enabled] ? true : false) if args.key?(:enabled)
-    { previous: prev, current: ai[:agent][:auto_reflect] ? true : false }
+    prev = ai[:agent][:auto_introspect] ? true : false
+    ai[:agent][:auto_introspect] = (args[:enabled] ? true : false) if args.key?(:enabled)
+    { previous: prev, current: ai[:agent][:auto_introspect] ? true : false }
   }
 )

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

@@ -20,7 +20,7 @@ module PWN
 
           system_role_content = "Being an expert penetration tester skilled in code analysis, debugging, and exploitation while stepping through JavaScript in a Chrome DevTools debugging session:  1. Your sole purpose is to analyze each JavaScript step and generate an Exploit Prediction Scoring System (EPSS) score between 0% - 100%.  The step currently resides in this block of JavaScript:\n```\n#{source_to_review}\n```\n2. If the score is >= 75%, generate a JavaScript proof-of-concept that would allow a threat actor to directly exploit or target a user for exploitation (i.e. no self-exploit).  3. If the EPSS score is >= 75% also provide a code fix. *** If the EPSS score is < 75%, no explanations or summaries - just the EPSS score."
 
-          PWN::AI::Agent::Introspection.reflect_on(
+          PWN::AI::Agent::Reflect.on(
             system_role_content: system_role_content,
             request: request,
             suppress_pii_warning: true

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

@@ -12,7 +12,7 @@ module PWN
       # 4. CVSS score, vector string, and first.org calculator URI
       # 5. CWE category, brief description, and CWE URI
       # 6. Relevant NIST 800-53 control
-      # It leverages the PWN::AI::Agent::Introspection.reflect_on method. Defaults to Jira for existing workflow compatibility.
+      # It leverages the PWN::AI::Agent::Reflect.on method. Defaults to Jira for existing workflow compatibility.
       module VulnGen
         # Supported Method Parameters::
         # ai_analysis = PWN::AI::Agent::VulnGen.analyze(
@@ -60,7 +60,7 @@ module PWN
           6. NIST 800-53 Security Control that is impacted by this vulnerability.
           "
 
-          analysis = PWN::AI::Agent::Introspection.reflect_on(
+          analysis = PWN::AI::Agent::Reflect.on(
             system_role_content: system_role_content,
             request: request,
             suppress_pii_warning: true

data/lib/pwn/ai/agent.rb

@@ -27,7 +27,7 @@ module PWN
       autoload :Learning,      'pwn/ai/agent/learning'
       autoload :Mistakes,      'pwn/ai/agent/mistakes'
       autoload :Extrospection, 'pwn/ai/agent/extrospection'
-      autoload :Introspection, 'pwn/ai/agent/introspection'
+      autoload :Reflect,       'pwn/ai/agent/reflect'
       autoload :Swarm,         'pwn/ai/agent/swarm'
 
       # Display a List of Every PWN::AI Module