pwn 0.5.680 → 0.5.682

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,9 +580,10 @@ 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 = %w[shell pwn_eval memory_recall mistakes_record mistakes_resolve learning_note_outcome memory_remember]
           pref = begin
-            PWN::AI::Agent::Registry.preference_order
+            intent = Thread.current[:pwn_request_intent]
+            PWN::AI::Agent::Registry.preference_order(intent: intent)
           rescue StandardError
             []
           end
@@ -724,6 +733,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 +839,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,44 @@ 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.
+          # remain in the dynamic tail. Mid-turn lean: request + CORE_TOOLS +
+          # known-fix. Expand MEMORY/SKILLS/LEARNING/METRICS/POLICY/EXTRO
+          # only when the turn is stuck or the operator asked for the full harness.
+          expand = opts[:expand_harness] == true || opts[:stuck] == true
+          harness = if expand
+                      "#{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]}"
+                    else
+                      "#{recent_turns_block(session_id: session_id, request: request, limit: [b[:recent_turns].to_i, 1].max)}#{mistakes_block(limit: b[:mistakes], request: request)}"
+                    end
           <<~PROMPT
             #{base}
 
@@ -54,7 +84,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).
@@ -67,7 +97,8 @@ module PWN
 
             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 +106,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

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

@@ -47,7 +47,10 @@ module PWN
         # (or other rank features) tie. Overridable via opts[:order],
         # 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
+        # Recall-first fallback; kind-aware preference_order leads act/recon
+        # with shell / pwn_eval. Names stay inside CORE_TOOLS.
+        DEFAULT_PREFERENCE = %w[memory_recall pwn_eval shell mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
+        ACT_PREFERENCE = %w[shell pwn_eval memory_recall mistakes_record mistakes_resolve learning_note_outcome memory_remember].freeze
 
         @entries = {}
         @discovered = false
@@ -119,8 +122,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 +154,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?)
+
+          ACT_PREFERENCE.dup
         rescue StandardError
           DEFAULT_PREFERENCE.dup
         end
@@ -315,13 +323,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