pwn 0.5.627 → 0.5.628

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

@@ -18,6 +18,15 @@ module PWN
       # tool selection accordingly. This is one half of the closed
       # feedback loop that lets pwn-ai continuously make itself smarter
       # (the other half is PWN::AI::Agent::Learning).
+      #
+      # PER-ENGINE SEGMENTATION
+      # -----------------------
+      # A local qwen3.6:35b and a frontier model do NOT have the same
+      # per-tool success rate — blending them mis-advises the local model
+      # about itself. Every record now also increments an :engines[<engine>]
+      # sub-bucket; summary/to_context accept engine: to surface only that
+      # engine's telemetry so the TOOL EFFECTIVENESS block becomes a
+      # genuine per-engine learned policy.
       module Metrics
         METRICS_FILE = File.join(Dir.home, '.pwn', 'metrics.json')
 
@@ -51,7 +60,8 @@ module PWN
         #   name: 'required - tool name that was dispatched',
         #   success: 'required - Boolean, did the handler complete without error',
         #   duration: 'optional - Float seconds the dispatch took',
-        #   error: 'optional - String error message when success is false'
+        #   error: 'optional - String error message when success is false',
+        #   engine: 'optional - Symbol/String AI engine that chose this tool (segments telemetry)'
         # )
 
         public_class_method def self.record(opts = {})
@@ -59,65 +69,70 @@ module PWN
           success  = opts[:success] ? true : false
           duration = opts[:duration].to_f
           error    = opts[:error]
+          engine   = opts[:engine].to_s
           return if name.empty?
 
           metrics = load
           metrics[:tools] ||= {}
           key = name.to_sym
-          t = metrics[:tools][key] ||= {
-            calls: 0, ok: 0, fail: 0, total_duration: 0.0,
-            last_error: nil, last_at: nil
-          }
-          t[:calls]          += 1
-          t[:ok]             += 1 if success
-          t[:fail]           += 1 unless success
-          t[:total_duration] += duration
-          t[:last_error]      = error.to_s[0, 300] if error && !success
-          t[:last_at]         = Time.now.utc.iso8601
+          t = metrics[:tools][key] ||= blank_bucket
+          bump(bucket: t, success: success, duration: duration, error: error)
+          unless engine.empty?
+            t[:engines] ||= {}
+            e = t[:engines][engine.to_sym] ||= blank_bucket
+            bump(bucket: e, success: success, duration: duration, error: error)
+          end
           save(metrics: metrics)
           t
         end
 
         # Supported Method Parameters::
         # rows = PWN::AI::Agent::Metrics.summary(
-        #   limit: 'optional - cap number of tools returned (default 25)'
+        #   limit: 'optional - cap number of tools returned (default 25)',
+        #   engine: 'optional - only that engine\'s sub-bucket (falls back to global when absent)'
         # )
 
         public_class_method def self.summary(opts = {})
-          limit = opts[:limit] || 25
-          tools = load[:tools] || {}
+          limit  = opts[:limit] || 25
+          engine = opts[:engine].to_s
+          tools  = load[:tools] || {}
           rows = tools.map do |name, t|
-            calls = t[:calls].to_i
-            ok    = t[:ok].to_i
+            b = engine.empty? ? t : (t.dig(:engines, engine.to_sym) || t)
+            calls = b[:calls].to_i
+            ok    = b[:ok].to_i
             rate  = calls.positive? ? (ok.to_f / calls).round(3) : 0.0
-            avg   = calls.positive? ? (t[:total_duration].to_f / calls).round(3) : 0.0
+            avg   = calls.positive? ? (b[:total_duration].to_f / calls).round(3) : 0.0
             {
               name: name.to_s,
               calls: calls,
               success_rate: rate,
               avg_duration: avg,
-              last_error: t[:last_error],
-              last_at: t[:last_at]
+              last_error: b[:last_error],
+              last_at: b[:last_at]
             }
           end
-          rows.sort_by { |r| [-r[:calls], -r[:success_rate]] }.first(limit)
+          rows.reject { |r| r[:calls].zero? }
+              .sort_by { |r| [-r[:calls], -r[:success_rate]] }.first(limit)
         end
 
         # Supported Method Parameters::
         # ctx = PWN::AI::Agent::Metrics.to_context(
-        #   limit: 'optional - cap number of tools included (default 8)'
+        #   limit: 'optional - cap number of tools included (default 8)',
+        #   engine: 'optional - restrict to one engine\'s telemetry'
         # )
 
         public_class_method def self.to_context(opts = {})
-          limit = opts[:limit] || 8
-          rows = summary(limit: limit)
+          limit  = opts[:limit] || 8
+          engine = opts[:engine]
+          rows   = summary(limit: limit, engine: engine)
           return '' if rows.empty?
 
+          scope = engine.to_s.empty? ? 'historical' : "engine=#{engine}"
           lines = rows.map do |r|
             err = r[:last_error] ? " last_err=#{r[:last_error][0, 60]}" : ''
             "  - #{r[:name]}: calls=#{r[:calls]} success=#{(r[:success_rate] * 100).round(1)}% avg=#{r[:avg_duration]}s#{err}"
           end
-          "TOOL EFFECTIVENESS (historical, adapt tool choice accordingly)\n#{lines.join("\n")}\n\n"
+          "TOOL EFFECTIVENESS (#{scope}, adapt tool choice accordingly)\n#{lines.join("\n")}\n\n"
         end
 
         # Supported Method Parameters::
@@ -128,6 +143,24 @@ module PWN
           { tools: {}, updated_at: nil }
         end
 
+        private_class_method def self.blank_bucket
+          { calls: 0, ok: 0, fail: 0, total_duration: 0.0, last_error: nil, last_at: nil }
+        end
+
+        private_class_method def self.bump(opts = {})
+          b        = opts[:bucket]
+          success  = opts[:success]
+          duration = opts[:duration].to_f
+          error    = opts[:error]
+          b[:calls]          += 1
+          b[:ok]             += 1 if success
+          b[:fail]           += 1 unless success
+          b[:total_duration]  = b[:total_duration].to_f + duration
+          b[:last_error]      = error.to_s[0, 300] if error && !success
+          b[:last_at]         = Time.now.utc.iso8601
+          b
+        end
+
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
@@ -139,9 +172,9 @@ module PWN
         public_class_method def self.help
           puts <<~USAGE
             USAGE:
-              PWN::AI::Agent::Metrics.record(name: 'shell', success: true, duration: 0.42)
-              PWN::AI::Agent::Metrics.summary(limit: 10)
-              PWN::AI::Agent::Metrics.to_context(limit: 8)   # injected by PromptBuilder
+              PWN::AI::Agent::Metrics.record(name: 'shell', success: true, duration: 0.42, engine: :ollama)
+              PWN::AI::Agent::Metrics.summary(limit: 10, engine: :ollama)
+              PWN::AI::Agent::Metrics.to_context(limit: 8, engine: :ollama)   # injected by PromptBuilder
               PWN::AI::Agent::Metrics.reset
               PWN::AI::Agent::Metrics.load
               PWN::AI::Agent::Metrics.save(metrics: hash)

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

@@ -10,15 +10,33 @@ module PWN
       # Re-injection IS the persistence mechanism: this is rebuilt fresh on
       # every user turn, so a memory_remember / skill_create from the prior
       # turn shows up here with no extra wiring.
+      #
+      # ENGINE-AWARE BUDGETING
+      # ----------------------
+      # Local models (Ollama) drown when handed the same 6-8 KB of MEMORY /
+      # METRICS / MISTAKES / EXTROSPECTION context that a frontier model
+      # shrugs off. .budget shrinks each block for :ollama (or whatever
+      # PWN::Env[:ai][<engine>][:prompt_budget] says) so the small model
+      # spends its attention on the request, not the harness.
+      #
+      # RELEVANCE-RANKED MEMORY
+      # -----------------------
+      # When Loop.run passes request: through, the MEMORY block is populated
+      # by PWN::MemoryIndex.recall_semantic (embedding cosine over
+      # ~/.pwn/memory.idx) instead of a recency dump — the 6 memories a
+      # small model can afford are the 6 that actually matter for THIS turn.
       module PromptBuilder
         # Supported Method Parameters::
         # system_prompt = PWN::AI::Agent::PromptBuilder.build(
-        #   session_id: 'optional - PWN::Sessions id to embed in the ENV block'
+        #   session_id: 'optional - PWN::Sessions id to embed in the ENV block',
+        #   request: 'optional - user request; enables relevance-ranked MEMORY when provided'
         # )
 
         public_class_method def self.build(opts = {})
           session_id = opts[:session_id]
+          request = opts[:request]
           engine = active_engine
+          b = budget
           base = (PWN::Env.dig(:ai, engine, :system_role_content) if defined?(PWN::Env)) || 'You are a world-class introspective offensive cyber security and research engineer.  You specialize in discovering zero day vulnerabilities focused on responsible disclosure prior to threat actors discovering and exploiting.  You are self-aware of your harness, pwn which begins with the ruby namespace `PWN` operating inside the pwn REPL.  For every request you first begin by determining if PWN has a module capable of satisfying the request.'
 
           "
@@ -31,7 +49,7 @@ module PWN
               pwn        : #{pwn_version}
               session_id : #{session_id || '(none)'}
 
-            #{memory_block}#{skills_block}#{learning_block}#{mistakes_block}#{metrics_block}#{extrospection_block}TOOL USE
+            #{memory_block(limit: b[:memory], request: request)}#{skills_block}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes])}#{metrics_block(limit: b[:metrics], engine: engine)}#{extrospection_block if b[:extro]}TOOL USE
               Use the provided function tools to act on the host. A reply with
               no tool_calls is treated as your FINAL answer to the user.
               Prefer `pwn_eval` for anything in the PWN:: namespace and `shell`
@@ -39,6 +57,29 @@ module PWN
           "
         end
 
+        # Supported Method Parameters::
+        # b = PWN::AI::Agent::PromptBuilder.budget
+        #
+        # Per-engine caps for each injected block. Override any key via
+        # PWN::Env[:ai][<engine>][:prompt_budget][:memory|:metrics|:mistakes|
+        # :learning|:extro]. :extro is a Boolean gate — Extrospection is the
+        # heaviest block and rarely useful to a local model.
+
+        public_class_method def self.budget
+          eng = active_engine
+          b   = (PWN::Env.dig(:ai, eng, :prompt_budget) if defined?(PWN::Env)) || {}
+          local = eng == :ollama
+          {
+            memory: (b[:memory] || (local ? 6 : 25)).to_i,
+            metrics: (b[:metrics] || (local ? 3 : 8)).to_i,
+            mistakes: (b[:mistakes] || (local ?  3 :  6)).to_i,
+            learning: (b[:learning] || (local ?  2 :  5)).to_i,
+            extro: b[:extro].nil? ? !local : b[:extro]
+          }
+        rescue StandardError
+          { memory: 25, metrics: 8, mistakes: 6, learning: 5, extro: true }
+        end
+
         private_class_method def self.active_engine
           return :openai unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
 
@@ -57,11 +98,17 @@ module PWN
           defined?(PWN::VERSION) ? PWN::VERSION : '?'
         end
 
-        private_class_method def self.memory_block
+        private_class_method def self.memory_block(opts = {})
           return '' unless defined?(PWN::Memory) && PWN::Memory.respond_to?(:to_context)
 
-          ctx = PWN::Memory.to_context(limit: 25).to_s
-          ctx.strip.empty? ? '' : "MEMORY#{ctx}\n\n"
+          limit = opts[:limit] || 25
+          req   = opts[:request]
+          ctx   = if req && defined?(PWN::MemoryIndex) && PWN::MemoryIndex.available?
+                    PWN::MemoryIndex.to_context(query: req, limit: limit)
+                  else
+                    PWN::Memory.to_context(limit: limit)
+                  end
+          ctx.to_s.strip.empty? ? '' : "MEMORY#{ctx}\n\n"
         rescue StandardError
           ''
         end
@@ -81,28 +128,28 @@ module PWN
           ''
         end
 
-        private_class_method def self.learning_block
+        private_class_method def self.learning_block(opts = {})
           return '' unless defined?(PWN::AI::Agent::Learning)
 
-          ctx = PWN::AI::Agent::Learning.to_context(limit: 5).to_s
+          ctx = PWN::AI::Agent::Learning.to_context(limit: opts[:limit] || 5).to_s
           ctx.strip.empty? ? '' : "LEARNING\n#{ctx}"
         rescue StandardError
           ''
         end
 
-        private_class_method def self.mistakes_block
+        private_class_method def self.mistakes_block(opts = {})
           return '' unless defined?(PWN::AI::Agent::Mistakes)
 
-          ctx = PWN::AI::Agent::Mistakes.to_context(limit: 6).to_s
+          ctx = PWN::AI::Agent::Mistakes.to_context(limit: opts[:limit] || 6).to_s
           ctx.strip.empty? ? '' : ctx
         rescue StandardError
           ''
         end
 
-        private_class_method def self.metrics_block
+        private_class_method def self.metrics_block(opts = {})
           return '' unless defined?(PWN::AI::Agent::Metrics)
 
-          ctx = PWN::AI::Agent::Metrics.to_context(limit: 8).to_s
+          ctx = PWN::AI::Agent::Metrics.to_context(limit: opts[:limit] || 8, engine: opts[:engine]).to_s
           ctx.strip.empty? ? '' : ctx
         rescue StandardError
           ''
@@ -128,7 +175,11 @@ module PWN
         public_class_method def self.help
           puts <<~USAGE
             USAGE:
-              system_prompt = PWN::AI::Agent::PromptBuilder.build(session_id: 'abc')
+              system_prompt = PWN::AI::Agent::PromptBuilder.build(session_id: 'abc', request: 'nmap sweep 10/8')
+              PWN::AI::Agent::PromptBuilder.budget   # => {memory:, metrics:, mistakes:, learning:, extro:}
+
+              Override per-engine via:
+                PWN::Env[:ai][:ollama][:prompt_budget] = { memory: 4, extro: false }
 
               #{self}.authors
           USAGE

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

@@ -21,11 +21,21 @@ 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.
+      #
+      # TEACHER-STUDENT REFLECTION
+      # --------------------------
+      # When PWN::Env[:ai][:reflect_engine] (or opts[:engine]) names a
+      # different provider than :active, Reflect.on temporarily flips
+      # :active for the duration of the introspection call. This lets a
+      # local Ollama model EXECUTE the task while a frontier model WRITES
+      # the durable lessons about it — the local model then reads back
+      # distilled reasoning it could never have produced itself.
       module Reflect
         # Supported Method Parameters::
         # 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',
+        #   engine: 'optional - override engine for THIS reflection only (Symbol/String); defaults to PWN::Env[:ai][:reflect_engine] || :active',
         #   spinner: 'optional - Boolean - Display spinner during operation (default: false)',
         #   suppress_pii_warning: 'optional - Boolean - Suppress PII Warnings (default: false)'
         # )
@@ -45,17 +55,20 @@ module PWN
           ai_module_reflection = PWN::Env[:ai][:module_reflection]
 
           if ai_module_reflection && request.length.positive?
-            engine = PWN::Env[:ai][:active].to_s.downcase.to_sym
+            override = opts[:engine] || PWN::Env.dig(:ai, :reflect_engine)
+            engine   = (override || 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 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,
-              enabled_toolsets: [],
-              spinner: spinner
-            )
+            response = with_engine(engine: override) do
+              PWN::AI::Agent::Loop.run(
+                request: request.chomp,
+                system_role_content: system_role_content,
+                enabled_toolsets: [],
+                spinner: spinner
+              )
+            end
           end
 
           response
@@ -63,6 +76,23 @@ module PWN
           raise e
         end
 
+        # Temporarily override PWN::Env[:ai][:active] so Loop.run routes to
+        # the teacher engine, restoring afterwards even on raise. No-op when
+        # engine is nil/blank or PWN::Env[:ai] is frozen.
+        private_class_method def self.with_engine(opts = {})
+          engine = opts[:engine].to_s
+          ai = defined?(PWN::Env) && PWN::Env.is_a?(Hash) ? PWN::Env[:ai] : nil
+          return yield if engine.empty? || !ai.is_a?(Hash) || ai.frozen?
+
+          prev = ai[:active]
+          ai[:active] = engine
+          begin
+            yield
+          ensure
+            ai[:active] = prev
+          end
+        end
+
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
@@ -78,10 +108,14 @@ module PWN
             #{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',
+              engine: 'optional - override engine (Symbol) for teacher-student reflection; defaults to PWN::Env[:ai][:reflect_engine]',
               spinner: 'optional - Boolean - Display spinner during operation (default: false)',
               suppress_pii_warning: 'optional - Boolean - Suppress PII Warnings (default: false)'
             )
 
+            Teacher-student config:
+              PWN::Env[:ai][:reflect_engine] = :anthropic   # execute on :active, critique on :anthropic
+
             #{self}.authors
           "
         end

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

@@ -18,6 +18,16 @@ module PWN
       #   agent/tools/*.rb         (require registry, call .register at top level)
       #          ^
       #   agent/loop.rb            (calls Registry.discover then .definitions)
+      #
+      # DYNAMIC TOOL-SET SLIMMING (local-model scaffolding)
+      # ---------------------------------------------------
+      # Shipping all ~47 tool schemas on every call overwhelms a 35B local
+      # model — it mis-routes (extro_rf_tune for a git question) because the
+      # choice space is huge. When PWN::Env[:ai][:agent][:tool_router] is
+      # truthy AND definitions(relevance: request) is passed, the pool is
+      # reduced to CORE_TOOLS + the top-K keyword-ranked matches. Routing
+      # accuracy is fed back into Metrics under name:'tool_router' so the
+      # router itself becomes a learned component.
       module Registry
         Entry = Struct.new(
           :name,        # String  - tool name exposed to the model
@@ -29,6 +39,9 @@ module PWN
           keyword_init: true
         )
 
+        CORE_TOOLS = %w[shell pwn_eval memory_remember memory_recall
+                        mistakes_record mistakes_resolve learning_note_outcome].freeze
+
         @entries = {}
         @discovered = false
 
@@ -84,15 +97,51 @@ module PWN
 
         # Supported Method Parameters::
         # tools = PWN::AI::Agent::Registry.definitions(
-        #   enabled: 'optional - Array of toolset names to include; nil = all whose check passes'
+        #   enabled: 'optional - Array of toolset names to include; nil = all whose check passes',
+        #   relevance: 'optional - user request; when set AND :tool_router is enabled, slim to CORE + top-K keyword matches',
+        #   top_k: 'optional - keyword-ranked tools to keep beyond CORE (default 10)'
         # )
 
         public_class_method def self.definitions(opts = {})
           enabled = opts[:enabled]
           enabled = enabled.map(&:to_s) if enabled
-          @entries.values
-                  .select { |e| (enabled.nil? || enabled.include?(e.toolset)) && safe_check(entry: e) }
-                  .map    { |e| { type: 'function', function: e.schema } }
+          pool = @entries.values.select { |e| (enabled.nil? || enabled.include?(e.toolset)) && safe_check(entry: e) }
+
+          if opts[:relevance] && router_enabled?
+            keep  = rank(query: opts[:relevance], entries: pool).first(opts[:top_k] || 10).map(&:name)
+            names = (CORE_TOOLS + keep).uniq
+            pool  = pool.select { |e| names.include?(e.name) }
+          end
+
+          pool.map { |e| { type: 'function', function: e.schema } }
+        end
+
+        # Supported Method Parameters::
+        # ranked = PWN::AI::Agent::Registry.rank(
+        #   query: 'required - user request text',
+        #   entries: 'optional - Entry pool to rank (default .all)'
+        # )
+        #
+        # Lightweight keyword TF router: scores each tool by the number of
+        # query tokens (≥ 3 chars, downcased) appearing in its name /
+        # description / property names. Zero-score entries drop off; ties
+        # break on historical Metrics success_rate so the router learns.
+
+        public_class_method def self.rank(opts = {})
+          query   = opts[:query].to_s.downcase
+          entries = opts[:entries] || all
+          return entries if query.strip.empty?
+
+          tokens = query.scan(/[a-z0-9_]{3,}/).uniq
+          rates  = metrics_rates
+          scored = entries.map do |e|
+            hay   = "#{e.name} #{e.toolset} #{e.schema[:description]} #{Array(e.schema.dig(:parameters, :properties)&.keys).join(' ')}".downcase
+            score = tokens.count { |t| hay.include?(t) }
+            [e, score, rates[e.name] || 0.0]
+          end
+          scored.reject { |_, s, _| s.zero? }
+                .sort_by { |_, s, r| [-s, -r] }
+                .map(&:first)
         end
 
         # Supported Method Parameters::
@@ -123,6 +172,20 @@ module PWN
           false
         end
 
+        private_class_method def self.router_enabled?
+          defined?(PWN::Env) && PWN::Env.is_a?(Hash) && PWN::Env.dig(:ai, :agent, :tool_router)
+        rescue StandardError
+          false
+        end
+
+        private_class_method def self.metrics_rates
+          return {} unless defined?(Metrics)
+
+          Metrics.summary(limit: 200).to_h { |r| [r[:name], r[:success_rate]] }
+        rescue StandardError
+          {}
+        end
+
         # Author(s):: 0day Inc. <support@0dayinc.com>
 
         public_class_method def self.authors
@@ -136,6 +199,8 @@ module PWN
             USAGE:
               PWN::AI::Agent::Registry.discover
               PWN::AI::Agent::Registry.definitions(enabled: %w[terminal pwn])
+              PWN::AI::Agent::Registry.definitions(relevance: 'nmap sweep 10/8')  # slim (needs :tool_router)
+              PWN::AI::Agent::Registry.rank(query: 'run a shell command')
               PWN::AI::Agent::Registry.lookup(name: 'shell')   # => Entry
               PWN::AI::Agent::Registry.toolsets                # => ["memory","pwn","skills","terminal"]
               PWN::AI::Agent::Registry.register(name:, toolset:, schema:, handler:)

data/lib/pwn/ai/ollama.rb

@@ -143,11 +143,25 @@ module PWN
       #   spinner: 'optional - display spinner (default false)'
       # )
       #
-      # Returns the raw /v1/chat/completions response Hash with :choices intact
-      # (including :message[:tool_calls]) — used by PWN::AI::Agent::Loop.
-      # Ollama's OpenAI-compat endpoint supports tools since 0.3.x; tool_calls
-      # come back with function.arguments as a JSON object (not string), which
-      # PWN::AI::Agent::Dispatch.parse_args handles transparently.
+      # Returns a Hash with :choices / :assistant_message intact (including
+      # :message[:tool_calls]) — used by PWN::AI::Agent::Loop.
+      #
+      # LOCAL-MODEL SCAFFOLDING
+      # -----------------------
+      # This hits Ollama's NATIVE /api/chat (not the OpenAI-compat shim) so
+      # the following actually take effect:
+      #   options.num_ctx     - Ollama defaults to 2048; the pwn-ai system
+      #                         prompt alone blows that. Defaults here to
+      #                         PWN::Env[:ai][:ollama][:num_ctx] || 32768.
+      #   options.temperature - forced to 0.1 on tool-bearing turns for
+      #                         deterministic tool selection; engine[:temp]
+      #                         (creative) on the final text-only turn.
+      #   format: 'json'      - constrains the sampler to valid JSON when
+      #                         tools are present so Dispatch never sees
+      #                         malformed function.arguments.
+      #   keep_alive: '30m'   - avoids reload latency between iterations.
+      # tool_calls come back with function.arguments as a Hash (not a JSON
+      # string), which PWN::AI::Agent::Dispatch.parse_args handles.
 
       public_class_method def self.chat_with_tools(opts = {})
         engine   = PWN::Env[:ai][:ollama]
@@ -160,18 +174,30 @@ module PWN
         temp = opts[:temp].to_f
         temp = engine[:temp].to_f.nonzero? || 1 if temp.zero?
 
+        tools_present = opts[:tools] && !opts[:tools].empty?
+        tool_temp     = (engine[:tool_temp] || 0.1).to_f
+        num_ctx       = (engine[:num_ctx]   || 32_768).to_i
+        keep_alive    = engine[:keep_alive] || '30m'
+
         http_body = {
           model: model,
           messages: messages,
-          temperature: temp,
-          stream: false
+          stream: false,
+          keep_alive: keep_alive,
+          options: {
+            num_ctx: num_ctx,
+            temperature: tools_present ? tool_temp : temp
+          }
         }
-        http_body[:tools]       = opts[:tools]       if opts[:tools] && !opts[:tools].empty?
+        if tools_present
+          http_body[:tools]  = opts[:tools]
+          http_body[:format] = engine[:format] || 'json'
+        end
         http_body[:tool_choice] = opts[:tool_choice] if opts[:tool_choice]
 
         response = ollama_rest_call(
           http_method: :post,
-          rest_call: 'ollama/v1/chat/completions',
+          rest_call: 'ollama/api/chat',
           http_body: http_body,
           timeout: opts[:timeout],
           spinner: opts[:spinner]
@@ -179,7 +205,10 @@ module PWN
         return nil if response.nil?
 
         json_resp = JSON.parse(response, symbolize_names: true)
-        json_resp[:assistant_message] = json_resp.dig(:choices, 0, :message)
+        # Normalise native /api/chat shape to what Loop.normalize_llm expects.
+        msg = json_resp[:message] || json_resp.dig(:choices, 0, :message)
+        json_resp[:choices] = [{ message: msg }] if msg && !json_resp.key?(:choices)
+        json_resp[:assistant_message] = msg
         json_resp
       rescue StandardError => e
         raise e

data/lib/pwn/config.rb

@@ -65,8 +65,13 @@ module PWN
             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',
+            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',
+            num_ctx: 32_768,
+            keep_alive: '30m',
+            # tighten each PromptBuilder block for the local model (nil = engine defaults)
+            prompt_budget: { memory: 6, metrics: 3, mistakes: 3, learning: 2, extro: false },
             max_prompt_length: 32_000
           },
           anthropic: {
@@ -86,6 +91,8 @@ module PWN
             temp: 'optional - Gemini temperature',
             max_prompt_length: 1_000_000
           },
+          # teacher-student reflection: execute on :active, write durable lessons via this engine (nil = same as :active)
+          reflect_engine: nil,
           agent: {
             native_tools: true,
             max_iters: 25,
@@ -95,6 +102,10 @@ module PWN
             auto_introspect: true,
             # also run PWN::AI::Agent::Extrospection.auto_extrospect from auto_introspect
             auto_extrospect: false,
+            # engine-agnostic scaffolding (defaults tuned for local models)
+            plan_first: nil,               # nil = auto (true when :active == :ollama)
+            tool_router: false,            # slim Registry.definitions to CORE + top-K relevant tools
+            escalation_persona: nil,       # Swarm persona name for frontier corrective hints when a local model is stuck
             toolsets: nil
             # multi-agent personas : ~/.pwn/agents.yml  (see PWN::AI::Agent::Swarm.help)
             # swarm bus            : ~/.pwn/swarm/<swarm_id>/bus.jsonl