pwn 0.5.685 → 0.5.686

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4969508ce00cf858c5dfd06506e306f37d86e3d0671f07c3d3c021fa603b49d8
-  data.tar.gz: 6e23201a56add7514b8a12de42ee930aba424e33329bc9c608bd3dc4c2ce0473
+  metadata.gz: 1c85ad9f56d45556168111931b475458009ad82fd7dac279457824484dde1105
+  data.tar.gz: 8cc423564b1f6adc95674b7002ca2a33abcc3e337b0d9a4dbf493a108431d1af
 SHA512:
-  metadata.gz: 980664beb783d0a4c4aed5df5548d8f3c839e47afadd566a35f5b3b4413d6242e6c6da54319cacc91ceb7a3f8f5756f8268d29876b6277fdfda2e2f4475a251d
-  data.tar.gz: de6ce8fac7cc8c1dda8989faef831c4c32bf88141d188b113aa16b7b0035f3062505fc4cb843ea2b7f9e179306f66060ab8fbc1e4c8a325169a274f5784ef79f
+  metadata.gz: f1b42ef466382cbe8122910f5baee95d4c1af40090bf31e26961f31ee2d66a44be805c51bed475c4f96b57c9a0fac00cacd7a2a554f1035fabd354823f4a4652
+  data.tar.gz: a53ae1eeb0fdd70938672b357c55456699810679921abd9ecfa17a1f296a3fe9c4b10dfd663b0958e52b450d80a7197c601724120efc9ccf03b90c0cac1d55b2

data/documentation/General-PWN-Usage.md

@@ -45,7 +45,7 @@ history                             # what you've typed → copy into a driver
 | `pwn-ai-sessions` | List / view / delete transcripts |
 | `pwn-ai-cron` | List / run scheduled jobs |
 | `pwn-ai-delegate` | Hand a task to a Swarm persona |
-| `toggle-pwn-ai-debug` | Show/hide raw tool_calls JSON |
+| `toggle-pwn-ai-debug` | Stream pwn-ai module progress to the TUI and `/tmp/pwn-ai-DEBUG-TIMESTAMP.log` |
 | `toggle-pwn-ai-speaks` | TTS every final answer on/off |
 | `welcome-banner` | Redraw a random `PWN::Banner` |
 | `toggle-pager` | Pry pager on/off |

data/documentation/pwn-REPL.md

@@ -27,7 +27,7 @@ commands.
 | `pwn-ai-cron` | `PWN::Cron` | List/run/toggle scheduled jobs |
 | `pwn-ai-delegate` | `Agent::Swarm` | Send one request to a persona |
 | `pwn-irc` | *(deprecated)* | Prints a pointer to `Agent::Swarm` - the IRC daemon transport is gone |
-| `toggle-pwn-ai-debug` | `Agent::Loop` | Show/hide raw tool_calls JSON in the TUI |
+| `toggle-pwn-ai-debug` | `Agent::Loop` / `Plugins::Log` | Stream every pwn-ai module step to the TUI and `/tmp/pwn-ai-DEBUG-TIMESTAMP.log` |
 | `toggle-pwn-ai-speaks` | `Plugins::Voice` | TTS every final answer on/off |
 | `welcome-banner` | `PWN::Banner` | Redraw a random banner |
 | `toggle-pager` | Pry | Page long output on/off |

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

@@ -62,6 +62,49 @@ module PWN
           unsatisfied incomplete_final empty_final evidence_final
         ].freeze
 
+        public_class_method def self.debug_on?(opts = {})
+          return true if opts[:debug]
+          return true if defined?(PWN::Plugins::Log) && PWN::Plugins::Log.debug_enabled?
+
+          pry_on = defined?(Pry) && Pry.respond_to?(:config) &&
+                   Pry.config.respond_to?(:pwn_ai_debug) && Pry.config.pwn_ai_debug
+          return true if pry_on
+
+          false
+        end
+
+        private_class_method def self.debug_progress(opts = {})
+          return false unless debug_on?(opts)
+          return false unless defined?(PWN::Plugins::Log)
+
+          PWN::Plugins::Log.progress(
+            msg: opts[:msg],
+            which_self: opts[:which_self] || self
+          )
+        end
+
+        private_class_method def self.start_debug_session(opts = {})
+          return unless debug_on?(opts)
+          return unless defined?(PWN::Plugins::Log)
+          return if PWN::Plugins::Log.debug_enabled?
+
+          PWN::Plugins::Log.start_debug(tee: opts[:debug_tee] || $stdout)
+        end
+
+        private_class_method def self.quiet_debug_tui!(opts = {})
+          return unless debug_on?(opts)
+          return unless defined?(PWN::Plugins::Log)
+
+          PWN::Plugins::Log.quiet_tui!(reason: opts[:reason])
+        end
+
+        private_class_method def self.loud_debug_tui!(opts = {})
+          return unless debug_on?(opts)
+          return unless defined?(PWN::Plugins::Log)
+
+          PWN::Plugins::Log.loud_tui!(reason: opts[:reason])
+        end
+
         private_class_method def self.dispatch_fail_n(opts = {})
           fails = opts[:turn_fails] || {}
           fails.sum do |key, count|
@@ -343,6 +386,7 @@ module PWN
           return false if request.match?(LOOKUP_REQUEST_RX)
           return false if request.match?(HOST_PATH_RX)
           return false if request.match?(BROWSER_REQUEST_RX)
+          return false if request.match?(HOWTO_RX)
           return false if request.match?(%r{\b(this\s+(?:host|machine|box|system|subnet|file|repo)|/opt/|implement|scan|hosts?)\b}i)
 
           request.match?(/\A(?:what|why|who|when|where|which|how)\b/i)
@@ -1095,6 +1139,9 @@ module PWN
         private_class_method def self.call_engine(opts = {})
           messages = opts[:messages]
           tools = opts[:tools]
+          debug_progress(
+            msg: "call_engine tools=#{tools.nil? ? 'none' : Array(tools).length} msgs=#{Array(messages).length}"
+          )
 
           engine = active_engine
           mod_name = ENGINE_MODS[engine]
@@ -1569,6 +1616,8 @@ module PWN
           txt = txt.to_s.strip
           txt = 'I do not have enough context to answer that yet.' if txt.empty?
 
+          debug_progress(msg: "final accepted chars=#{txt.length}")
+          quiet_debug_tui!(reason: 'question')
           append_session(session_id: session_id, role: 'user', content: request)
           append_session(session_id: session_id, role: 'assistant', content: txt)
           if defined?(Learning) && should_auto_introspect?(local: local_engine?, turn_fails: {}, iter: 0)
@@ -1583,6 +1632,7 @@ module PWN
           end
           txt
         rescue StandardError => e
+          quiet_debug_tui!(reason: 'question_error')
           warn "[pwn-ai/loop] answer_question swallowed: #{e.class}: #{e.message}"
           "Could not answer the question (#{e.class}: #{e.message})."
         end
@@ -1983,6 +2033,9 @@ module PWN
           request = opts[:request].to_s
           session_id = opts[:session_id]
           on_tool = opts[:on_tool]
+          start_debug_session(opts)
+          loud_debug_tui!(debug: opts[:debug])
+          debug_progress(msg: "Loop.run start request=#{request[0, 240]}", debug: opts[:debug])
           TurnFinalizer.enter_user_path! if defined?(TurnFinalizer)
           engine = active_engine
           local  = local_engine?(engine: engine)
@@ -2003,21 +2056,22 @@ module PWN
           end
           Thread.current[:pwn_request_intent] = intent
           Thread.current[:pwn_extinguished] = {}
+          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)
 
           cheap = opts[:force_tools] != true && %i[greeting howto recall].include?(intent)
 
-          # Greeting / light smalltalk: deterministic ack - no weather echo, no tools,
-          # no PromptBuilder, no Registry.
           if intent == :greeting && opts[:force_tools] != true
+            debug_progress(msg: 'path=greeting', debug: opts[:debug])
+            quiet_debug_tui!(debug: opts[:debug], reason: 'greeting')
             return answer_greeting(
               request: request,
               session_id: session_id
             )
           end
 
-          # Thin system prompt only for remaining cheap paths (howto/recall/statement/question).
+          # Thin system prompt only for remaining cheap paths (howto/recall).
           if cheap
             system_role_content = opts[:system_role_content]
             if system_role_content.nil? || system_role_content.to_s.empty?
@@ -2028,16 +2082,18 @@ module PWN
               )
               opts[:system_role_content] = system_role_content
             end
-            # How-to: never enter plan_first / task recon / tool thrash.
             if intent == :howto
+              debug_progress(msg: 'path=howto', debug: opts[:debug])
+              quiet_debug_tui!(debug: opts[:debug], reason: 'howto')
               return answer_howto(
                 request: request,
                 session_id: session_id,
                 system_role_content: system_role_content
               )
             end
-            # Pure prior-turn / vague memory recall: one cheap path, no plan_first.
             if intent == :recall
+              debug_progress(msg: 'path=recall', debug: opts[:debug])
+              quiet_debug_tui!(debug: opts[:debug], reason: 'recall')
               return answer_recall(
                 request: request,
                 session_id: session_id,
@@ -2088,8 +2144,10 @@ module PWN
           messages << { role: 'user', content: request }
           append_session(session_id: session_id, role: 'user', content: request)
 
-          # Every request gets a task compass.
-          task_summary_plan!(state: ts_state, request: request, on_tool: on_tool) if defined?(TaskSummarizer)
+          trivia = world_knowledge?(request: request)
+          # Every host-work request gets a task compass. Trivia does not —
+          # inventing English tasks there keeps the model from emitting a final.
+          task_summary_plan!(state: ts_state, request: request, on_tool: on_tool) if defined?(TaskSummarizer) && !trivia
           # Re-bind tools from English plan so task list is the sole driver of
           # tool exposure/ranking (Registry keyword router + CORE).
           if ts_state.is_a?(Hash) && defined?(TaskSummarizer) && TaskSummarizer.respond_to?(:relevance_query)
@@ -2103,14 +2161,13 @@ module PWN
               )
             end
           end
-          # English-task-as-primary: inject tangible tasks only for autonomous goals.
-          inject_task_focus!(messages: messages, state: ts_state, force: true, request: request)
+          # English-task-as-primary: inject tangible tasks only for host work.
+          inject_task_focus!(messages: messages, state: ts_state, force: true, request: request) unless trivia
           predicted = nil
           Thread.current[:pwn_plan_predicted] = nil
           cal_state = calibration_state
           force_plan = cal_state[:force_plan]
-          # Skip plan_first only for remaining cheap intents.
-          skip_plan = %i[howto recall greeting].include?(intent)
+          skip_plan = %i[howto recall greeting].include?(intent) || trivia
           if !skip_plan && (force_plan || agent_flag(key: :plan_first, default: local) || budget_exhaustion_hot?) && !Array(tools).empty?
             predicted = plan_first(messages: messages, request: request, ts_state: ts_state)
             # P22 — prefer explicit return; fall back to thread stash
@@ -2129,7 +2186,7 @@ module PWN
                 )
               end
             end
-            inject_task_focus!(messages: messages, state: ts_state, force: true, request: request)
+            inject_task_focus!(messages: messages, state: ts_state, force: true, request: request) unless trivia
           end
           if budget_exhaustion_hot?
             english_open = defined?(TaskSummarizer) && TaskSummarizer.respond_to?(:plan_open?) &&
@@ -2166,7 +2223,7 @@ module PWN
             compact_history!(messages: messages) if local
             # English-task-as-primary: when plan_idx advanced, tell the model
             # which plain-English task is active before the next tool batch.
-            inject_task_focus!(messages: messages, state: ts_state, request: request)
+            inject_task_focus!(messages: messages, state: ts_state, request: request) unless trivia
 
             # P17 — on the final iteration, strip tools and demand a plain-text
             # answer. Without this the model happily emits one more tool_calls
@@ -2224,6 +2281,7 @@ module PWN
             msg = call_engine(messages: messages, tools: last_iter ? nil : tools, ts_state: ts_state)
             if msg.nil?
               task_summary_flush!(state: ts_state, on_tool: on_tool)
+              quiet_debug_tui!(reason: 'engine_empty')
               return '[pwn-ai] engine returned no message'
             end
 
@@ -2293,6 +2351,8 @@ module PWN
                 }
                 next
               end
+              debug_progress(msg: "final accepted chars=#{text.to_s.length}")
+              quiet_debug_tui!(reason: 'final')
               append_session(session_id: session_id, role: 'assistant', content: text)
               Learning.auto_introspect(session_id: session_id, request: request, final: text, predicted: predicted, plan: ts_state && ts_state[:plan], ts_state: ts_state) if defined?(Learning) && should_auto_introspect?(local: local, turn_fails: turn_fails, iter: i)
               maybe_finish_policy(session_id: session_id, proxy_ok: true, ts_state: ts_state)
@@ -2329,6 +2389,7 @@ module PWN
               else
                 raw = Dispatch.call(tool_call: tc)
               end
+              debug_progress(msg: "dispatch #{name} ok_len=#{raw.to_s.length}")
               tele    = record_metrics(name: name, started: started, raw: raw, args: args, session_id: session_id, engine: engine, ts_state: ts_state)
               result  = Result.condition(content: raw, entry: entry)
 
@@ -2385,6 +2446,8 @@ module PWN
           # failure (previously we only Mistakes.record'd and returned a bare
           # string — no session row, no judge, no hindsight).
           final_msg = '[pwn-ai] iteration budget exhausted'
+          debug_progress(msg: 'final budget_exhausted')
+          quiet_debug_tui!(reason: 'budget_exhausted')
           if defined?(Mistakes)
             Mistakes.record(
               tool: 'agent_loop',

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

@@ -117,6 +117,9 @@ module PWN
               RECENT TURNS block or one memory_recall — never a multi-tool plan.
               Pure greetings / light smalltalk short-circuit to a fixed ack — never
               echo weather or invent social filler ("noted, cloudy out there").
+              World-knowledge questions (what color is X) may be answered as a
+              text final with no tools. Tools stay available; do not invent a
+              host-work plan for them.
               Do not treat process_sop_* or operator_pref_* memory about code
               hygiene as the current user goal unless they asked to change code.
           PROMPT

data/lib/pwn/ai/anthropic.rb

@@ -490,122 +490,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Anthropic.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Admin Usage API (organizations/usage_report/messages) yields tokens
-      # used; organizations/rate_limits yields the configured ceiling so the
-      # PS1 can show a percent. Individual accounts without an Admin key
-      # return {available:false}. Never prompts for credentials.
-      public_class_method def self.get_plan_usage(opts = {})
-        timeout = opts[:timeout] || 8
-        return { available: false, engine: :anthropic } unless plan_usage_credentials?
-
-        now = Time.now.utc
-        start_of_month = Time.utc(now.year, now.month, 1)
-        report = parse_plan_usage_json(
-          raw: anthropic_rest_call(
-            rest_call: 'organizations/usage_report/messages',
-            params: {
-              starting_at: start_of_month.strftime('%Y-%m-%dT00:00:00Z'),
-              ending_at: now.strftime('%Y-%m-%dT%H:%M:%SZ'),
-              bucket_width: '1d'
-            },
-            timeout: timeout,
-            spinner: false,
-            non_interactive: true
-          )
-        )
-        used_tokens = sum_usage_tokens(report: report)
-
-        limits = parse_plan_usage_json(
-          raw: anthropic_rest_call(
-            rest_call: 'organizations/rate_limits',
-            timeout: timeout,
-            spinner: false,
-            non_interactive: true
-          )
-        )
-        limit_tokens = first_rate_limit(limits: limits)
-
-        normalized = PWN::AI.normalize_plan_usage(
-          used: used_tokens,
-          limit: limit_tokens,
-          source: 'organizations/usage_report',
-          engine: :anthropic
-        )
-        return normalized if normalized[:available]
-
-        { available: false, engine: :anthropic }
-      rescue StandardError
-        { available: false, engine: :anthropic }
-      end
-
-      private_class_method def self.plan_usage_credentials?
-        engine = PWN::Env.dig(:ai, :anthropic) || {}
-        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
-        real_config_value?(value: engine[:key]) ||
-          real_config_value?(value: oauth[:bearer_token]) ||
-          real_config_value?(value: oauth[:refresh_token])
-      end
-
-      private_class_method def self.parse_plan_usage_json(opts = {})
-        raw = opts[:raw]
-        return nil if raw.nil?
-
-        parsed = JSON.parse(raw.to_s, symbolize_names: true)
-        parsed.is_a?(Hash) ? parsed : nil
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-
-      private_class_method def self.sum_usage_tokens(opts = {})
-        report = opts[:report]
-        return nil unless report.is_a?(Hash)
-
-        buckets = report[:data] || report[:usage] || []
-        total = 0
-        Array(buckets).each do |bucket|
-          next unless bucket.is_a?(Hash)
-
-          results = bucket[:results] || bucket[:usage] || [bucket]
-          Array(results).each do |row|
-            next unless row.is_a?(Hash)
-
-            %i[
-              uncached_input_tokens
-              input_tokens
-              cache_read_input_tokens
-              cache_creation_input_tokens
-              output_tokens
-            ].each { |k| total += row[k].to_i }
-          end
-        end
-        total.positive? ? total : nil
-      end
-
-      private_class_method def self.first_rate_limit(opts = {})
-        limits = opts[:limits]
-        return nil unless limits.is_a?(Hash)
-
-        Array(limits[:data]).each do |group|
-          next unless group.is_a?(Hash)
-
-          Array(group[:limits]).each do |lim|
-            next unless lim.is_a?(Hash)
-
-            type = lim[:type].to_s
-            next unless type.match?(/tokens_per|input_tokens|output_tokens/)
-
-            v = lim[:value].to_f
-            return v if v.positive?
-          end
-        end
-        nil
-      end
-
       # ----------------------------------------------------------------------
       # Native tool-calling adapter for PWN::AI::Agent::Loop.
       #
@@ -960,8 +844,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           # One-time Claude Pro/Max OAuth enrollment (PKCE paste flow):
           bearer = #{self}.obtain_oauth_bearer_token
           # Subsequent runs silently refresh via ai.anthropic.oauth.refresh_token

data/lib/pwn/ai/gemini.rb

@@ -114,19 +114,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Gemini.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Gemini Generative Language has no subscription-usage endpoint that
-      # returns used-vs-limit for an API key. Cached-miss / unavailable so
-      # the PS1 shows ∞ unless the operator later injects used/limit.
-      public_class_method def self.get_plan_usage(opts = {})
-        _timeout = opts[:timeout] || 8
-        { available: false, engine: :gemini }
-      end
-
       # ----------------------------------------------------------------------
       # Native tool-calling adapter for PWN::AI::Agent::Loop.
       #
@@ -449,8 +436,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Gemini',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:gemini][:model])',

data/lib/pwn/ai/grok.rb

@@ -505,162 +505,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Grok.get_plan_usage(
-      #   timeout: 'optional - seconds (default 8)'
-      # )
-      #
-      # Subscription / team usage for the PS1 percent suffix.
-      # GET /v1/api-key yields team_id; then billing preview /
-      # spending-limits / prepaid balance compute used vs limit.
-      # GET /v1/me is also tried (OAuth personal-team payload).
-      public_class_method def self.get_plan_usage(opts = {})
-        timeout = opts[:timeout] || 8
-        return { available: false, engine: :grok } unless plan_usage_credentials?
-
-        me = parse_plan_usage_json(
-          raw: grok_rest_call(rest_call: 'me', timeout: timeout, spinner: false, quiet: true, non_interactive: true)
-        )
-        if me.is_a?(Hash)
-          used = first_numeric(src: me, keys: %i[used usage spend spent used_usd usage_usd])
-          limit = first_numeric(src: me, keys: %i[limit quota allowance hard_limit spending_limit])
-          normalized = PWN::AI.normalize_plan_usage(
-            used: used,
-            limit: limit,
-            source: 'me',
-            engine: :grok
-          )
-          return normalized if normalized[:available]
-        end
-
-        key_info = parse_plan_usage_json(
-          raw: grok_rest_call(rest_call: 'api-key', timeout: timeout, spinner: false, quiet: true, non_interactive: true)
-        )
-        team_id = key_info.is_a?(Hash) ? key_info[:team_id] : nil
-        team_id ||= me.is_a?(Hash) ? (me[:team_id] || me.dig(:team, :id)) : nil
-
-        if team_id.to_s.strip != ''
-          preview = parse_plan_usage_json(
-            raw: grok_rest_call(
-              rest_call: "billing/teams/#{team_id}/postpaid/invoice/preview",
-              timeout: timeout,
-              spinner: false,
-              quiet: true,
-              non_interactive: true
-            )
-          )
-          limits = parse_plan_usage_json(
-            raw: grok_rest_call(
-              rest_call: "billing/teams/#{team_id}/postpaid/spending-limits",
-              timeout: timeout,
-              spinner: false,
-              quiet: true,
-              non_interactive: true
-            )
-          )
-          balance = parse_plan_usage_json(
-            raw: grok_rest_call(
-              rest_call: "billing/teams/#{team_id}/prepaid/balance",
-              timeout: timeout,
-              spinner: false,
-              quiet: true,
-              non_interactive: true
-            )
-          )
-
-          used = nil
-          limit = nil
-          if preview.is_a?(Hash)
-            core = preview[:coreInvoice] || preview[:core_invoice] || {}
-            used_cents = cents_val(src: core, key: :prepaidCreditsUsed) ||
-                         cents_val(src: core, key: :prepaid_credits_used) ||
-                         core[:amountAfterVat] ||
-                         core[:amount_after_vat]
-            prepaid_cents = cents_val(src: core, key: :prepaidCredits) ||
-                            cents_val(src: core, key: :prepaid_credits)
-            spend_limit_cents = preview[:effectiveSpendingLimit] || preview[:effective_spending_limit]
-            used = to_f_or_nil(value: used_cents)
-            limit = to_f_or_nil(value: spend_limit_cents)
-            limit = to_f_or_nil(value: prepaid_cents).abs if (limit.nil? || limit <= 0) && prepaid_cents
-          end
-          used = to_f_or_nil(value: cents_val(src: balance, key: :total)).to_f.abs if (used.nil? || used <= 0) && balance.is_a?(Hash)
-          if (limit.nil? || limit <= 0) && limits.is_a?(Hash)
-            sl = limits[:spendingLimits] || limits[:spending_limits] || {}
-            limit = to_f_or_nil(value: cents_val(src: sl, key: :effectiveSl)) ||
-                    to_f_or_nil(value: cents_val(src: sl, key: :effectiveHardSl)) ||
-                    to_f_or_nil(value: cents_val(src: sl, key: :softSl))
-          end
-
-          normalized = PWN::AI.normalize_plan_usage(
-            used: used,
-            limit: limit,
-            source: 'billing/teams',
-            engine: :grok
-          )
-          return normalized if normalized[:available]
-        end
-
-        { available: false, engine: :grok }
-      rescue StandardError
-        { available: false, engine: :grok }
-      end
-
-      private_class_method def self.plan_usage_credentials?
-        engine = PWN::Env.dig(:ai, :grok) || {}
-        oauth = engine[:oauth].is_a?(Hash) ? engine[:oauth] : {}
-        real_config_value?(value: engine[:key]) ||
-          real_config_value?(value: oauth[:bearer_token]) ||
-          real_config_value?(value: oauth[:refresh_token])
-      end
-
-      private_class_method def self.parse_plan_usage_json(opts = {})
-        raw = opts[:raw]
-        return nil if raw.nil?
-
-        parsed = JSON.parse(raw.to_s, symbolize_names: true)
-        parsed.is_a?(Hash) ? parsed : nil
-      rescue JSON::ParserError, TypeError
-        nil
-      end
-
-      private_class_method def self.cents_val(opts = {})
-        src = opts[:src]
-        key = opts[:key]
-        return nil unless src.is_a?(Hash)
-
-        v = src[key]
-        return v[:val] if v.is_a?(Hash) && v.key?(:val)
-        return v['val'] if v.is_a?(Hash) && v.key?('val')
-
-        v
-      end
-
-      private_class_method def self.to_f_or_nil(opts = {})
-        val = opts.is_a?(Hash) && opts.key?(:value) ? opts[:value] : opts
-        return nil if val.nil?
-        return val.to_f if val.respond_to?(:to_f)
-
-        nil
-      rescue StandardError
-        nil
-      end
-
-      private_class_method def self.first_numeric(opts = {})
-        src = opts[:src]
-        keys = Array(opts[:keys])
-        return nil unless src.is_a?(Hash)
-
-        keys.each do |k|
-          v = src[k]
-          next if v.nil?
-          next if v.is_a?(Hash)
-
-          f = v.to_f
-          return f if f.positive? || v.to_s.strip.match?(/\A-?\d/)
-        end
-        nil
-      end
-
       # Supported Method Parameters::
       # response = PWN::AI::Grok.chat_with_tools(
       #   messages: 'required - full OpenAI-format messages array (system/user/assistant/tool)',
@@ -845,8 +689,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Grok',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:grok][:model])',

data/lib/pwn/ai/ollama.rb

@@ -370,16 +370,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # usage = PWN::AI::Ollama.get_plan_usage
-      #
-      # Local Ollama has no subscription / plan-usage endpoint. Always
-      # unavailable so the PS1 shows the infinity glyph.
-      public_class_method def self.get_plan_usage(opts = {})
-        _unused = opts
-        { available: false, engine: :ollama, unlimited: true }
-      end
-
       # Coerce OpenAI-wire message history into Ollama-native shapes before
       # POST /api/chat (or Open WebUI /ollama/api/chat):
       # - function.arguments must be a Hash/Array object, not a JSON string
@@ -652,8 +642,6 @@ module PWN
         puts "USAGE:
           models = #{self}.get_models
 
-          usage = #{self}.get_plan_usage
-
           response = #{self}.chat(
             request: 'required - message to Ollama',
             model: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:ollama][:model])',