pwn 0.5.685 → 0.5.686

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

@@ -633,12 +633,42 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       expect(described_class).not_to respond_to :request_kind
     end
 
-    it 'run does not short-circuit statement/question — they take the full tool loop' do
+    it 'does not invent a request type for world-knowledge; the full loop still accepts a text final' do
+      expect(described_class.world_knowledge?(request: 'what color is a passion fruit?')).to eq true
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).not_to match(/kind\.to_sym == :statement/)
-      expect(src).not_to match(/kind\.to_sym == :question/)
-      expect(src).not_to match(/Request type/)
-      expect(src).to match(/Every request gets a task compass/)
+      expect(src).not_to match(/request_kind/)
+      expect(src).not_to match(/world_knowledge\?.*?return answer_question/m)
+      expect(src).to match(/world_knowledge\?/)
+    end
+
+    it 'full tool loop accepts a text final for world-knowledge with no host-work tools' do
+      expect(described_class.world_knowledge?(request: 'what color is a passion fruit?')).to eq true
+      expect(described_class.send(:request_need, request: 'what color is a passion fruit?')).to eq :none
+      expect(
+        described_class.send(
+          :request_unsatisfied?,
+          request: 'what color is a passion fruit?',
+          messages: [{ role: 'assistant', content: 'Purple when ripe.', tool_calls: [] }]
+        )
+      ).to eq false
+      sess_tmp = Dir.mktmpdir('pwn-sess-fruit')
+      stub_const('PWN::Sessions::SESSIONS_DIR', sess_tmp)
+      sid = 'fruit_spec'
+      PWN::Sessions.create(id: sid, title: 'fruit')
+      allow(described_class).to receive(:should_auto_introspect?).and_return(false)
+      allow(described_class).to receive(:plan_first).and_raise('plan_first must not run on world-knowledge')
+      allow(PWN::AI::Agent::TaskSummarizer).to receive(:enabled?).and_return(false) if defined?(PWN::AI::Agent::TaskSummarizer)
+      allow(described_class).to receive(:call_engine).and_return(
+        { role: 'assistant', content: 'Purple when ripe.', tool_calls: [] }
+      )
+      out = described_class.run(
+        request: 'what color is a passion fruit?',
+        session_id: sid,
+        system_role_content: 'test system'
+      )
+      expect(out).to include('Purple when ripe.')
+    ensure
+      FileUtils.rm_rf(sess_tmp) if sess_tmp
     end
 
     it 'classifies pure prior-turn recall and vague memory cues as :recall' do
@@ -979,4 +1009,12 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
     expect(src).not_to include('return false if kind == :statement')
     expect(src).not_to include('return false if kind == :question && fails.zero?')
   end
+
+  it 'streams request-processing progress through PWN::Plugins::Log when debug is on' do
+    src = File.read(described_class.method(:run).source_location.first)
+    expect(src).to match(/PWN::Plugins::Log\.start_debug/)
+    expect(src).to match(/PWN::Plugins::Log\.progress/)
+    expect(src).to match(/quiet_debug_tui!/)
+    expect(described_class).to respond_to(:debug_on?)
+  end
 end # rubocop:enable Metrics/BlockLength

data/spec/lib/pwn/ai/anthropic_spec.rb

@@ -47,8 +47,8 @@ describe PWN::AI::Anthropic do
     end
   end
 
-  it 'exposes get_plan_usage for the PS1 subscription suffix' do
-    expect(described_class).to respond_to(:get_plan_usage)
+  it 'does not expose get_plan_usage' do
+    expect(described_class).not_to respond_to(:get_plan_usage)
   end
 
   describe 'Hermes prompt-cache breakpoint' do

data/spec/lib/pwn/ai/gemini_spec.rb

@@ -13,8 +13,8 @@ describe PWN::AI::Gemini do
     expect(help_response).to respond_to :help
   end
 
-  it 'exposes get_plan_usage for the PS1 subscription suffix' do
-    expect(described_class).to respond_to(:get_plan_usage)
+  it 'does not expose get_plan_usage' do
+    expect(described_class).not_to respond_to(:get_plan_usage)
   end
 
   it 'chat_with_tools honors PromptCache when prompt_cache is on' do

data/spec/lib/pwn/ai/grok_spec.rb

@@ -18,8 +18,8 @@ describe PWN::AI::Grok do
     expect(src).to match(/openai_wire_messages/)
   end
 
-  it 'exposes get_plan_usage for the PS1 subscription suffix' do
-    expect(described_class).to respond_to(:get_plan_usage)
+  it 'does not expose get_plan_usage' do
+    expect(described_class).not_to respond_to(:get_plan_usage)
   end
 
   it 'grok_rest_call swallows ReadTimeout quietly without ERROR: print' do

data/spec/lib/pwn/ai/ollama_spec.rb

@@ -321,12 +321,7 @@ describe PWN::AI::Ollama do
     expect(args[:command] || args['command']).to eq('id')
   end
 
-  it 'exposes get_plan_usage for the PS1 subscription suffix' do
-    expect(described_class).to respond_to(:get_plan_usage)
-  end
-  it 'marks local plan usage as unlimited so the PS1 shows infinity' do
-    usage = described_class.get_plan_usage
-    expect(usage[:available]).to be false
-    expect(usage[:unlimited]).to be true
+  it 'does not expose get_plan_usage' do
+    expect(described_class).not_to respond_to(:get_plan_usage)
   end
 end

data/spec/lib/pwn/ai/open_ai_spec.rb

@@ -18,29 +18,8 @@ describe PWN::AI::OpenAI do
     expect(src).to match(/openai_wire_messages/)
   end
 
-  it 'exposes get_plan_usage for the PS1 subscription suffix' do
-    expect(described_class).to respond_to(:get_plan_usage)
-  end
-  it 'computes a percentage from dashboard billing used vs hard limit' do
-    allow(described_class).to receive(:plan_usage_credentials?).and_return(true)
-    allow(described_class).to receive(:open_ai_rest_call) do |**kwargs|
-      case kwargs[:rest_call]
-      when 'dashboard/billing/subscription'
-        '{"hard_limit_usd":100.0}'
-      when 'dashboard/billing/usage'
-        '{"total_usage":1900}'
-      else
-        '{"error":"no"}'
-      end
-    end
-    usage = described_class.get_plan_usage
-    expect(usage[:available]).to be true
-    expect(usage[:percent]).to eq(19)
-  end
-
-  it 'returns unavailable when credentials are missing' do
-    allow(described_class).to receive(:plan_usage_credentials?).and_return(false)
-    expect(described_class.get_plan_usage[:available]).to be false
+  it 'does not expose get_plan_usage' do
+    expect(described_class).not_to respond_to(:get_plan_usage)
   end
 
   it 'open_ai_rest_call swallows ReadTimeout quietly without ERROR: print' do

data/spec/lib/pwn/ai/open_web_ui_spec.rb

@@ -300,12 +300,7 @@ describe PWN::AI::OpenWebUI do
     expect(args[:command] || args['command']).to eq('id')
   end
 
-  it 'exposes get_plan_usage for the PS1 subscription suffix' do
-    expect(described_class).to respond_to(:get_plan_usage)
-  end
-  it 'marks local plan usage as unlimited so the PS1 shows infinity' do
-    usage = described_class.get_plan_usage
-    expect(usage[:available]).to be false
-    expect(usage[:unlimited]).to be true
+  it 'does not expose get_plan_usage' do
+    expect(described_class).not_to respond_to(:get_plan_usage)
   end
 end

data/spec/lib/pwn/ai_spec.rb

@@ -8,26 +8,9 @@ describe PWN::AI do
     expect(help_response).not_to be_nil
   end
 
-  it 'normalizes used/limit into a clamped percentage' do
-    usage = described_class.normalize_plan_usage(used: 19, limit: 100, engine: :grok)
-    expect(usage[:available]).to be true
-    expect(usage[:percent]).to eq(19)
-  end
-
-  it 'returns the infinity glyph for ollama and openwebui' do
-    expect(described_class.plan_usage_glyph(engine: :ollama)).to eq("\u221E")
-    expect(described_class.plan_usage_glyph(engine: :openwebui)).to eq("\u221E")
-  end
-
-  it 'returns a percent glyph when usage data is available' do
-    glyph = described_class.plan_usage_glyph(
-      engine: :grok,
-      usage: { available: true, percent: 19 }
-    )
-    expect(glyph).to eq('19%')
-  end
-
-  it 'returns infinity when a hosted engine has no usage data' do
-    expect(described_class.plan_usage_glyph(engine: :gemini, usage: { available: false })).to eq("\u221E")
+  it 'does not expose plan-usage helpers' do
+    expect(described_class).not_to respond_to(:normalize_plan_usage)
+    expect(described_class).not_to respond_to(:plan_usage)
+    expect(described_class).not_to respond_to(:plan_usage_glyph)
   end
 end

data/spec/lib/pwn/plugins/log_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
+require 'stringio'
 
 describe PWN::Plugins::Log do
   it 'should display information for authors' do
@@ -12,4 +13,142 @@ describe PWN::Plugins::Log do
     help_response = PWN::Plugins::Log
     expect(help_response).to respond_to :help
   end
+
+  describe 'pwn-ai debug session' do
+    after do
+      PWN::Plugins::Log.stop_debug if PWN::Plugins::Log.respond_to?(:stop_debug)
+    end
+
+    it 'starts a /tmp/pwn-ai-DEBUG-TIMESTAMP.log and tees progress to TUI + file' do
+      expect(PWN::Plugins::Log).to respond_to(:start_debug)
+      expect(PWN::Plugins::Log).to respond_to(:stop_debug)
+      expect(PWN::Plugins::Log).to respond_to(:progress)
+      expect(PWN::Plugins::Log).to respond_to(:debug_enabled?)
+      expect(PWN::Plugins::Log).to respond_to(:debug_log_path)
+
+      tee = StringIO.new
+      path = PWN::Plugins::Log.start_debug(tee: tee, path: nil)
+      expect(path).to match(%r{\A/tmp/pwn-ai-DEBUG-.+\.log\z})
+      expect(File.file?(path)).to eq(true)
+      expect(PWN::Plugins::Log.debug_enabled?).to eq(true)
+      expect(PWN::Plugins::Log.debug_log_path).to eq(path)
+
+      ok = PWN::Plugins::Log.progress(msg: 'Loop.run start request=hi', which_self: PWN::AI::Agent::Loop)
+      expect(ok).to eq(true)
+      body = File.read(path)
+      expect(body).to include('Loop.run start request=hi')
+      expect(body).to include('PWN::AI::Agent::Loop')
+      expect(tee.string).to include('Loop.run start request=hi')
+
+      PWN::Plugins::Log.stop_debug
+      expect(PWN::Plugins::Log.debug_enabled?).to eq(false)
+      expect(PWN::Plugins::Log.progress(msg: 'after stop', which_self: self)).to eq(false)
+    end
+
+    it 'quiet_tui keeps writing the file but stops teeing to the TUI' do
+      expect(PWN::Plugins::Log).to respond_to(:quiet_tui!)
+      expect(PWN::Plugins::Log).to respond_to(:loud_tui!)
+      tee = StringIO.new
+      path = PWN::Plugins::Log.start_debug(tee: tee, path: "/tmp/pwn-ai-DEBUG-#{Process.pid}-quiet.log")
+      PWN::Plugins::Log.progress(msg: 'before-quiet', which_self: PWN::AI::Agent::Loop)
+      PWN::Plugins::Log.quiet_tui!
+      PWN::Plugins::Log.progress(msg: 'after-quiet', which_self: PWN::AI::Agent::Loop)
+      expect(tee.string).to include('before-quiet')
+      expect(tee.string).not_to include('after-quiet')
+      expect(File.read(path)).to include('after-quiet')
+      PWN::Plugins::Log.loud_tui!
+      PWN::Plugins::Log.progress(msg: 'after-loud', which_self: PWN::AI::Agent::Loop)
+      expect(tee.string).to include('after-loud')
+    end
+
+    it 'rolls the debug log to .N+1 when the file exceeds 1MB' do
+      stem = "/tmp/pwn-ai-DEBUG-#{Process.pid}-roll"
+      first = "#{stem}.1.log"
+      File.write(first, 'x' * (1_024_000 + 10))
+      path = PWN::Plugins::Log.start_debug(tee: StringIO.new, path: first)
+      expect(path).to eq(first)
+      PWN::Plugins::Log.progress(msg: 'overflow-line', which_self: PWN::AI::Agent::Loop)
+      second = "#{stem}.2.log"
+      expect(PWN::Plugins::Log.debug_log_path).to eq(second)
+      expect(File.file?(second)).to eq(true)
+      expect(File.read(second)).to include('overflow-line')
+    end
+
+    it 'traces PWN module calls into the same debug log while the session is on' do
+      path = PWN::Plugins::Log.start_debug(tee: StringIO.new, path: "/tmp/pwn-ai-DEBUG-#{Process.pid}-#{Time.now.to_i}.log")
+      PWN::AI::Agent::OpenGoal.current if defined?(PWN::AI::Agent::OpenGoal)
+      body = File.read(path)
+      expect(body).to match(/PWN::AI::Agent::OpenGoal/)
+    end
+
+    it 'does not raise when a traced module #name is a Symbol' do
+      probe = Module.new do
+        def self.name
+          :symname
+        end
+
+        def self.ping
+          :ok
+        end
+      end
+      stub_const('PWN::AI::Agent::SymNameProbe', probe)
+      PWN::Plugins::Log.start_debug(
+        tee: StringIO.new,
+        path: "/tmp/pwn-ai-DEBUG-#{Process.pid}-sym.log"
+      )
+      expect { PWN::AI::Agent::SymNameProbe.ping }.not_to raise_error
+    end
+
+    it 'logs the complete traced call including parameters' do
+      probe = Module.new do
+        def self.echo(opts = {})
+          opts[:msg]
+        end
+      end
+      stub_const('PWN::AI::Agent::ArgProbe', probe)
+      path = PWN::Plugins::Log.start_debug(
+        tee: StringIO.new,
+        path: "/tmp/pwn-ai-DEBUG-#{Process.pid}-args.log"
+      )
+      PWN::AI::Agent::ArgProbe.echo(
+        msg: 'hello-browser',
+        url: 'https://example.test/open',
+        password: 's3cret-token'
+      )
+      body = File.read(path)
+      expect(body).to include('PWN::AI::Agent::ArgProbe.echo')
+      expect(body).to include('hello-browser')
+      expect(body).to include('https://example.test/open')
+      expect(body).not_to include('s3cret-token')
+      expect(body).to match(/\[REDACTED\]/)
+    end
+
+    it 'redacts secret-shaped values even when the key is not a password name' do
+      probe = Module.new do
+        def self.echo(opts = {})
+          opts[:msg]
+        end
+      end
+      stub_const('PWN::AI::Agent::ArgProbe', probe)
+      path = PWN::Plugins::Log.start_debug(
+        tee: StringIO.new,
+        path: "/tmp/pwn-ai-DEBUG-#{Process.pid}-redact.log"
+      )
+      PWN::AI::Agent::ArgProbe.echo(
+        header: 'Bearer eyJhbGciOiJIUzI1NiJ9.aaa.bbb',
+        blob: "-----BEGIN PRIVATE KEY-----\nMIIB\n-----END PRIVATE KEY-----",
+        note: 'xai-abcdefghijklmnopqrstuvwxyz0123456789ABCD'
+      )
+      PWN::Plugins::Log.progress(
+        msg: 'Loop.run start request=use key sk-live-SUPERSECRET999',
+        which_self: PWN::AI::Agent::Loop
+      )
+      body = File.read(path)
+      expect(body).not_to include('eyJhbGciOiJIUzI1NiJ9')
+      expect(body).not_to include('BEGIN PRIVATE KEY')
+      expect(body).not_to include('xai-abcdefghijklmnopqrstuvwxyz0123456789ABCD')
+      expect(body).not_to include('sk-live-SUPERSECRET999')
+      expect(body).to match(/\[REDACTED\]/)
+    end
+  end
 end

data/spec/lib/pwn/plugins/repl_pwn_vault_spec.rb

@@ -132,3 +132,34 @@ describe 'pwn-vault Config RuntimeError retry' do
     end
   end
 end
+
+describe 'toggle-pwn-ai-debug' do
+  let(:repl_src) { File.read(PWN::Plugins::REPL.method(:add_commands).source_location.first) }
+  let(:block) do
+    start = repl_src.index("Pry::Commands.create_command 'toggle-pwn-ai-debug'")
+    stop = repl_src.index("Pry::Commands.create_command 'toggle-pwn-ai-speaks'")
+    repl_src[start...stop]
+  end
+
+  it 'starts and stops PWN::Plugins::Log debug session on the TUI toggle' do
+    expect(block).to include('PWN::Plugins::Log.start_debug')
+    expect(block).to include('PWN::Plugins::Log.stop_debug')
+    expect(block).to include('pwn-ai-DEBUG')
+  end
+end
+
+describe 'pwn-ai debug final answer placement' do
+  let(:repl_src) { File.read(PWN::Plugins::REPL.method(:add_commands).source_location.first) }
+  let(:hook) do
+    start = repl_src.index('Pry.config.hooks.add_hook(:after_read, :pwn_ai_hook)')
+    repl_src[start..]
+  end
+
+  it 'prints the green final after Loop.run and does not pp the session after it' do
+    expect(hook).to match(/Loop\.run\(/)
+    expect(hook).to match(/\\e\[32m\\002#\{final\}/)
+    native = hook[hook.index('final = PWN::AI::Agent::Loop.run')..hook.index("request.replace('nil')")]
+    expect(native).not_to match(/pp PWN::Sessions\.load/)
+    expect(native).to match(/\$stdout\.flush/)
+  end
+end

data/spec/lib/pwn/plugins/repl_spec.rb

@@ -13,10 +13,11 @@ describe PWN::Plugins::REPL do
     expect(help_response).to respond_to :help
   end
 
-  it 'appends plan usage after the token budget in the pwn.ai PS1' do
+  it 'does not append plan usage to the pwn.ai PS1' do
     src = File.read(described_class.method(:refresh_ps1_proc).source_location.first)
-    expect(src).to include('PWN::AI.plan_usage_glyph(engine: engine)')
-    expect(src).to include("\#{current_context_length}/\#{plan_usage_glyph}")
+    expect(src).not_to include('plan_usage_glyph')
+    expect(src).not_to include('PWN::AI.plan_usage')
+    expect(src).to include('current_context_length')
   end
 
   it 'formats compact token counts for the PS1 budget' do