pwn 0.5.666 → 0.5.668

data/lib/pwn/ai.rb

@@ -11,6 +11,7 @@ module PWN
     autoload :Grok, 'pwn/ai/grok'
     autoload :Ollama, 'pwn/ai/ollama'
     autoload :OpenAI, 'pwn/ai/open_ai'
+    autoload :OpenWebUI, 'pwn/ai/open_web_ui'
     autoload :RedTeam, 'pwn/ai/red_team'
 
     # Display a List of Every PWN::AI Module

data/lib/pwn/config.rb

@@ -67,12 +67,14 @@ module PWN
             }
           },
           ollama: {
-            base_uri: 'required - Base URI for Open WebUI - e.g. https://ollama.local',
-            key: 'required - Open WebUI API Key Under Settings  >> Account >> JWT Token',
-            model: 'required - Ollama model to use',
+            # Direct Ollama server (stock: http://127.0.0.1:11434). No key required.
+            base_uri: 'optional - Base URI for Ollama server (default http://127.0.0.1:11434)',
+            key: 'optional - bearer token only if a reverse-proxy sits in front of Ollama (stock ollama needs none)',
+            model: 'required - Ollama model tag to use',
             embed_model: 'optional - embedding model for PWN::MemoryIndex (default nomic-embed-text)',
             system_role_content: 'You are an ethically hacking Ollama agent.',
             temp: 'optional - Ollama temperature',
+            tool_temp: 0.1, # lower temperature when tools are present (chat_with_tools)
             num_ctx: 32_768,
             # Cap decode length so thinking models cannot stream forever
             # (Net::HTTP read_timeout only fires on idle gaps between chunks).
@@ -85,6 +87,22 @@ module PWN
             result_max: 4_000, # tool-result cap for local models (frontier keeps Result::DEFAULT_MAX)
             max_prompt_length: 32_000
           },
+          openwebui: {
+            # Open WebUI gateway in front of one or more model backends.
+            base_uri: 'required - Base URI for Open WebUI - e.g. https://openwebui.local',
+            key: 'required - Open WebUI API Key Under Settings >> Account >> JWT Token',
+            model: 'required - model id/tag exposed by Open WebUI',
+            embed_model: 'optional - embedding model for PWN::MemoryIndex when ollama direct is unset (default nomic-embed-text)',
+            system_role_content: 'You are an ethically hacking Open WebUI agent.',
+            temp: 'optional - Open WebUI temperature',
+            tool_temp: 0.1, # lower temperature when tools are present (chat_with_tools)
+            num_ctx: 32_768,
+            num_predict: 4_096,
+            keep_alive: '30m',
+            prompt_budget: { memory: 6, metrics: 3, mistakes: 3, learning: 2, extro: false },
+            result_max: 4_000,
+            max_prompt_length: 32_000
+          },
           anthropic: {
             base_uri: 'optional - Base URI for Anthropic - Use private base OR defaults to https://api.anthropic.com/v1',
             key: 'required - Anthropic API Key',
@@ -135,8 +153,8 @@ module PWN
             # (host/repo/env probes only — no toolchain/GUI/net side-effects)
             auto_extrospect: true,
             # engine-agnostic scaffolding (defaults tuned for local models)
-            plan_first: nil,               # nil = auto (true when :active == :ollama)
-            tool_router: nil,              # nil = auto (true when :active == :ollama) — cuts ~11k→~3k schema tokens
+            plan_first: nil,               # nil = auto (true when :active is :ollama or :openwebui)
+            tool_router: nil,              # nil = auto (true when :active is local :ollama/:openwebui) — cuts ~11k→~3k schema tokens
             escalation_persona: 'escalator', # Swarm persona for frontier corrective hints when a local model is stuck
             # sample E3 verify_as_reward: true|false|nil(auto: ~10% local / always frontier when CLAIM_RX hits)
             verify_as_reward: nil,
@@ -360,37 +378,33 @@ module PWN
       target
     end
 
-    # Inject Ollama/RL scaffolding defaults into a vault-loaded env hash
-    # before freeze. Never overwrites operator choices already in the vault.
+    # Inject AI engine + agent scaffolding defaults into a vault-loaded env
+    # hash before freeze. Never overwrites operator choices already in the vault.
+    # Also seeds a missing engine block when ai.active points at a known engine
+    # that is absent from older vaults (e.g. active: ollama with no ai.ollama
+    # hash) so refresh_env does not NoMethodError on env[:ai][engine][:key].
     private_class_method def self.merge_ai_defaults!(opts = {})
       env = opts[:env]
       return env unless env.is_a?(Hash) && env[:ai].is_a?(Hash)
 
-      # Pull the in-code default template without writing a file.
-      template = {
-        ollama: {
-          result_max: 4_000
-        },
-        agent: {
-          max_iters: 75,
-          tool_router: nil,
-          escalation_persona: 'escalator',
-          verify_as_reward: nil,
-          local_introspect: :failure_only,
-          introspect_every_n: 3,
-          critic: nil,
-          counterfactual: nil,
-          red_team_plan: nil,
-          hindsight: true,
-          reward_llm: nil,
-          history_keep_tool_pairs: 6,
-          history_tool_max_chars: 2_000
-        }
-      }
-      env[:ai][:ollama] = {} unless env[:ai][:ollama].is_a?(Hash)
-      env[:ai][:agent]  = {} unless env[:ai][:agent].is_a?(Hash)
-      deep_fill!(target: env[:ai][:ollama], defaults: template[:ollama])
-      deep_fill!(target: env[:ai][:agent], defaults: template[:agent])
+      ai_tmpl = env_template[:ai]
+      return env unless ai_tmpl.is_a?(Hash)
+
+      # Deep-fill every Hash-shaped ai.* slot from the release template
+      # (engines + :agent). Scalars like :active / :module_reflection are
+      # left untouched — only ABSENT nested keys are supplied.
+      ai_tmpl.each do |slot, defaults|
+        next unless defaults.is_a?(Hash)
+
+        env[:ai][slot] = {} unless env[:ai][slot].is_a?(Hash)
+        deep_fill!(target: env[:ai][slot], defaults: defaults)
+      end
+
+      # If active names a supported engine symbol and the slot is still
+      # somehow non-Hash, force an empty Hash so callers can index safely.
+      engine = env[:ai][:active].to_s.downcase.to_sym
+      env[:ai][engine] = {} if !engine.empty? && engine != :agent && !env[:ai][engine].is_a?(Hash)
+
       env
     rescue StandardError => e
       warn "[pwn/config] merge_ai_defaults! swallowed: #{e.class}: #{e.message}"
@@ -430,9 +444,17 @@ module PWN
 
       valid_ai_engines = PWN::AI.help.reject { |e| e.downcase == :agent }.map(&:downcase)
 
+      raise "ERROR: PWN Environment (#{pwn_env_path}) is missing ai: Hash" unless env.is_a?(Hash) && env[:ai].is_a?(Hash)
+
       engine = env[:ai][:active].to_s.downcase.to_sym
       raise "ERROR: Unsupported AI Engine: #{engine} in #{pwn_env_path}.  Supported AI Engines:\n#{valid_ai_engines.inspect}" unless valid_ai_engines.include?(engine)
 
+      # Backfill missing ai.<engine> / ai.agent keys from env_template BEFORE
+      # indexing env[:ai][engine][:key]. Older vaults may set ai.active to a
+      # newly supported engine (e.g. ollama) without shipping that engine's
+      # config block yet.
+      merge_ai_defaults!(env: env)
+
       # Determine whether the active engine already has usable auth
       # material so the pwn / pwn-ai REPL driver does not prompt for an
       # API key when OAuth is configured via pwn-vault.
@@ -442,7 +464,10 @@ module PWN
       # written by PWN::Config.default_env into a fresh ~/.pwn/pwn.yaml.
       real_cfg = lambda do |v|
         s = v.to_s.strip
-        !s.empty? && !s.match?(/\A(optional|required)\b/i)
+        !(s.empty? ||
+           s.match?(/\A(optional|required)\b/i) ||
+           s.match?(/REDACTED/i) ||
+           s.match?(/\A<{3}.*>{3}\z/))
       end
 
       key = env[:ai][engine][:key]
@@ -475,9 +500,18 @@ module PWN
           anthropic: 'or store ai.anthropic.oauth.refresh_token via pwn-vault -- run PWN::AI::Anthropic.obtain_oauth_bearer_token to enroll'
         }
         enroll_hint = enroll_hints[engine]
-        prompt = enroll_hint ? "#{engine} API Key (#{enroll_hint})" : "#{engine} API Key"
-        key = PWN::Plugins::AuthenticationHelper.mask_password(prompt: prompt)
-        env[:ai][engine][:key] = key
+        # engine is a Symbol (e.g. :ollama). Compare as Symbol — the old
+        # String check `!= 'ollama'` was ALWAYS true, so active: ollama still
+        # prompted for an API key even though stock ollama needs none.
+        # openwebui still requires a JWT/API key and is NOT skipped here.
+        # Keep this skip list engine-symbol based only. Do not gate on base_uri
+        # hostnames — reverse-proxied ollama may still need no key.
+
+        if engine != :ollama
+          prompt = enroll_hint ? "#{engine} API Key (#{enroll_hint})" : "#{engine} API Key"
+          key = PWN::Plugins::AuthenticationHelper.mask_password(prompt: prompt)
+          env[:ai][engine][:key] = key
+        end
       end
 
       model = env[:ai][engine][:model]

data/lib/pwn/memory.rb

@@ -121,23 +121,150 @@ module PWN
     # Supported Method Parameters::
     #   results = PWN::Memory.recall(
     #     query: 'optional - string to search keys/values/categories (simple match)',
-    #     category: 'optional - filter by category',
-    #     limit: 'optional - max results (default 50)'
+    #     category: 'optional - filter by category (:session = transcript only)',
+    #     limit: 'optional - max results (default 50)',
+    #     session_id: 'optional - current session (default Env/Pry active id)'
     #   )
+    # Returns session turns first (previous assistant response -> older, current
+    # session only, empty/invalid skipped), then durable memory newest-first.
+
     public_class_method def self.recall(opts = {})
       query = opts[:query].to_s.downcase
       category = opts[:category]
-      limit = opts[:limit] || 50
+      limit = (opts[:limit] || 50).to_i
+      limit = 50 if limit <= 0
+      session_id = opts[:session_id]
+      session_id = current_session_id if session_id.to_s.empty?
+      # Default ON for memory_recall tool UX. to_context passes false so the
+      # injected MEMORY block stays durable cross-session facts only.
+      include_session = if opts.key?(:include_session)
+                          opts[:include_session] ? true : false
+                        else
+                          true
+                        end
+
+      ordered = {}
+
+      # 1) Current-session turns first: start at previous response, walk older.
+      #    Skips empty/invalid turns. Stays scoped to this session only.
+      if include_session && !(category && category.to_sym != :session)
+        session_turns(session_id: session_id, query: query, limit: limit).each do |entry|
+          break if ordered.length >= limit
+
+          key = entry[:key]
+          ordered[key] = entry.except(:key)
+        end
+      end
 
-      mem = load
-      results = mem.select do |k, v|
-        match = true
-        match &&= k.to_s.downcase.include?(query) || v[:value].to_s.downcase.include?(query) || v[:category].to_s.downcase.include?(query) if query && !query.empty?
-        match &&= (v[:category] == category.to_sym) if category
-        match
+      # 2) Durable ~/.pwn/memory.json (newest timestamp first) fills remaining slots.
+      if ordered.length < limit && !(category && category.to_sym == :session)
+        mem = load
+        durable = mem.select do |k, v|
+          match = true
+          if query && !query.empty?
+            match &&= k.to_s.downcase.include?(query) ||
+                      v[:value].to_s.downcase.include?(query) ||
+                      v[:category].to_s.downcase.include?(query)
+          end
+          match &&= (v[:category].to_s == category.to_s) if category
+          match
+        end
+        durable_sorted = durable.sort_by do |k, v|
+          [-Time.parse(v[:timestamp].to_s).to_i, k.to_s]
+        rescue StandardError
+          [0, k.to_s]
+        end
+        durable_sorted.each do |k, v|
+          break if ordered.length >= limit
+          next if ordered.key?(k)
+
+          ordered[k] = v
+        end
       end
 
-      results.to_a.first(limit).to_h
+      ordered
+    end
+
+    # Resolve the active pwn-ai session id (Env, then Pry config).
+    public_class_method def self.current_session_id(opts = {})
+      sid = opts[:session_id].to_s
+      return sid unless sid.empty?
+
+      if defined?(PWN::Env) && PWN::Env.is_a?(Hash)
+        sid = PWN::Env.dig(:ai, :session_id).to_s
+        return sid unless sid.empty?
+      end
+
+      return Pry.config.pwn_ai_session_id.to_s if defined?(Pry) && Pry.respond_to?(:config) && Pry.config.respond_to?(:pwn_ai_session_id)
+
+      ''
+    end
+
+    # Walk the current session transcript from the previous assistant response
+    # backward (previous -> older). Empty/invalid turns are skipped.
+    # Returns Array of hashes with :key plus entry fields (role/value/...).
+    public_class_method def self.session_turns(opts = {})
+      sid = opts[:session_id].to_s
+      sid = current_session_id if sid.empty?
+      return [] if sid.empty?
+      return [] unless defined?(PWN::Sessions)
+
+      query = opts[:query].to_s.downcase
+      limit = (opts[:limit] || 50).to_i
+      limit = 50 if limit <= 0
+
+      rows = PWN::Sessions.load(session_id: sid)
+      return [] if rows.nil? || rows.empty?
+
+      valid = []
+      rows.each_with_index do |e, idx|
+        next unless e.is_a?(Hash)
+
+        role = e[:role].to_s
+        content = e[:content].to_s
+        next if content.strip.empty?
+        next unless %w[assistant user tool system observation].include?(role)
+        # Skip the bootstrap system line when it has no useful body.
+        next if role == 'system' && content.match?(/\ASession started:/i)
+
+        valid << {
+          idx: idx,
+          role: role,
+          content: content,
+          timestamp: e[:timestamp]
+        }
+      end
+      return [] if valid.empty?
+
+      # Previous response = most recent non-empty assistant turn in-session.
+      last_asst = valid.rindex { |e| e[:role] == 'assistant' }
+      # If no assistant yet, still walk backward from the latest valid turn.
+      start_at = last_asst || (valid.length - 1)
+      backward = valid[0..start_at].reverse
+
+      hits = []
+      backward.each do |e|
+        break if hits.length >= limit
+
+        content = e[:content]
+        role = e[:role]
+        if query && !query.empty? && !(content.downcase.include?(query) ||
+                      role.include?(query) ||
+                      "session_#{sid}".include?(query))
+          next
+        end
+
+        hits << {
+          key: :"session_turn_#{sid}_#{e[:idx]}",
+          value: content,
+          category: :session,
+          role: role,
+          timestamp: e[:timestamp],
+          session_id: sid,
+          source: 'session_backward'
+        }
+      end
+      hits
     end
 
     # Supported Method Parameters::
@@ -196,7 +323,7 @@ module PWN
     #   (used internally by pwn-ai hook to inject into system prompt)
     public_class_method def self.to_context(opts = {})
       limit = opts[:limit] || 20
-      mem = recall(limit: limit)
+      mem = recall(limit: limit, include_session: false)
       return '' if mem.empty?
 
       ctx = "\n\nPERSISTENT MEMORY (cross-session facts, prefs, lessons - use PWN::Memory.remember to store new ones):\n"
@@ -290,6 +417,8 @@ module PWN
           mem = PWN::Memory.load
           PWN::Memory.remember(key: :user_prefers_ruby, value: 'Always prefer pure Ruby + RestClient patterns', category: :preference)
           facts = PWN::Memory.recall(query: 'recon', category: :fact, limit: 10)
+          # session-first (previous response → older), then durable newest-first:
+          sess  = PWN::Memory.recall(limit: 10)  # or session_id: '20260811_...'
           hits  = PWN::Memory.recall_semantic(query: 'recon', limit: 6)  # embedding-ranked
           PWN::Memory.forget(key: :some_key)
           PWN::Memory.forget(key: :operator_pref_x) rescue puts('protected')

data/lib/pwn/memory_index.rb

@@ -8,9 +8,10 @@ module PWN
   # PWN::MemoryIndex is a lightweight local embedding index over
   # PWN::Memory (~/.pwn/memory.json) so PromptBuilder can inject the N
   # MOST-RELEVANT memories for the current request instead of the N
-  # newest. Embeddings come from the local Ollama instance
-  # (PWN::Env[:ai][:ollama][:embed_model], default 'nomic-embed-text') via
-  # its native /api/embed endpoint — everything stays on-box.
+  # newest. Embeddings prefer a direct Ollama /api/embed endpoint
+  # (PWN::Env[:ai][:ollama][:embed_model], default 'nomic-embed-text').
+  # When only Open WebUI is configured, embeddings go through its
+  # /ollama/api/embed proxy with the openwebui key/base_uri.
   #
   # Index layout (~/.pwn/memory.idx):
   #   { "<key>": { "sha": "<sha16 of value>", "vec": [Float,…] }, … }
@@ -24,11 +25,11 @@ module PWN
     # Supported Method Parameters::
     #   bool = PWN::MemoryIndex.available?
     #
-    # True when a local Ollama base_uri is configured. All public methods
-    # degrade to substring recall when this is false.
+    # True when a local Ollama or Open WebUI base_uri is configured. All
+    # public methods degrade to substring recall when this is false.
 
     public_class_method def self.available?
-      !ollama_base.nil?
+      !embed_endpoint.nil?
     rescue StandardError
       false
     end
@@ -122,26 +123,27 @@ module PWN
     # Supported Method Parameters::
     #   vecs = PWN::MemoryIndex.embed(texts: ['a', 'b'])
     #
-    # POST /api/embed on the local Ollama; returns Array<Array<Float>> (one
-    # vector per input, nil on per-item failure). Batches of 32.
+    # POST /api/embed on direct Ollama, or /ollama/api/embed via Open WebUI.
+    # Returns Array<Array<Float>> (one vector per input, nil on per-item
+    # failure). Batches of 32.
 
     public_class_method def self.embed(opts = {})
       texts = Array(opts[:texts]).map(&:to_s)
-      base  = ollama_base
-      return Array.new(texts.length) unless base && !texts.empty?
+      ep = embed_endpoint
+      return Array.new(texts.length) unless ep && !texts.empty?
 
-      model = (PWN::Env.dig(:ai, :ollama, :embed_model) if defined?(PWN::Env)) || DEFAULT_EMBED_MODEL
+      model = ep[:model]
       browser = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)
       rest    = browser[:browser]::Request
       headers = { content_type: 'application/json; charset=UTF-8' }
-      token   = PWN::Env.dig(:ai, :ollama, :key) if defined?(PWN::Env)
-      headers[:authorization] = "Bearer #{token}" if token
+      token   = ep[:token]
+      headers[:authorization] = "Bearer #{token}" if token && !token.to_s.empty?
 
       out = []
       texts.each_slice(32) do |batch|
         resp = rest.execute(
           method: :post,
-          url: "#{base}/ollama/api/embed",
+          url: ep[:url],
           headers: headers,
           payload: { model: model, input: batch }.to_json,
           verify_ssl: false,
@@ -201,11 +203,50 @@ module PWN
       Digest::SHA256.hexdigest(opts[:text].to_s)[0, 16]
     end
 
-    private_class_method def self.ollama_base
+    # Prefer direct Ollama (native /api/embed). Fall back to Open WebUI's
+    # /ollama/api/embed proxy when only openwebui is configured.
+    private_class_method def self.embed_endpoint
       return nil unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
 
-      b = PWN::Env.dig(:ai, :ollama, :base_uri).to_s
-      b.start_with?('http') ? b.chomp('/') : nil
+      ollama_b = PWN::Env.dig(:ai, :ollama, :base_uri).to_s.strip
+      if ollama_b.start_with?('http')
+        model = PWN::Env.dig(:ai, :ollama, :embed_model).to_s
+        model = DEFAULT_EMBED_MODEL if model.empty? || model.match?(/\A(optional|required)\b/i)
+        token = PWN::Env.dig(:ai, :ollama, :key)
+        token = nil if token.to_s.strip.empty? || token.to_s.match?(/\A(optional|required)\b/i)
+        return {
+          url: "#{ollama_b.chomp('/')}/api/embed",
+          model: model,
+          token: token,
+          via: :ollama
+        }
+      end
+
+      owu_b = PWN::Env.dig(:ai, :openwebui, :base_uri).to_s.strip
+      return nil unless owu_b.start_with?('http')
+
+      model = PWN::Env.dig(:ai, :openwebui, :embed_model).to_s
+      model = PWN::Env.dig(:ai, :ollama, :embed_model).to_s if model.empty?
+      model = DEFAULT_EMBED_MODEL if model.empty? || model.match?(/\A(optional|required)\b/i)
+      token = PWN::Env.dig(:ai, :openwebui, :key)
+      token = nil if token.to_s.strip.empty? || token.to_s.match?(/\A(optional|required)\b/i)
+      {
+        url: "#{owu_b.chomp('/')}/ollama/api/embed",
+        model: model,
+        token: token,
+        via: :openwebui
+      }
+    rescue StandardError
+      nil
+    end
+
+    # Backward-compatible private alias (specs / older callers).
+    private_class_method def self.ollama_base
+      ep = embed_endpoint
+      return nil unless ep
+
+      # Strip trailing path so callers that append still work if any remain.
+      ep[:url].sub(%r{/api/embed\z}, '').sub(%r{/ollama\z}, '')
     end
 
     private_class_method def self.fallback(opts = {})
@@ -234,8 +275,13 @@ module PWN
           PWN::MemoryIndex.embed(texts: ['a', 'b'])                   # raw vectors
           PWN::MemoryIndex.reset
 
-          Config:
-            PWN::Env[:ai][:ollama][:embed_model] = '<embed-model-tag>'  # any embedding model pulled locally
+          Config (prefer direct Ollama; Open WebUI is the fallback proxy):
+            PWN::Env[:ai][:ollama][:base_uri] = 'http://127.0.0.1:11434'
+            PWN::Env[:ai][:ollama][:embed_model] = '<embed-model-tag>'
+            # or:
+            PWN::Env[:ai][:openwebui][:base_uri] = 'https://openwebui.local'
+            PWN::Env[:ai][:openwebui][:key] = '<jwt>'
+            PWN::Env[:ai][:openwebui][:embed_model] = '<embed-model-tag>'
 
           #{self}.authors
       USAGE

data/lib/pwn/plugins/repl.rb

@@ -1260,16 +1260,18 @@ module PWN
               chat_opts[:system_role_content] = system_role if system_role
 
               case engine
+              when :anthropic
+                response = PWN::AI::Anthropic.chat(**chat_opts)
+              when :gemini
+                response = PWN::AI::Gemini.chat(**chat_opts)
               when :grok
                 response = PWN::AI::Grok.chat(**chat_opts)
               when :ollama
                 response = PWN::AI::Ollama.chat(**chat_opts)
               when :openai
                 response = PWN::AI::OpenAI.chat(**chat_opts)
-              when :anthropic
-                response = PWN::AI::Anthropic.chat(**chat_opts)
-              when :gemini
-                response = PWN::AI::Gemini.chat(**chat_opts)
+              when :openwebui
+                response = PWN::AI::OpenWebUI.chat(**chat_opts)
               else
                 raise "ERROR: Unsupported AI Engine: #{engine}"
               end

data/lib/pwn/version.rb

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

data/spec/integration/reinforced_feedback_loop_spec.rb

@@ -1468,13 +1468,13 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
   end
 
   describe 'P0 · Budget exhaust deepen (last-iter / no-CF-hot / exhaust Learning)' do
-    it 'tightens budget-hot max_iters: 24 ollama / 75 remote (long-goal runway)' do
+    it 'tightens budget-hot max_iters: 24 local (ollama/openwebui) / 75 remote (long-goal runway)' do
       src = File.read(loop_mod.method(:run).source_location.first)
       # max_iters is private_class_method — read surrounding source
       # P17 long-autonomy: local stays 24; remote keeps multi-step runway 75.
       # always-24-for-ALL starved long-lived goals after the hot text-only tail.
       expect(src).to match(/budget_exhaustion_hot\?/)
-      expect(src).to match(/hot_cap = active_engine == :ollama \? 24 : 75/)
+      expect(src).to match(/hot_cap = local_engine\? \? 24 : 75/)
       expect(src).to match(/n = \[n, hot_cap\]\.min/)
       expect(src).not_to match(/n = \[n, 24\]\.min/)
     end
@@ -1506,25 +1506,27 @@ RSpec.describe 'PWN::AI::Agent reinforced feedback loop', :aggregate_failures do
   end
 
   describe 'P28 · autonomy (remote overconf runway + incomplete-final)' do
-    it 'sets W3 overconf max_iters_cap to 120 on remote, 24 on ollama' do
+    it 'sets W3 overconf max_iters_cap to 120 on remote, 24 on local engines' do
       src = File.read(loop_mod.method(:run).source_location.first)
       expect(src).to match(/P28/)
       expect(src).to match(/remote_cap = 120/)
       expect(src).to match(/local_cap\s*=\s*24/)
-      expect(src).to match(/eng == :ollama \? local_cap : remote_cap/)
+      expect(src).to match(/local_engine\?\(engine: eng\) \? local_cap : remote_cap/)
       # P17 budget-hot: 24 ollama / 75 remote (not always-24)
-      expect(src).to match(/hot_cap = active_engine == :ollama \? 24 : 75/)
+      expect(src).to match(/hot_cap = local_engine\? \? 24 : 75/)
     end
 
     it 'defines incomplete_final? and continues on mid-goal handoff' do
       src = File.read(loop_mod.method(:run).source_location.first)
       expect(src).to match(/incomplete_final\?/)
       expect(src).to match(/INCOMPLETE_FINAL_RX/)
+      expect(src).to match(/MONOLOGUE_TOOL_INTENT_RX/)
       expect(src).to match(%r{\[pwn-ai/p28\]})
       expect(src).to match(/continuing autonomously/)
       # last-iter wording no longer coaches "next single step" handoffs
       expect(src).not_to match(/next single step/)
-      expect(src).to match(/do NOT ask the/)
+      expect(src).to match(/Do NOT monologue/)
+      expect(src).to match(/Emit NATIVE tool_calls NOW/)
     end
 
     it 'PromptBuilder injects AUTONOMY block' do

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'json'
 
 describe PWN::AI::Agent::Dispatch do
   it 'should display information for authors' do
@@ -12,4 +13,81 @@ describe PWN::AI::Agent::Dispatch do
     help_response = PWN::AI::Agent::Dispatch
     expect(help_response).to respond_to :help
   end
+
+  describe '.tool_calls_from_text' do
+    before { PWN::AI::Agent::Registry.discover }
+
+    def args_hash(call)
+      raw = call.dig(:function, :arguments)
+      raw.is_a?(String) ? JSON.parse(raw, symbolize_names: true) : raw
+    end
+
+    it 'parses shell(command="...") kwarg form' do
+      calls = described_class.tool_calls_from_text(
+        text: 'shell(command="ip addr | head -n 1")'
+      )
+      expect(calls.length).to eq(1)
+      expect(calls[0].dig(:function, :name)).to eq('shell')
+      expect(calls[0].dig(:function, :arguments)).to be_a(String)
+      expect(args_hash(calls[0])[:command]).to include('ip addr')
+    end
+
+    it 'parses shell({JSON}) and bare JSON name/arguments forms' do
+      a = described_class.tool_calls_from_text(text: 'shell({"command":"id"})')
+      b = described_class.tool_calls_from_text(
+        text: '{"name":"shell","arguments":{"command":"uname -a"}}'
+      )
+      expect(a[0].dig(:function, :arguments)).to be_a(String)
+      expect(args_hash(a[0])[:command]).to eq('id')
+      expect(args_hash(b[0])[:command]).to eq('uname -a')
+    end
+
+    it 'returns [] when no registered tool call is present' do
+      expect(
+        described_class.tool_calls_from_text(text: 'use hping3 like this: hping3 -1 host')
+      ).to eq([])
+    end
+
+    it 'parses call:name{...} and tool:name{...} colon-brace forms' do
+      a = described_class.tool_calls_from_text(text: 'call:shell{command: "uname -s"}')
+      b = described_class.tool_calls_from_text(text: 'tool:shell{"command":"id"}')
+      c = described_class.tool_calls_from_text(text: 'call:shell{command="whoami"}')
+      expect(a.length).to eq(1)
+      expect(a[0].dig(:function, :name)).to eq('shell')
+      expect(args_hash(a[0])[:command]).to eq('uname -s')
+      expect(args_hash(b[0])[:command]).to eq('id')
+      expect(args_hash(c[0])[:command]).to eq('whoami')
+    end
+
+    it 'parses JSON objects keyed by tool/call as well as name/function' do
+      tool_key = described_class.tool_calls_from_text(
+        text: '{"tool":"shell","arguments":{"command":"id"}}'
+      )
+      call_key = described_class.tool_calls_from_text(
+        text: '{"call":"shell","arguments":{"command":"uname -a"}}'
+      )
+      typed = described_class.tool_calls_from_text(
+        text: '{"type":"call","name":"shell","arguments":{"command":"pwd"}}'
+      )
+      expect(args_hash(tool_key[0])[:command]).to eq('id')
+      expect(args_hash(call_key[0])[:command]).to eq('uname -a')
+      expect(args_hash(typed[0])[:command]).to eq('pwd')
+    end
+
+    it 'ignores prose that only mentions call: without a registered tool body' do
+      expect(
+        described_class.tool_calls_from_text(text: 'please call:help later')
+      ).to eq([])
+    end
+
+    it 'parses multi-arg call:name{k=v,...} without swallowing trailing braces' do
+      calls = described_class.tool_calls_from_text(
+        text: 'call:shell{command=id, timeout=5}'
+      )
+      expect(calls.length).to eq(1)
+      h = args_hash(calls[0])
+      expect(h[:command]).to eq('id')
+      expect(h[:timeout].to_s).to eq('5')
+    end
+  end
 end