pwn 0.5.674 → 0.5.676

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a62ba09707c5e4256e02e501ace75b21fd3d29e0f3239b64e054743e8481deaa
-  data.tar.gz: 8c3a604756f02a0f3e47fc7633cc6ed6b7362adb1613a82db8418668b2e3a1fa
+  metadata.gz: 65d8aa03f93adc593efbfb8b342885f8ceb815a19a6a8ef8e72c3b0a493a32a5
+  data.tar.gz: eee3d957a5975a105240040cf6bd2f0a44a05d35cbac3240ec252f913cc38c5e
 SHA512:
-  metadata.gz: cd13158fb37c453d6ed9eb20008ac7896cd9c31c1f4efdc60a18eaa00878ae1bd0a46cdb640ff4a49bd2edd9eeeb6e14a42f2c59c764916641b57a2a040e6477
-  data.tar.gz: 39a6032209299723a26bb76160b980e4c51f3e7ba5e0bd06d7f1228bde1e5637ef9d91ed7f639071e42f6eeaaa8d9e2be688b678551dc6d14faddf1d8137f492
+  metadata.gz: 03f6a8960538e278b4041981a64ad27c4163e3748a11866c559c81da75152644f62b61658f695369f0281832e03d0810f012f47387b3ff4c456ad2df964b365c
+  data.tar.gz: 9b3eec90f64577c1167ae556d713f07f82f1c76d43255a14b7a1b69eaec5cfa2bdd9d99343d0a338aef40d1aa9e6fbd2c4c89d72e9e5d7b35b6a69ab504cdc07

data/Gemfile

@@ -49,7 +49,7 @@ gem 'jwt', '3.2.0'
 gem 'libusb', '0.8.0'
 gem 'luhn', '3.0.0'
 gem 'mail', '2.9.1'
-gem 'mcp', '1.1.0'
+gem 'mcp', '1.2.0'
 gem 'meshtastic', '0.0.173'
 gem 'metasm', '1.0.6'
 gem 'mongo', '2.25.0'

data/bin/pwn

@@ -51,9 +51,11 @@ begin
     # ------------------------------------------------------------------
     if opts[:setup] == true
       r = PWN::Setup.check
+      PWN::Setup.ensure_cron(restart: false)
       exit(r[:ok] ? 0 : 1)
     else
       PWN::Setup.deps(profile: opts[:setup])
+      PWN::Setup.ensure_cron(restart: false)
     end
   elsif opts[:ai]
     # ------------------------------------------------------------------

data/bin/pwn_setup

@@ -54,11 +54,27 @@ pwn_driver = PWN::Driver::Parser.new do |options|
              '<Optional - Print the commands that would run, do not execute>') do |o|
     opts[:dry_run] = o
   end
+
+  options.on('--[no-]cron',
+             '<Optional - Enable (default) or disable OS-native persistence of pwn-ai cron jobs>') do |o|
+    opts[:cron] = o
+  end
 end
 pwn_driver.auto_opts_help = false
 pwn_driver.parse!
 
 begin
+  status = 0
+  # Seed default jobs + start/reuse the in-process scheduler so last_run
+  # actually advances. Do this BEFORE the doctor so `pwn setup` reports
+  # the worker as running. Skip list/terminal (no host scheduler needed)
+  # and dry-run (must not spawn).
+  unless opts[:list] || opts[:terminal] || opts[:dry_run]
+    cron_opts = { restart: false, dry_run: false }
+    cron_opts[:enabled] = opts[:cron] unless opts[:cron].nil?
+    PWN::Setup.ensure_cron(**cron_opts)
+  end
+
   if opts[:list]
     PWN::Setup.list_profiles
   elsif opts[:migrate]
@@ -66,7 +82,7 @@ begin
       fix: opts[:fix] || opts[:yes],
       dry_run: opts[:dry_run]
     )
-    exit 1 unless r && r[:after] && r[:after][:incompatible].empty?
+    status = 1 unless r && r[:after] && r[:after][:incompatible].empty?
   elsif opts[:terminal]
     PWN::Setup.terminal(
       yes: opts[:yes],
@@ -83,8 +99,18 @@ begin
     # `pwn setup --check`               → same
     # `pwn setup --check --profile net` → gate ONLY on the :net profile
     r = PWN::Setup.check(profile: opts[:profile])
-    exit 1 unless r[:ok]
+    status = 1 unless r[:ok]
+  end
+
+  # Seed default jobs + start/reuse the in-process scheduler so
+  # last_run actually advances. Skip list/terminal (no host scheduler
+  # needed) and dry-run (must not spawn).
+  unless opts[:list] || opts[:terminal] || opts[:dry_run]
+    cron_opts = { restart: false, dry_run: false }
+    cron_opts[:enabled] = opts[:cron] unless opts[:cron].nil?
+    PWN::Setup.ensure_cron(**cron_opts)
   end
+  exit status
 rescue Interrupt
   puts "\naborted."
   exit 130

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

@@ -460,6 +460,11 @@ module PWN
           return unless session_id
           return unless auto_introspect_enabled?
 
+          # Hermes split: Loop.run is on the stack → defer critic/judge/PRM/HER
+          # onto a daemon thread so the user already has the reply. Specs,
+          # cron, and tools pass through (inline:true or no user-path depth).
+          return TurnFinalizer.defer(opts.merge(inline: true)) if defined?(TurnFinalizer) && !opts[:inline] && TurnFinalizer.should_defer?
+
           t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           stages_run = []
           stages_skipped = []

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

@@ -1063,6 +1063,16 @@ module PWN
         # 3.2 — local models cannot afford auto_introspect (judge+prm+critic+
         # sentinel+extro) on every success. Default :failure_only when local.
         private_class_method def self.should_auto_introspect?(opts = {})
+          kind = (opts[:kind] || Thread.current[:pwn_request_kind]).to_s.to_sym
+          intent = (opts[:intent] || Thread.current[:pwn_request_intent]).to_s.to_sym
+          fails = opts[:turn_fails].is_a?(Hash) ? opts[:turn_fails].values.sum : 0
+          # Cheap answers already returned user-visible text. The post-answer
+          # critic + 12s ORM printed ERROR: Timed out reading data from server
+          # after greetings / takes / questions.
+          return false if %i[greeting howto recall].include?(intent)
+          return false if kind == :statement
+          return false if kind == :question && fails.zero?
+
           return true unless opts[:local]
 
           policy = agent_flag(key: :local_introspect, default: :failure_only).to_s.to_sym
@@ -1865,6 +1875,7 @@ module PWN
           request = opts[:request].to_s
           session_id = opts[:session_id]
           on_tool = opts[:on_tool]
+          TurnFinalizer.enter_user_path! if defined?(TurnFinalizer)
           # Live coalesced "what am I doing" lines for the TUI (not a model tool).
           ts_state = (TaskSummarizer.fresh(request: request) if defined?(TaskSummarizer) && TaskSummarizer.enabled? && Thread.current[:pwn_reflect_depth].to_i.zero?)
           engine = active_engine
@@ -2297,6 +2308,8 @@ module PWN
           maybe_finish_policy(session_id: session_id, proxy_ok: false, ts_state: ts_state)
           task_summary_flush!(state: ts_state, on_tool: on_tool)
           final_msg
+        ensure
+          TurnFinalizer.leave_user_path! if defined?(TurnFinalizer)
         end
 
         # Author(s):: 0day Inc. <support@0dayinc.com>

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

@@ -434,6 +434,21 @@ module PWN
           Thread.current[EP_KEY]
         end
 
+        # Hermes split: snapshot + clear the live episode so Loop.maybe_finish_policy
+        # is a no-op on the user-visible path while TurnFinalizer re-attaches it
+        # on the background review thread.
+
+        public_class_method def self.detach_episode!
+          ep = Thread.current[EP_KEY]
+          Thread.current[EP_KEY] = nil
+          ep
+        end
+
+        public_class_method def self.attach_episode!(opts = {})
+          Thread.current[EP_KEY] = opts[:episode]
+          opts[:episode]
+        end
+
         # ----------------------------------------------------------------
         # Persistence / eval
         # ----------------------------------------------------------------

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

@@ -41,6 +41,9 @@ module PWN
 
           # 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.
           <<~PROMPT
             #{base}
 
@@ -51,7 +54,7 @@ module PWN
               pwn        : #{pwn_version}
               session_id : #{session_id || '(none)'}
 
-            #{memory_block(limit: b[:memory], request: request)}#{recent_turns_block(session_id: session_id, request: request, limit: b[:recent_turns])}#{skills_block}#{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
+            #{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
               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).

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

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module PWN
+  module AI
+    module Agent
+      # Hermes-style prompt-cache breakpoints. The static system prefix +
+      # SKILLS index stay cacheable; dynamic MEMORY / LEARNING / MISTAKES /
+      # METRICS / EXTROSPECTION stay uncached so a turn-local write is not
+      # baked into the prefix.
+      #
+      # Anthropic: system is an array of text blocks; the last static block
+      # carries cache_control: { type: 'ephemeral' }.
+      # OpenAI Chat Completions: two system/developer messages (static then
+      # dynamic) plus prompt_cache_key for cache routing.
+      # xAI Grok Chat Completions: the same message split plus the
+      # x-grok-conv-id request header (sticky server routing).
+      # Gemini generateContent: systemInstruction.parts = [static, dynamic]
+      # so implicit prefix cache can hit the stable head.
+      # Ollama: no-op.
+      module PromptCache
+        STATIC_HEAD = %w[ENVIRONMENT].freeze
+        DYNAMIC_HEADS = [
+          'MEMORY',
+          'RECENT TURNS',
+          'LEARNING',
+          'OPERATOR INBOX',
+          'KNOWN MISTAKES',
+          'KNOWN FIXES',
+          'TOOL EFFECTIVENESS',
+          'POLICY',
+          'EXTROSPECTION',
+          'TOOL USE'
+        ].freeze
+
+        # Supported Method Parameters::
+        # ok = PWN::AI::Agent::PromptCache.enabled?(engine: :anthropic)
+
+        public_class_method def self.enabled?(opts = {})
+          flag = agent_flag(key: :prompt_cache, default: true)
+          return false if flag == false || flag.to_s.match?(/\A(0|false|no|off)\z/i)
+
+          engine = (opts[:engine] || active_engine).to_s.downcase.to_sym
+          supports.include?(engine)
+        rescue StandardError
+          false
+        end
+
+        # Supported Method Parameters::
+        # parts = PWN::AI::Agent::PromptCache.split_system(text: system_prompt)
+        #
+        # → { static: String, dynamic: String, skills: String }
+
+        public_class_method def self.split_system(opts = {})
+          text = opts[:text].to_s
+          return { static: '', dynamic: '', skills: '' } if text.empty?
+
+          dyn_idx = first_dynamic_index(text: text)
+          if dyn_idx.nil?
+            skills = extract_skills(text: text)
+            return { static: text, dynamic: '', skills: skills }
+          end
+
+          static = text[0...dyn_idx].rstrip
+          dynamic = text[dyn_idx..].to_s
+          { static: static, dynamic: dynamic, skills: extract_skills(text: static) }
+        rescue StandardError
+          { static: opts[:text].to_s, dynamic: '', skills: '' }
+        end
+
+        # Supported Method Parameters::
+        # blocks = PWN::AI::Agent::PromptCache.anthropic_system_blocks(text: system_prompt)
+        #
+        # → [ {type:'text', text: static, cache_control:{type:'ephemeral'}},
+        #     {type:'text', text: dynamic} ]  (empty blocks omitted)
+
+        public_class_method def self.anthropic_system_blocks(opts = {})
+          parts = split_system(text: opts[:text])
+          blocks = []
+          unless parts[:static].to_s.strip.empty?
+            blocks << {
+              type: 'text',
+              text: parts[:static],
+              cache_control: { type: 'ephemeral' }
+            }
+          end
+          blocks << { type: 'text', text: parts[:dynamic] } unless parts[:dynamic].to_s.strip.empty?
+          blocks
+        rescue StandardError
+          txt = opts[:text].to_s
+          return [] if txt.strip.empty?
+
+          [{ type: 'text', text: txt }]
+        end
+
+        # Supported Method Parameters::
+        # messages = PWN::AI::Agent::PromptCache.openai_messages(messages: [...])
+        #
+        # Split the first system/developer message into a stable static
+        # prefix and a turn-local dynamic tail so OpenAI / xAI implicit
+        # prefix matching can hit across turns. Does NOT emit Anthropic
+        # cache_control.
+
+        public_class_method def self.openai_messages(opts = {})
+          messages = Array(opts[:messages]).map { |m| m.is_a?(Hash) ? m.dup : m }
+          idx = messages.index do |m|
+            next false unless m.is_a?(Hash)
+
+            %w[system developer].include?((m[:role] || m['role']).to_s)
+          end
+          return messages unless idx
+
+          msg = messages[idx]
+          role = msg[:role] || msg['role']
+          text = (msg[:content] || msg['content']).to_s
+          parts = split_system(text: text)
+          return messages if parts[:static].to_s.strip.empty? || parts[:dynamic].to_s.strip.empty?
+
+          static_msg = msg.dup
+          if static_msg.key?(:content) || !static_msg.key?('content')
+            static_msg[:content] = parts[:static]
+          else
+            static_msg['content'] = parts[:static]
+          end
+
+          dynamic_msg = if msg.key?(:role) || !msg.key?('role')
+                          { role: role, content: parts[:dynamic] }
+                        else
+                          { 'role' => role, 'content' => parts[:dynamic] }
+                        end
+
+          messages[idx, 1] = [static_msg, dynamic_msg]
+          messages
+        rescue StandardError
+          Array(opts[:messages])
+        end
+
+        # Supported Method Parameters::
+        # inst = PWN::AI::Agent::PromptCache.gemini_system_instruction(text: system_prompt)
+        #
+        # → { parts: [{text: static}, {text: dynamic}] }  (empty omitted)
+
+        public_class_method def self.gemini_system_instruction(opts = {})
+          parts = split_system(text: opts[:text])
+          out = []
+          out << { text: parts[:static] } unless parts[:static].to_s.strip.empty?
+          out << { text: parts[:dynamic] } unless parts[:dynamic].to_s.strip.empty?
+          return nil if out.empty?
+
+          { parts: out }
+        rescue StandardError
+          txt = opts[:text].to_s
+          return nil if txt.strip.empty?
+
+          { parts: [{ text: txt }] }
+        end
+
+        # Supported Method Parameters::
+        # key = PWN::AI::Agent::PromptCache.cache_key(text: system_prompt)
+        # key = PWN::AI::Agent::PromptCache.cache_key(key: 'explicit-override')
+        #
+        # Stable OpenAI prompt_cache_key / xAI x-grok-conv-id. Hashes the
+        # static prefix so MEMORY / LEARNING churn does not rotate the key.
+
+        public_class_method def self.cache_key(opts = {})
+          explicit = opts[:key]
+          return explicit.to_s unless explicit.to_s.strip.empty?
+
+          raw = opts[:text].to_s
+          static = raw.empty? ? '' : split_system(text: raw)[:static].to_s
+          static = raw if static.strip.empty?
+          static = 'pwn-ai' if static.strip.empty?
+          "pwn-#{Digest::SHA256.hexdigest(static)[0, 24]}"
+        rescue StandardError
+          'pwn-ai'
+        end
+
+        # Supported Method Parameters::
+        # n = PWN::AI::Agent::PromptCache.cache_marks(blocks: [...])
+
+        public_class_method def self.cache_marks(opts = {})
+          Array(opts[:blocks]).count do |b|
+            next false unless b.is_a?(Hash)
+
+            cc = b[:cache_control] || b['cache_control']
+            cc.is_a?(Hash) && (cc[:type] || cc['type']).to_s == 'ephemeral'
+          end
+        end
+
+        public_class_method def self.supports
+          %i[anthropic openai grok gemini]
+        end
+
+        public_class_method def self.authors
+          "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+        end
+
+        public_class_method def self.help
+          puts <<~USAGE
+            USAGE:
+              parts  = PWN::AI::Agent::PromptCache.split_system(text: system_prompt)
+              blocks = PWN::AI::Agent::PromptCache.anthropic_system_blocks(text: system_prompt)
+              msgs   = PWN::AI::Agent::PromptCache.openai_messages(messages: [...])
+              inst   = PWN::AI::Agent::PromptCache.gemini_system_instruction(text: system_prompt)
+              key    = PWN::AI::Agent::PromptCache.cache_key(text: system_prompt)
+              # Engine chat_with_tools uses the helpers automatically when
+              # PWN::Env[:ai][:agent][:prompt_cache] is truthy (default).
+
+              Toggle via PWN::Env[:ai][:agent][:prompt_cache]
+              #{self}.authors
+          USAGE
+        end
+
+        private_class_method def self.first_dynamic_index(opts = {})
+          text = opts[:text].to_s
+          idxs = DYNAMIC_HEADS.filter_map do |head|
+            i = text.index(/^#{Regexp.escape(head)}\b/)
+            i
+          end
+          idxs.min
+        end
+
+        private_class_method def self.extract_skills(opts = {})
+          text = opts[:text].to_s
+          m = text.match(%r{^SKILLS[^\n]*\n(?:.*\n)*?(?=\n[A-Z][A-Z /]|\z)})
+          m ? m[0] : ''
+        rescue StandardError
+          ''
+        end
+
+        private_class_method def self.active_engine
+          return :openai unless defined?(PWN::Env) && PWN::Env.is_a?(Hash)
+
+          PWN::Env.dig(:ai, :active).to_s.downcase.to_sym
+        rescue StandardError
+          :openai
+        end
+
+        private_class_method def self.agent_flag(opts = {})
+          key = opts[:key]
+          default = opts[:default]
+          return default unless defined?(PWN::Env)
+
+          val = PWN::Env.dig(:ai, :agent, key)
+          val.nil? ? default : val
+        rescue StandardError
+          opts[:default]
+        end
+      end
+    end
+  end
+end

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

@@ -97,7 +97,8 @@ module PWN
                   system_role_content: system_role_content,
                   spinner: spinner,
                   timeout: timeout,
-                  temp: temp
+                  temp: temp,
+                  quiet: opts[:quiet]
                 )
               end
             ensure
@@ -132,6 +133,7 @@ module PWN
           chat_opts[:timeout] = opts[:timeout] unless opts[:timeout].nil?
           chat_opts[:temp] = opts[:temp] unless opts[:temp].nil?
           chat_opts[:model] = opts[:model] unless opts[:model].to_s.empty?
+          chat_opts[:quiet] = opts[:quiet] unless opts[:quiet].nil?
           mod.chat(chat_opts)
         end
 

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

@@ -1157,11 +1157,20 @@ module PWN
                 spinner: false,
                 model: judge_model,
                 timeout: cheap_orm_timeout,
-                temp: CHEAP_ORM_TEMP
+                temp: CHEAP_ORM_TEMP,
+                quiet: true
               )
               text = extract_chat_text(resp: raw)
               return text unless text.strip.empty?
-            rescue StandardError
+
+              # Quiet ReadTimeout now returns nil instead of raising. That
+              # empty response already spent the cheap-ORM budget — do not
+              # immediately fire engine_chat_cheap (second 12s stall).
+              return nil
+            rescue StandardError => e
+              # A 12s ReadTimeout already spent the cheap-ORM budget.
+              return nil if timeout_error?(err: e)
+
               nil
             end
           end
@@ -1191,7 +1200,8 @@ module PWN
             system_role_content: opts[:system_role_content],
             spinner: false,
             timeout: cheap_orm_timeout,
-            temp: CHEAP_ORM_TEMP
+            temp: CHEAP_ORM_TEMP,
+            quiet: true
           }
           model = judge_model
           chat_opts[:model] = model unless model.to_s.empty?
@@ -1200,6 +1210,20 @@ module PWN
           nil
         end
 
+        private_class_method def self.timeout_error?(opts = {})
+          err = opts[:err]
+          return false if err.nil?
+
+          klass = err.class
+          name = klass.name.to_s
+          return true if name.include?('Timeout') || name.include?('ReadTimeout') || name.include?('OpenTimeout')
+          return true if err.message.to_s.match?(/timed out reading|read timeout|open timeout/i)
+
+          false
+        rescue StandardError
+          false
+        end
+
         private_class_method def self.cheap_orm_timeout
           n = agent_flag(key: :reward_llm_timeout, default: CHEAP_ORM_TIMEOUT).to_i
           n = CHEAP_ORM_TIMEOUT if n < 2

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

@@ -566,7 +566,9 @@ module PWN
               request: user,
               system_role_content: system,
               suppress_pii_warning: true,
-              spinner: false
+              spinner: false,
+              timeout: sidecar_timeout,
+              quiet: true
             )
             text = reflect_text(resp: resp)
             return text unless text.to_s.strip.empty?
@@ -846,7 +848,9 @@ module PWN
               request: user,
               system_role_content: system,
               suppress_pii_warning: true,
-              spinner: false
+              spinner: false,
+              timeout: sidecar_timeout,
+              quiet: true
             )
             text = reflect_text(resp: resp)
             return text unless text.to_s.strip.empty?
@@ -896,7 +900,9 @@ module PWN
           r = mod.chat(
             request: opts[:request],
             system_role_content: opts[:system_role_content],
-            spinner: false
+            spinner: false,
+            timeout: sidecar_timeout,
+            quiet: true
           )
           reflect_text(resp: r)
         rescue StandardError => e
@@ -911,6 +917,17 @@ module PWN
           :ollama
         end
 
+        # Kind / plan classification is a sidecar hop. Bound it so a hung
+        # model cannot stall the user's real answer, and stay quiet on timeout.
+        private_class_method def self.sidecar_timeout
+          n = (PWN::Env.dig(:ai, :agent, :sidecar_llm_timeout) if defined?(PWN::Env)).to_i
+          n = 20 if n < 5
+          n = 60 if n > 60
+          n
+        rescue StandardError
+          20
+        end
+
         # Parse JSON array, fenced JSON, or numbered/bulleted plain text.
         #
         # Supported Method Parameters::