pwn 0.5.701 → 0.5.702

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e51829d4db1ea2aaea43c6c7707f64e6b071fd0535b72e9ac330eaf08798c6e4
-  data.tar.gz: 5f3f54e56dc52ba72f95edcb33a342a9e865569d21a1b09b2d9e9810b2058c33
+  metadata.gz: 5e0f1934072cdfc2dd334d22bcd15774e5756a0bd02bb68962759ceb2e436b98
+  data.tar.gz: b092c265b35a9000293ce787252452c8045c4604677a3bd5416a2e4e732c2cce
 SHA512:
-  metadata.gz: 650f0bd9930cde7a95973ef32313bdaedb6420b1c0d9ac87e67554e95b419969b1836dc635362d105c7a7b5e8116c2fda191aa902c4716c7451a458a43135469
-  data.tar.gz: f3ac960a2f8e780d3f9ca316d72ff69ada1353c17cde9c1d51a6d0d12d2bf8fd21af20ac8de8e4d41fa60b9274f136e08426a6c5e9f00cf40064443bb91a55e2
+  metadata.gz: 61bdd9c6f370aa44f1cb3e5b00a928cd57acb5f1a40154769079ecec39ac4f0d8ce81c8daac5c5a1f5040b96cff7b7503de230645920531a854f10762bf75058
+  data.tar.gz: bc978a06cf9dd7e109696b6e95bfba64dcbc73d3092a9fbdcfe19cdf488dcec0b3c463866a90703050705fdf01bdd0f6a34e93c5f02812631682669499632461

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

@@ -172,6 +172,7 @@ module PWN
         private_class_method def self.finish_debug_request!(opts = {})
           return unless debug_on?(opts)
           return unless defined?(PWN::Plugins::Log)
+          return if opts[:nested]
 
           PWN::Plugins::Log.finish_request_log!(
             iter: opts[:iter],
@@ -572,6 +573,7 @@ module PWN
 
           live = effects.reject { |fx| %i[recall store].include?(fx) }
           return true if live.empty?
+          return true if duration_unsatisfied?(request: request)
           return true if need == :write && !write_verified?(effects: effects)
           return true if need == :browse && !effects.include?(:browse)
           return true if need == :any && !effects.intersect?(%i[write browse eval])
@@ -592,6 +594,32 @@ module PWN
           false
         end
 
+        HOUR_WORDS = {
+          'one' => 1, 'two' => 2, 'three' => 3, 'four' => 4, 'five' => 5,
+          'six' => 6, 'seven' => 7, 'eight' => 8, 'nine' => 9, 'ten' => 10,
+          'eleven' => 11, 'twelve' => 12, 'thirteen' => 13, 'fourteen' => 14,
+          'fifteen' => 15, 'sixteen' => 16, 'seventeen' => 17, 'eighteen' => 18,
+          'nineteen' => 19, 'twenty' => 20, 'twenty-four' => 24
+        }.freeze
+
+        private_class_method def self.duration_unsatisfied?(opts = {})
+          req = opts[:request].to_s
+          hours = nil
+          if (m = req.match(/\b(\d+)\s*(?:hours?|hrs?)\b/i))
+            hours = m[1].to_i
+          elsif (m = req.match(/\b(twenty-four|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|sixteen|seventeen|eighteen|nineteen|twenty)\s*(?:hours?|hrs?)\b/i))
+            hours = HOUR_WORDS[m[1].downcase]
+          end
+          return false if hours.to_i <= 0
+
+          t0 = Thread.current[:pwn_loop_t0]
+          return false unless t0
+
+          (Time.now - t0) < (hours * 3600)
+        rescue StandardError
+          false
+        end
+
         private_class_method def self.may_finalize?(opts = {})
           return false if incomplete_final?(text: opts[:text], last_iter: false)
           return false if request_unsatisfied?(
@@ -1589,23 +1617,13 @@ module PWN
         # Uses TaskSummarizer.active_task_prompt (full plan_context on first
         # force, compact focus thereafter). No-ops when already injected.
         private_class_method def self.inject_task_focus!(opts = {})
-          state = opts[:state]
-          messages = opts[:messages]
-          return nil unless state.is_a?(Hash) && messages.is_a?(Array)
-          return nil unless defined?(TaskSummarizer) && TaskSummarizer.enabled?
-          return nil if respond_to?(:needs_host_work?) && !needs_host_work?(request: opts[:request] || state[:original_request] || state[:request])
-          return nil unless TaskSummarizer.plan_open?(state: state, messages: messages)
-
-          req = opts[:request]
-          req = state[:original_request] || state[:request] if req.to_s.strip.empty? && state.is_a?(Hash)
-          text =
-            (TaskSummarizer.active_task_prompt(state: state, force: opts[:force], request: req) if TaskSummarizer.respond_to?(:active_task_prompt))
-          return nil if text.to_s.strip.empty?
-
-          messages << { role: 'user', content: text }
-          text
-        rescue StandardError => e
-          warn "[pwn-ai/loop] inject_task_focus! swallowed: #{e.class}: #{e.message}"
+          # Original request is the only model-facing goal. TaskSummarizer
+          # remains TUI (emit_plan / about_to). Do not append a compass
+          # user message that can replace the operator ask.
+          return nil if opts.is_a?(Hash)
+
+          nil
+        rescue StandardError
           nil
         end
 
@@ -2396,6 +2414,7 @@ module PWN
           Thread.current[:pwn_request_intent] = intent
           Thread.current[:pwn_extinguished] = {}
           Thread.current[:pwn_same_payload] = Hash.new(0)
+          Thread.current[:pwn_loop_t0] = Time.now unless nested
           debug_progress(msg: "intent=#{intent} engine=#{engine}", debug: opts[:debug])
           expose_current_session(session_id: session_id)
           Mistakes.check_user_correction(request: request, session_id: session_id) if defined?(Mistakes)
@@ -2795,7 +2814,8 @@ module PWN
             iter: i,
             tools_called: tools_called,
             engine_s: engine_s,
-            final_chars: final_chars
+            final_chars: final_chars,
+            nested: nested
           )
           TurnFinalizer.leave_user_path! if defined?(TurnFinalizer)
         end

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

@@ -328,6 +328,7 @@ module PWN
             source = :injected
           else
             tasks = llm_decompose(goal: goal, llm_tasks: opts[:llm_tasks], has_llm_tasks: opts.key?(:llm_tasks))
+            tasks = reject_scaffold_tasks(tasks: tasks)
             source = tasks.any? ? :llm : nil
             if tasks.length < MIN_PLAN_TASKS
               tasks = fallback_decompose(goal: goal)
@@ -677,19 +678,9 @@ module PWN
             return tasks
           end
 
-          tasks << 'Understand the request'
-          tasks << 'Carry out the core work'
-
-          if goal_lc.match?(/\b(json|ya?ml|table|csv|tsv)\b/)
-            fmt = goal_lc[/\b(json|ya?ml|table|csv|tsv)\b/]
-            tasks << "Present the results in #{fmt} format"
-          elsif goal_lc.match?(/\b(display|show|print|output|format|present|report|export)\b/)
-            tasks << 'Present the final results in the requested format'
-          end
-
-          # Only when the user actually asked about tests/lint — not bare "verify".
-          tasks << 'Run specs, rubocop, and/or rake to verify' if goal_lc.match?(/\b(test|spec|rubocop|rake|lint)\b/) &&
-                                                                  goal_lc.match?(%r{\b(/opt/pwn|code|patch|refactor|commit)\b})
+          shaped = request_clause_tasks(goal: goal_text)
+          return shaped if shaped.length >= MIN_PLAN_TASKS
+          return [goal_text] unless goal_text.strip.empty?
 
           tasks
         rescue StandardError
@@ -706,6 +697,20 @@ module PWN
           fallback_decompose(goal: opts[:goal])
         end
 
+        private_class_method def self.request_clause_tasks(opts = {})
+          goal = opts[:goal].to_s.gsub(/\s+/, ' ').strip
+          return [] if goal.empty?
+
+          parts = goal.split(/(?<=[.!?])\s+|(?<=;)\s+|\s+(?:ensuring|then|and then)\s+/i)
+          parts = parts.map { |p| p.gsub(/\s+/, ' ').strip.sub(/\A(?:so|and|then)\s+/i, '') }
+          parts = reject_scaffold_tasks(tasks: parts).reject { |p| p.length < 24 }
+          return parts.first(8) if parts.length >= MIN_PLAN_TASKS
+
+          [goal]
+        rescue StandardError
+          []
+        end
+
         private_class_method def self.truncate_goal(opts = {})
           # Task summaries are displayed in full — do not ellipsize goals or
           # plan items. (:len retained for call-site compatibility.)
@@ -987,14 +992,7 @@ module PWN
           state = opts[:state]
           request = opts[:request].to_s
           request = state[:request].to_s if request.empty? && state.is_a?(Hash)
-          parts = []
-          if state.is_a?(Hash)
-            info = active_task(state: state)
-            parts << info[:item] if info && !info[:item].to_s.empty?
-            Array(state[:plan]).each { |t| parts << t.to_s }
-          end
-          parts << request unless request.empty?
-          parts.map { |p| p.to_s.gsub(/\s+/, ' ').strip }.reject(&:empty?).uniq.join(' ')
+          request.gsub(/\s+/, ' ').strip
         rescue StandardError
           opts[:request].to_s
         end
@@ -1081,6 +1079,8 @@ module PWN
           return true if s.empty?
           return true if s.match?(/\A(?:GOAL|PLAN|REQUEST|ANSWER|FLAW|PATCH)\s*:/i)
           return true if s.match?(/\A\w+\s+command\s*=/i)
+          return true if s.match?(/\Aunderstand the request\z/i)
+          return true if s.match?(/\Acarry out the core work(?:\s+for:.*)?\z/i)
 
           false
         rescue StandardError
@@ -1393,7 +1393,7 @@ module PWN
           # Soft "verify the result and report" is a closer, not a test runner.
           return :present if s.match?(/\bverif\w*\b/) && !s.match?(/\b(rspec|rubocop|rake|lint|spec|test)\b/)
           return :mutate if s.match?(
-            /\b(implement\w*|fix|patch\w*|chang\w*|improv\w*|write|apply|wire|refactor\w*)\b/
+            /\b(implement\w*|fix|patch\w*|chang\w*|improv\w*|write|apply|wire|refactor\w*|core work|requested duration|eligible issues)\b/
           )
           return :discover if s.match?(
             /\b(locat\w*|find|read|inspect|recon\w*|understand|decompos\w*|map|identif\w*|gather|discover|enumerat\w*|scan|probe|determin\w*|analy[sz]e|analysis|root cause|where and why|track|navigat\w*|browse|goto)\b/

data/lib/pwn/version.rb

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

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

@@ -51,27 +51,28 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       end
     end
 
-    it 'injects English task focus into model messages (task-as-primary)' do
+    it 'does not inject English task focus as a competing user goal' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/inject_task_focus!/)
-      expect(src).to match(/active_task_prompt/)
-      # inject after emit_plan and inside the iteration loop
-      expect(src.scan('inject_task_focus!').length).to be >= 3
+      req = 'using hping3 what live hosts can you find in this subnet?'
+      focus = File.read(described_class.method(:inject_task_focus!).source_location.first)
+      expect(focus).to match(/original request is the only/)
+      st = { plan: ['Carry out the core work'], plan_idx: 0, original_request: req }
+      msgs = [{ role: 'user', content: req }]
+      out = described_class.send(:inject_task_focus!, state: st, messages: msgs, request: req, force: true)
+      expect(out).to eq nil
+      expect(msgs.length).to eq 1
     end
 
     it 'does not keep injecting English focus after the plan is covered' do
       src = File.read(described_class.method(:inject_task_focus!).source_location.first)
-      focus = src[/private_class_method def self\.inject_task_focus!.*?private_class_method def self\.\w+/m]
-      focus ||= src
-      expect(focus).to match(/plan_open\?/)
+      expect(src).to match(/original request is the only/)
     end
 
     it 'does not tell an open English plan to stop after 3 tools just because budget is hot' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/budget_exhaustion_hot\?/)
-      expect(src).to match(/plan_open\?/)
-      # local ≤3-tool abort is only for a closed/short plan, not mid-goal.
-      expect(src).to match(/english_open|plan_open\?/)
+      expect(src).to match(/original request is the completion signal/i)
     end
 
     it 'parks stale extra budget scars even while the host is hot' do
@@ -97,12 +98,15 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       FileUtils.remove_entry(tmp) if tmp && Dir.exist?(tmp)
     end
 
-    it 're-ranks Registry tools from English tangible tasks after plan (sole driver)' do
+    it 'ranks Registry tools from the original request, not the English plan' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/TaskSummarizer\.relevance_query/)
-      expect(src).to match(/relevance_query\(state: ts_state/)
-      # Must rebind tools after task_summary_plan! (not only from bare request)
-      expect(src).to match(/task_summary_plan!.*relevance_query|relevance_query.*inject_task_focus!/m)
+      q = PWN::AI::Agent::TaskSummarizer.relevance_query(
+        state: { plan: ['Carry out the core work', 'Present the result'], request: 'inventory sockets' },
+        request: 'inventory sockets'
+      )
+      expect(q).to eq 'inventory sockets'
+      expect(q).not_to match(/core work/i)
     end
 
     it 'P17 evidence_enough does not early-final on bare success while plan open' do
@@ -885,6 +889,27 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(described_class.send(:incomplete_final?, text: poc)).to eq(false)
     end
 
+    it 'keeps an N-hour host-work request unsatisfied until that duration elapses' do
+      req = 'perform unauthenticated analysis for Critical issues for the next eight hours. Eight hours non-stop is a requirement.'
+      recap = 'Alternative executed via pwn_eval. Probed unauth GraphQL mutations; wrote graphql/alt.json. Notable: createPriorAuthSupportUploadURL still reachable.'
+      msgs = [
+        { role: 'user', content: req },
+        {
+          role: 'assistant',
+          tool_calls: [{ function: { name: 'pwn_eval', arguments: '{"code":"1"}' } }]
+        },
+        { role: 'tool', name: 'pwn_eval', content: '{"success":true,"result":{"value":"1"},"effect":"eval"}' },
+        { role: 'assistant', content: recap }
+      ]
+      Thread.current[:pwn_loop_t0] = Time.now
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(true)
+      expect(described_class.send(:may_finalize?, request: req, messages: msgs, text: recap)).to eq(false)
+      Thread.current[:pwn_loop_t0] = Time.now - (9 * 3600)
+      expect(described_class.send(:request_unsatisfied?, request: req, messages: msgs)).to eq(false)
+    ensure
+      Thread.current[:pwn_loop_t0] = nil
+    end
+
     it 'forces tool_choice required on host-work before any tool result, for every engine' do
       src = File.read(described_class.method(:run).source_location.first)
       expect(src).to match(/tool_choice/)

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

@@ -416,10 +416,11 @@ describe PWN::AI::Agent::TaskSummarizer do
       expect(described_class).not_to receive(:chat_for_plan)
       tasks = described_class.plan(request: subnet_req)
       expect(tasks).to be_a(Array)
-      expect(tasks.length).to be >= 2
+      expect(tasks.length).to be >= 1
       joined = tasks.join(' | ').downcase
-      # Generic fallback — understand + core work + present JSON — NOT ARP/ICMP canned list.
-      expect(joined).to match(/json|present|core work|understand|carry out/)
+      expect(joined).to match(/subnet|host|json/)
+      expect(tasks).not_to include('Understand the request')
+      expect(tasks).not_to include('Carry out the core work')
       expect(described_class.heuristic_decompose(goal: subnet_req)).to eq(
         described_class.fallback_decompose(goal: subnet_req)
       )
@@ -695,11 +696,10 @@ describe PWN::AI::Agent::TaskSummarizer do
       expect(described_class.tool_jargon_task?(item: 'fix the truncation bug')).to eq false
     end
 
-    it 'relevance_query prefers active English task + plan over bare request' do
+    it 'relevance_query is the original request, not the English plan' do
       q = described_class.relevance_query(state: state, request: state[:request])
-      expect(q).to include('locate the TaskSummarizer source')
-      expect(q).to include('fix the truncation bug')
-      expect(q).to include('run rspec to verify')
+      expect(q).to eq state[:request].to_s.gsub(/\s+/, ' ').strip
+      expect(q).not_to include('Carry out the core work')
     end
 
     it 'apply_prm_advancement! holds on +1 search streak and on -1; advances on next-task handoff' do
@@ -981,14 +981,53 @@ describe PWN::AI::Agent::TaskSummarizer do
       expect(st[:plan_idx]).to eq 1
     end
 
+    it 'does not complete Carry out the core work on three directory listings' do
+      st = described_class.fresh(request: 'perform unauthenticated analysis for eight hours')
+      st[:plan] = [
+        'Understand the request',
+        'Carry out the core work',
+        'Present the result and report completion'
+      ]
+      st[:plan_idx] = 1
+      3.times do |i|
+        described_class.record!(
+          state: st,
+          name: 'shell',
+          args: { 'command' => "cat /opt/bugbounty/programs/curative/POLICY.md #{i}" },
+          result: '{"success":true,"result":{"stdout":"Curative Inc. looks forward to working with the security community to find security vulnerabilities. POLICY.md body easily over forty characters.","exit":0}}'
+        )
+      end
+      expect(st[:plan_idx]).to eq 1
+    end
+
     it 'does not paste the full operator goal into fallback understand/carry-out tasks' do
       goal = 'Until we can claim credentials perform unauthenticated analysis for Critical / High severity issues ' \
              'eligible for submission leveraging ~/.pwn/skills for all subdomains in scope for the next eight hours'
       tasks = described_class.fallback_decompose(goal: goal)
-      expect(tasks.length).to be >= 2
+      expect(tasks.length).to be >= 1
       expect(tasks.grep(/Understand the request:/)).to eq([])
       expect(tasks.grep(/Carry out the core work for:/)).to eq([])
-      expect(tasks.join("\n").length).to be < goal.length
+      expect(tasks).not_to include('Understand the request')
+      expect(tasks).not_to include('Carry out the core work')
+      joined = tasks.join("\n")
+      expect(joined).to match(/unauth/i)
+      expect(joined).to match(/critical|high/i)
+      expect(joined).to match(/eight hours|requested duration/i)
+      expect(joined).to match(/PoC|severity|attack chain/i)
+    end
+
+    it 'keeps distinctive tokens from unrelated unique goals instead of a stub plan' do
+      [
+        'Inventory every listening TCP socket on this host and print pid user and port',
+        'Name every Ruby constant under PWN::AI::Agent and print them as a JSON array'
+      ].each do |goal|
+        tasks = described_class.fallback_decompose(goal: goal)
+        expect(tasks).not_to include('Understand the request')
+        expect(tasks).not_to include('Carry out the core work')
+        joined = tasks.join(' ')
+        tokens = goal.scan(%r{[A-Za-z0-9_./-]{5,}}).uniq
+        expect(tokens.count { |tok| joined.downcase.include?(tok.downcase) }).to be >= 2
+      end
     end
 
     it 'a verify task is covered after the verifier ran, even with remaining offenses' do

data/third_party/pwn_rdoc.jsonl

@@ -338,6 +338,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.default_interactive_toolsets Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.default_interactive_toolsets`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.degrade_text_only Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.degrade_text_only`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.dispatch_fail_n Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.dispatch_fail_n`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.duration_unsatisfied? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.duration_unsatisfied?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.emit_task_summary Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.emit_task_summary`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.engine_transient? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.engine_transient?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.escalate Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.escalate`: "}]}
@@ -700,6 +701,7 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.reject_scaffold_tasks Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.reject_scaffold_tasks`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.relevance_query Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.relevance_query`: Supported Method Parameters\n\nq = PWN::AI::Agent::TaskSummarizer.relevance_query(\n\nstate: 'optional - fresh() hash',\nrequest: 'optional - original user goal fallback'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.remember_brief! Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.remember_brief!`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.request_clause_tasks Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.request_clause_tasks`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.sidecar_timeout Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.sidecar_timeout`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.squeeze_request_ws Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.squeeze_request_ws`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::TaskSummarizer.task_complete_enough? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::TaskSummarizer.task_complete_enough?`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.701
+  version: 0.5.702
 platform: ruby
 authors:
 - 0day Inc.