pwn 0.5.680 → 0.5.683

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

@@ -500,6 +500,7 @@ module PWN
           limit   = opts[:limit] || 6
           request = opts[:request].to_s
           open_rows = top(limit: limit * 3, unresolved_only: true)
+          open_rows = open_rows.reject { |m| budget_scar?(mistake: m) } unless request.match?(/budget|iterat|exhaust|\bagent.?loop\b/i)
           # 2.6 — request-conditioned rank (sim × recency × count), same idea
           # as exemplars_for. Stops injecting loudest scar (reward_signal ×13)
           # on every unrelated turn.
@@ -534,6 +535,21 @@ module PWN
           "#{out}\n"
         end
 
+        private_class_method def self.budget_scar?(opts = {})
+          m = opts[:mistake] || opts[:m] || opts
+          return false unless m.is_a?(Hash)
+
+          shape = m[:shape].to_s
+          err = m[:error].to_s.downcase
+          tool = m[:tool].to_s
+          return true if %w[budget_exhausted budget_thrash].include?(shape)
+          return true if err.include?('budget exhausted') || err.include?('iteration budget') || err.include?('budget thrash')
+
+          %w[agent_loop assistant_answer].include?(tool) && err.include?('budget')
+        rescue StandardError
+          false
+        end
+
         private_class_method def self.rank_for_request(opts = {})
           rows = Array(opts[:rows])
           limit = opts[:limit] || 6
@@ -553,6 +569,7 @@ module PWN
             # downrank reward_signal / parked unless the request is about rewards
             penalty = 1.0
             penalty *= 0.05 if m[:tool].to_s == 'reward_signal' && !req.match?(/reward|judge|sentinel|proxy/)
+            penalty *= 0.05 if budget_scar?(mistake: m) && !req.match?(/budget|iterat|exhaust|loop/)
             penalty *= 0.3 if m[:parked] || m[:needs_code_change]
             score = ((sim * 2.0) + (decay * 0.5) + (Math.log2(m[:count].to_i + 1) * 0.3)) * penalty
             # always allow some mass for top-count scars when sim=0 but keep penalty

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

@@ -36,6 +36,9 @@ module PWN
         EPSILON    = 0.08
         STEP_OK    = 0.05
         STEP_FAIL  = -0.20
+        STEP_TASK  = 0.12
+        STEP_CLOSED = 0.20
+        STEP_GRIND = -0.08
         MAX_TRAJ   = 2_000
         GOLD_MIN   = 0.6
         VISITS_MIN = 2
@@ -147,6 +150,8 @@ module PWN
             started_at: Time.now.utc.iso8601,
             state: s0,
             last_action: 'start',
+            plan_idx: ts_idx(ts_state: opts[:ts_state]),
+            plan_open: ts_open?(ts_state: opts[:ts_state]),
             fails: 0,
             steps: []
           }
@@ -197,6 +202,9 @@ module PWN
                    else
                      ok ? STEP_OK : STEP_FAIL
                    end
+          reward = (reward + english_step_bonus(ep: ep, ts_state: opts[:ts_state], ok: ok, action: action)).round(4)
+          ep[:plan_idx] = ts_idx(ts_state: opts[:ts_state])
+          ep[:plan_open] = ts_open?(ts_state: opts[:ts_state])
           s = ep[:state]
           task = active_task_text(ts_state: opts[:ts_state], request: ep[:request])
           s2 = state(
@@ -572,7 +580,7 @@ module PWN
           end
 
           ev = evaluate(limit: opts[:limit] || 40)
-          fallback = %w[memory_recall sessions_view pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember]
+          fallback = PWN::AI::Agent::Registry::DEFAULT_PREFERENCE
           pref = begin
             PWN::AI::Agent::Registry.preference_order
           rescue StandardError
@@ -724,6 +732,36 @@ module PWN
           opts[:request].to_s
         end
 
+        private_class_method def self.ts_idx(opts = {})
+          ts = opts[:ts_state]
+          ts.is_a?(Hash) ? ts[:plan_idx].to_i : 0
+        end
+
+        private_class_method def self.ts_open?(opts = {})
+          ts = opts[:ts_state]
+          return true unless ts.is_a?(Hash)
+          return true unless defined?(TaskSummarizer) && TaskSummarizer.respond_to?(:plan_open?)
+
+          TaskSummarizer.plan_open?(state: ts)
+        rescue StandardError
+          true
+        end
+
+        private_class_method def self.english_step_bonus(opts = {})
+          ep = opts[:ep]
+          return 0.0 unless ep.is_a?(Hash)
+
+          bonus = 0.0
+          new_idx = ts_idx(ts_state: opts[:ts_state])
+          new_open = ts_open?(ts_state: opts[:ts_state])
+          bonus += STEP_TASK if !ep[:plan_idx].nil? && new_idx > ep[:plan_idx].to_i
+          bonus += STEP_CLOSED if ep[:plan_open] && new_open == false
+          bonus += STEP_GRIND if new_open == false && opts[:ok] && opts[:action].to_s != 'final'
+          bonus
+        rescue StandardError
+          0.0
+        end
+
         private_class_method def self.terminal_reward(opts = {})
           return ((2.0 * opts[:score].to_f) - 1.0).clamp(-1.0, 1.0) unless opts[:score].nil?
 
@@ -800,9 +838,20 @@ module PWN
           plan = Array(ts[:plan]).map { |t| t.to_s.strip }.reject(&:empty?)
           return 'n' if plan.empty?
 
-          idx = ts[:plan_idx].to_i.clamp(0, plan.length)
-          frac = idx.to_f / plan.length
-          return 'h' if frac >= 0.75 || idx >= (plan.length - 1)
+          open = if defined?(TaskSummarizer) && TaskSummarizer.respond_to?(:plan_open?)
+                   TaskSummarizer.plan_open?(state: ts)
+                 else
+                   true
+                 end
+          return 'h' unless open
+
+          left = if defined?(TaskSummarizer) && TaskSummarizer.respond_to?(:unfinished_tasks)
+                   Array(TaskSummarizer.unfinished_tasks(state: ts)).length
+                 else
+                   plan.length
+                 end
+          done = plan.length - left
+          frac = done.to_f / plan.length
           return 'm' if frac >= 0.3
 
           'l'

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

@@ -36,14 +36,42 @@ module PWN
           session_id = opts[:session_id]
           request = opts[:request]
           engine = active_engine
+          # thin: greeting/statement/howto/recall — base + ENV + optional recent turns.
+          # Full MEMORY/METRICS/MISTAKES/EXTRO only for act/recon (default).
+          thin = opts[:thin] == true || opts[:mode].to_s == 'thin'
           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.'
 
+          if thin
+            recent = recent_turns_block(session_id: session_id, request: request, limit: [b[:recent_turns].to_i, 2].min)
+            return <<~PROMPT
+              #{base}
+
+              ENVIRONMENT
+                host       : #{host_line}
+                cwd        : #{Dir.pwd}
+                ruby       : #{RUBY_VERSION}
+                pwn        : #{pwn_version}
+                session_id : #{session_id || '(none)'}
+
+              #{recent}TOOL USE
+                No tools on this turn unless a single factual lookup is already in
+                context. Answer concisely in plain US English. Do not plan multi-step
+                work, invent task traces, or run live recon.
+            PROMPT
+          end
+
           # Heredoc (not a "..." literal): an unescaped "..." inside a
           # double-quoted string is parsed as Range (begin..."...end).
-          # Skills sit in the STATIC prefix (Hermes index) so prompt-cache
-          # breakpoints can pin the persona + SKILLS list; MEMORY/LEARNING
-          # remain in the dynamic tail.
+          # Mid-turn: current session + memory + skills + learning + known-fix,
+          # then tools (memory_recall / session_recall / skills_recall / pwn_eval / shell).
+          # Expand METRICS/POLICY/EXTRO when stuck or expand_harness.
+          expand = opts[:expand_harness] == true || opts[:stuck] == true
+          harness = if expand
+                      "#{skills_block}#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{memory_block(limit: b[:memory], request: request)}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes], request: request)}#{metrics_block(limit: b[:metrics], engine: engine)}#{policy_block if b[:policy].to_i.positive?}#{extrospection_block if b[:extro]}"
+                    else
+                      "#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{memory_block(limit: b[:memory], request: request)}#{skills_block}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes], request: request)}"
+                    end
           <<~PROMPT
             #{base}
 
@@ -54,7 +82,7 @@ module PWN
               pwn        : #{pwn_version}
               session_id : #{session_id || '(none)'}
 
-            #{skills_block}#{memory_block(limit: b[:memory], request: request)}#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{learning_block(limit: b[:learning])}#{mistakes_block(limit: b[:mistakes], request: request)}#{metrics_block(limit: b[:metrics], engine: engine)}#{policy_block if b[:policy].to_i.positive?}#{extrospection_block if b[:extro]}TOOL USE
+            #{harness}TOOL USE
               Use the provided function tools to act on the host via NATIVE
               tool_calls / function calling — never print tool invocations as
               plain text (e.g. do NOT write shell(command="...") as your answer).
@@ -62,12 +90,16 @@ module PWN
             "I will run…", "one more thing…") — that is treated as an incomplete
             reply. Emit a real tool_call instead, or a complete final answer
             with evidence. A reply with no tool_calls is your FINAL answer to the user.
-              Prefer `pwn_eval` for anything in the PWN:: namespace and `shell`
-              for OS commands. Save durable facts with `memory_remember`.
+              Prefer this order: use RECENT TURNS (current session already in
+              context), then `memory_recall`, then `session_recall`, then
+              `skills_recall`, then `pwn_eval` for PWN:: work, then `shell` for OS
+              commands. Save durable facts with `memory_remember`.
+              TransparentBrowser: open once, reuse browser_obj, close once.
 
             AUTONOMY
               Multi-step goals must be finished in one Loop.run. Keep calling
-              tools until the request is done or truly blocked. Do NOT stop to
+              CORE_TOOLS until the original request is done or truly blocked.
+              English tasks are an advisory compass, not a gate. Do NOT stop to
               ask the user to confirm the next step, approve a partial plan, or
               green-light the obvious continuation. Only ask when a credential,
               irreversible destructive action, or missing external decision is
@@ -75,15 +107,10 @@ module PWN
               goal are incorrect behavior.
 
             INTENT AND SCOPE
-              First classify every user request as one of:
-                - general statement — observation or FYI; no multi-step task plan
-                - question — answer concisely; no multi-step task breakdown
-                - autonomous goal — MUST decompose into ordered tangible work units
-                  (each unit may use one or more tools) and finish them in this run
-              Match effort to that kind. Pure how-to / syntax / usage questions
-              get a concise explanation with example commands only — no tool calls,
-              no multi-step recon plan, no live probes, no rubocop/rake/docs side
-              quests, and no invented planner or verification monologue.
+              Every user request is an autonomous goal. Finish it in this run
+              with CORE_TOOLS. English tasks are an advisory compass only.
+              Pure how-to / syntax / usage questions get a concise explanation
+              with example commands only — no invented planner monologue.
               Pure prior-turn recall ("what did I just say?") is answered from the
               RECENT TURNS block or one memory_recall — never a multi-tool plan.
               Pure greetings / light smalltalk short-circuit to a fixed ack — never
@@ -114,13 +141,13 @@ module PWN
             metrics: (b[:metrics] || (local ? 3 : 8)).to_i,
             mistakes: (b[:mistakes] || (local ?  3 :  6)).to_i,
             learning: (b[:learning] || (local ?  2 :  5)).to_i,
-            # Always inject last user/assistant pair(s); local keeps it tiny.
-            recent_turns: (b[:recent_turns] || (local ? 1 : 2)).to_i,
+            # Always inject prior user/assistant pairs from this session.
+            recent_turns: (b[:recent_turns] || (local ? 3 : 6)).to_i,
             policy: (b[:policy] || 1).to_i,
             extro: b[:extro].nil? ? !local : b[:extro]
           }
         rescue StandardError
-          { memory: 25, metrics: 8, mistakes: 6, learning: 5, recent_turns: 2, policy: 1, extro: true }
+          { memory: 25, metrics: 8, mistakes: 6, learning: 5, recent_turns: 6, policy: 1, extro: true }
         end
 
         private_class_method def self.active_engine

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

@@ -40,14 +40,14 @@ module PWN
           keyword_init: true
         )
 
-        CORE_TOOLS = %w[shell pwn_eval memory_remember memory_recall
-                        mistakes_record mistakes_resolve learning_note_outcome].freeze
+        CORE_TOOLS = %w[memory_recall session_recall skills_recall pwn_eval shell
+                        mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
 
-        # Operator-tunable tool order. Prefer these names when keyword-fit
-        # (or other rank features) tie. Overridable via opts[:order],
+        # Schema order = CORE_TOOLS. Current session is injected (RECENT TURNS).
+        # Then memory / prior sessions / skills, then pwn_eval before shell.
         # opts[:preference], or PWN::Env[:ai][:agent][:tool_preference].
         # Explicit nil/empty order disables preference (no Env/DEFAULT fallback).
-        DEFAULT_PREFERENCE = %w[memory_recall sessions_view pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
+        DEFAULT_PREFERENCE = CORE_TOOLS
 
         @entries = {}
         @discovered = false
@@ -119,8 +119,12 @@ module PWN
           pref_fwd = {}
           pref_fwd[:order] = opts[:order] if opts.key?(:order)
           pref_fwd[:preference] = opts[:preference] if opts.key?(:preference)
+          pref_fwd[:kind] = opts[:kind] if opts.key?(:kind)
+          pref_fwd[:intent] = opts[:intent] if opts.key?(:intent)
 
-          if opts[:relevance] && router_enabled?
+          if opts[:core_only]
+            pool = pool.select { |e| CORE_TOOLS.include?(e.name) }
+          elsif opts[:relevance] && router_enabled?
             keep = rank({ query: opts[:relevance], entries: pool }.merge(pref_fwd)).first(opts[:top_k] || 10).map(&:name)
             names = (CORE_TOOLS + keep).uniq
             pool  = pool.select { |e| names.include?(e.name) }
@@ -147,8 +151,9 @@ module PWN
 
           raw = nil
           raw = PWN::Env.dig(:ai, :agent, :tool_preference) if defined?(PWN::Env) && PWN::Env.is_a?(Hash)
-          raw = DEFAULT_PREFERENCE if raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
-          Array(raw).map(&:to_s).reject(&:empty?)
+          return Array(raw).map(&:to_s).reject(&:empty?) unless raw.nil? || (raw.respond_to?(:empty?) && raw.empty?)
+
+          DEFAULT_PREFERENCE.dup
         rescue StandardError
           DEFAULT_PREFERENCE.dup
         end
@@ -315,13 +320,13 @@ module PWN
           return false unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
 
           v = PWN::Env.dig(:ai, :agent, :tool_router)
-          # nil = auto: on for ollama (largest single local-model win — ~11k→~3k
-          # schema tokens/turn); off for frontier unless explicitly enabled.
-          return v ? true : false unless v.nil?
+          # nil = auto ON for every engine: ~85 tools / ~50KB schemas bloat every
+          # turn (esp. Grok). Opt out with tool_router: false.
+          return !!v unless v.nil?
 
-          %i[ollama openwebui].include?(PWN::Env.dig(:ai, :active).to_s.downcase.to_sym)
+          true
         rescue StandardError
-          false
+          true
         end
 
         private_class_method def self.metrics_rates