pwn 0.5.749 → 0.5.751

data/spec/lib/pwn/plugins/repl/ai_console_usage_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::REPL::AIConsoleUsage do
+  it 'counts provider tokens once and estimates only configured USD rates' do
+    tracker = described_class::Tracker.new
+    tracker.record(engine: :openai, model: 'priced', usage: { input_tokens: 1_000_000, output_tokens: 1_000, input_tokens_details: { cached_tokens: 100 } }, rates: { input_per_million: 2, output_per_million: 8, cache_read_per_million: 1 })
+    priced = tracker.snapshot
+    expect(priced[:input_tokens]).to eq(1_000_000)
+    expect(priced[:cached_tokens]).to eq(100)
+    expect(priced[:total_tokens]).to eq(1_001_000)
+    expect(priced[:estimated_cost_usd]).to be_within(0.001).of((2 * 0.9999) + 0.0001 + 0.008)
+    tracker.record(engine: :openai, model: 'unknown', usage: { prompt_tokens: 10, completion_tokens: 5 })
+    mixed = tracker.snapshot
+    expect(mixed[:calls]).to eq(2)
+    expect(mixed[:cost_status]).to include('partial')
+    expect(described_class.estimate(usage: { input_tokens: 5 }, rates: nil)).to be_nil
+  end
+
+  it 'receives one Loop completion even when provider config is frozen' do
+    tracker = described_class::Tracker.new
+    Thread.current[:pwn_usage_observer] = tracker.method(:record)
+    PWN::AI::Agent::Loop.send(:publish_usage, response: { model: 'offline', usage: { input_tokens: 3, output_tokens: 4 } }, engine: :missing)
+    expect(tracker.snapshot[:total_tokens]).to eq(7)
+  ensure
+    Thread.current[:pwn_usage_observer] = nil
+  end
+end

data/spec/lib/pwn/plugins/repl/ai_swarm_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Plugins::REPL::AISwarm::Controller do
+  include_context 'pwn tmp sandbox'
+
+  it 'returns visible errors for malformed commands and synchronous backend failures' do
+    controller = described_class.new(session_id: 'fixture')
+    expect(controller.execute(line: '/swarm ask scout "unfinished')[:ok]).to be(false)
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_raise(IOError, 'fixture storage unavailable')
+    expect(controller.execute(line: '/swarm create fixture')).to include(ok: false, error: 'IOError: fixture storage unavailable')
+  ensure
+    controller&.close
+  end
+
+  it 'exposes roster metadata and retains outcomes without reviving finished jobs' do
+    allow(PWN::AI::Agent::Swarm).to receive(:personas).and_return(scout: { role: 'Inspect evidence', engine: 'ollama', model: 'fixture' })
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
+    allow(PWN::AI::Agent::Swarm).to receive(:ask).and_return(reply: 'Observed fixture result')
+    controller = described_class.new(session_id: 'fixture')
+    expect(controller.roster).to include(include(name: 'scout', role: 'Inspect evidence', engine: 'ollama', model: 'fixture'))
+    queued = controller.execute(line: '/swarm ask scout inspect')
+    controller.send(:workers).each(&:join)
+    expect(controller.snapshot[:jobs].first).to include(state: 'completed', result: 'Observed fixture result')
+    expect(controller.execute(line: "/swarm steer #{queued[:job_id]} again")[:ok]).to be(false)
+    expect(controller.execute(line: "/swarm cancel #{queued[:job_id]}")[:ok]).to be(false)
+    expect(controller.busy?).to be(false)
+  ensure
+    controller&.close
+  end
+
+  it 'owns model interrupts on the job thread and copies request-local routing' do
+    entered = Queue.new
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
+    Thread.current[:pwn_workspace_fixture] = :copied
+    allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
+      control = opts[:steering]
+      entered << [control.instance_variable_get(:@owner), Thread.current, Thread.current[:pwn_workspace_fixture], Thread.current[:pwn_steering_input]]
+      { reply: 'done' }
+    end
+    controller = described_class.new(session_id: 'fixture')
+    controller.execute(line: '/swarm ask scout inspect')
+    owner, worker, local, marker = entered.pop
+    expect(owner).to eq(worker)
+    expect(local).to eq(:copied)
+    expect(marker).to be_a(PWN::Plugins::REPL::AISwarm::JobControl)
+  ensure
+    controller&.close
+    Thread.current[:pwn_workspace_fixture] = nil
+  end
+
+  it 'passes prior speakers to debate, preserves literal flag-like missions, and retains failures' do
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
+    calls = []
+    allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
+      calls << opts
+      raise IOError, 'fixture unavailable' if opts[:name] == 'broken'
+
+      { reply: "reply from #{opts[:name]}" }
+    end
+    controller = described_class.new(session_id: 'fixture')
+    controller.execute(line: '/swarm debate scout,critic "--literal mission"')
+    controller.send(:workers).each(&:join)
+    expect(calls.first[:request]).to eq('--literal mission')
+    expect(calls.last[:request]).to include('reply from scout', '--literal mission')
+    controller.execute(line: '/swarm ask broken inspect')
+    controller.send(:workers).each(&:join)
+    expect(controller.snapshot[:jobs].last).to include(state: 'failed', error: 'IOError: fixture unavailable')
+  ensure
+    controller&.close
+  end
+
+  it 'cancels only its owned blocked model and cannot switch swarms while it runs' do
+    entered = Queue.new
+    foreign = Thread.new { sleep }
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
+    allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
+      opts[:steering].model(messages: []) do
+        entered << true
+        Queue.new.pop
+      end
+      opts[:steering].checkpoint(messages: [])
+    end
+    controller = described_class.new(session_id: 'fixture')
+    job = controller.execute(line: '/swarm ask scout inspect')
+    entered.pop
+    expect(controller.execute(line: '/swarm create other')[:ok]).to be(false)
+    expect(controller.execute(line: '/swarm use other')[:ok]).to be(false)
+    controller.execute(line: "/swarm cancel #{job[:job_id]}")
+    expect(controller.send(:workers).first.join(2)).not_to be_nil
+    expect(controller.snapshot[:jobs].first).to include(state: 'cancelled')
+    expect(foreign).to be_alive
+    controller.close
+    expect(controller.execute(line: '/swarm ask scout again')[:ok]).to be(false)
+  ensure
+    controller&.close
+    foreign&.kill&.join
+  end
+
+  it 'runs, steers, and cancels a persona through the existing Swarm API' do
+    entered = Queue.new
+    allow(PWN::AI::Agent::Swarm).to receive(:ask) do |opts|
+      entered << opts[:steering]
+      opts[:on_tool].call('shell', { command: 'true' }, '{"success":true}')
+      sleep 0.01 until opts[:steering].instance_variable_get(:@stopping)
+      raise PWN::Plugins::REPL::AISwarm::JobControl::Stopped, 'cancelled'
+    end
+    events = Queue.new
+    controller = described_class.new(session_id: 'console-session')
+    allow(PWN::AI::Agent::Swarm).to receive(:personas).and_return(scout: { role: 'scout' })
+    allow(PWN::AI::Agent::Swarm).to receive(:spawn).and_return(name: 'scout')
+    controller.execute(line: '/swarm spawn scout inspect evidence')
+    queued = controller.execute(line: '/swarm ask scout inspect the fixture', on_event: ->(type, text) { events << [type, text] })
+    steering = entered.pop
+    expect(queued[:ok]).to eq(true)
+    expect(controller.snapshot[:jobs].first[:state]).to eq('running')
+    controller.execute(line: "/swarm steer #{queued[:job_id]} stop the scan")
+    expect(steering.instance_variable_get(:@pending)).to include('stop the scan')
+    controller.execute(line: "/swarm cancel #{queued[:job_id]}")
+    sleep 0.05
+    expect(controller.snapshot[:jobs].first[:state]).to eq('cancelled')
+    expect(events.pop[0]).to eq(:tool)
+  ensure
+    controller&.close
+  end
+end

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

@@ -189,11 +189,13 @@ describe 'pwn-ai debug final answer placement' do
   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 include('PWN::Plugins::REPL.pwn_ai_run_steerable(')
+    wrapper = File.read(PWN::Plugins::REPL.method(:pwn_ai_run_steerable).source_location.first)
+    expect(wrapper).to include('control.with_reader { PWN::AI::Agent::Loop.run(')
     expect(hook).to match(/\\e\[32m#\{final\}/)
     expect(hook).not_to include('[0, 280]')
     expect(hook).not_to include('[0, 700]')
-    native_start = hook.index('final = PWN::AI::Agent::Loop.run')
+    native_start = hook.index('final = PWN::Plugins::REPL.pwn_ai_run_steerable')
     native_stop = hook.index("request.replace('nil')", native_start)
     native = hook[native_start..native_stop]
     expect(native).not_to include('\001')
@@ -208,7 +210,7 @@ describe 'pwn-ai debug final answer placement' do
   end
 
   it 'does not fall through to regex-ReAct after a native Loop.run error' do
-    native_start = hook.index('final = PWN::AI::Agent::Loop.run')
+    native_start = hook.index('final = PWN::Plugins::REPL.pwn_ai_run_steerable')
     rescue_at = hook.index('rescue StandardError', native_start)
     expect(rescue_at).not_to be_nil
     chunk = hook[rescue_at, 900]

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

@@ -3,6 +3,162 @@
 require 'spec_helper'
 
 describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
+  describe 'reasoning selection' do
+    include_context 'pwn tmp sandbox'
+
+    it 'persists system role before updating Env and preserves unrelated vault fields' do
+      previous_driver_opts = PWN::Env[:driver_opts]
+      path = File.join(@tmp, 'role.yaml')
+      key = Base64.strict_encode64('k' * 32)
+      iv = Base64.strict_encode64('i' * 16)
+      original = { ai: { active: 'openai', openai: { model: 'old', system_role_content: 'original', key: 'fixture' }, ollama: { model: 'keep' } }, unrelated: 'keep' }
+      PWN::Env[:ai] = Marshal.load(Marshal.dump(original[:ai]))
+      File.write(path, YAML.dump(original))
+      File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
+      PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
+      PWN::Env[:driver_opts] = { pwn_env_path: path, pwn_dec_path: "#{path}.decryptor" }
+      expect(described_class.pwn_ai_apply_system_role(engine: 'openai', content: "new role\nsecond line")).to eq(:saved)
+      expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq("new role\nsecond line")
+      expect(File.read(path)).not_to include('new role')
+      PWN::Plugins::Vault.decrypt(file: path, key: key, iv: iv)
+      original[:ai][:openai][:system_role_content] = "new role\nsecond line"
+      expect(YAML.load_file(path, symbolize_names: true)).to eq(original)
+      PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
+      expect(described_class.pwn_ai_apply_system_role(engine: 'openai', content: '')).to eq(:saved)
+      original[:ai][:openai][:system_role_content] = ''
+      expect(PWN::Plugins::Vault.dump(file: path, key: key, iv: iv)).to eq(original)
+    ensure
+      PWN::Env[:driver_opts] = previous_driver_opts
+    end
+
+    it 'leaves ciphertext and Env untouched when role encryption fails' do
+      previous_driver_opts = PWN::Env[:driver_opts]
+      path = File.join(@tmp, 'role.yaml')
+      key = Base64.strict_encode64('k' * 32)
+      iv = Base64.strict_encode64('i' * 16)
+      PWN::Env[:ai] = { active: 'openai', openai: { model: 'old', system_role_content: 'original' } }
+      File.write(path, YAML.dump(ai: PWN::Env[:ai]))
+      File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
+      PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
+      ciphertext = File.binread(path)
+      PWN::Env[:driver_opts] = { pwn_env_path: path, pwn_dec_path: "#{path}.decryptor" }
+      allow(PWN::Plugins::Vault).to receive(:encrypt).and_raise(IOError, 'fixture encryption failure')
+      expect { described_class.pwn_ai_apply_system_role(engine: 'openai', content: 'unsaved') }.to raise_error(/not saved/)
+      expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq('original')
+      expect(File.binread(path)).to eq(ciphertext)
+      expect(Dir.glob(File.join(@tmp, '.pwn-ai-selection*'))).to be_empty
+    ensure
+      PWN::Env[:driver_opts] = previous_driver_opts
+    end
+
+    it 'rejects role saves without a decryptor or after switching the active engine' do
+      previous_driver_opts = PWN::Env[:driver_opts]
+      PWN::Env[:driver_opts] = { pwn_env_path: File.join(@tmp, 'missing.yaml'), pwn_dec_path: File.join(@tmp, 'missing.decryptor') }
+      PWN::Env[:ai] = { active: 'openai', openai: { system_role_content: 'original' } }
+      expect { described_class.pwn_ai_apply_system_role(engine: 'openai', content: 'unsaved') }.to raise_error(/not saved/)
+      expect(PWN::Env.dig(:ai, :openai, :system_role_content)).to eq('original')
+      expect(described_class).not_to receive(:persist_ai_selection)
+      expect { described_class.pwn_ai_apply_system_role(engine: 'ollama', content: 'unsaved') }.to raise_error(/Active engine changed/)
+    ensure
+      PWN::Env[:driver_opts] = previous_driver_opts
+    end
+
+    it 'forwards explicit none through the agent rather than silently using provider defaults' do
+      PWN::Env[:ai] = { active: 'openai', openai: { model: 'gpt-5.5', reasoning_effort: 'none' } }
+      expect(PWN::AI::OpenAI).to receive(:chat_with_tools).with(hash_including(reasoning_effort: 'none', think: false)).and_return(choices: [{ message: { role: 'assistant', content: 'fixture' } }])
+      PWN::AI::Agent::Loop.send(:invoke_provider_chat, engine: :openai, messages: [], tools: [])
+    end
+
+    it 'forwards OpenAI effort through the agent into Chat Completions and Responses payloads' do
+      PWN::Env[:ai] = { active: 'openai', openai: { model: 'gpt-5', reasoning_effort: 'high' } }
+      expect(PWN::AI::OpenAI).to receive(:open_ai_rest_call).with(hash_including(rest_call: 'chat/completions', http_body: hash_including(reasoning_effort: 'high'))).and_return({ choices: [{ message: { role: 'assistant', content: 'offline fixture' } }] }.to_json)
+      PWN::AI::Agent::Loop.send(:invoke_provider_chat, engine: :openai, messages: [{ role: 'user', content: 'fixture' }], tools: [])
+      PWN::Env[:ai][:openai][:model] = 'gpt-6-astra'
+      expect(PWN::AI::OpenAI).to receive(:open_ai_rest_call).with(hash_including(rest_call: 'responses', http_body: hash_including(reasoning: { effort: 'high', summary: 'auto' }))).and_return({ output: [{ type: 'message', content: [{ type: 'output_text', text: 'offline fixture' }] }] }.to_json)
+      PWN::AI::Agent::Loop.send(:invoke_provider_chat, engine: :openai, messages: [{ role: 'user', content: 'fixture' }], tools: [])
+    end
+
+    it 'forwards the Grok effort through the agent into the HTTP payload' do
+      PWN::Env[:ai] = { active: 'grok', grok: { model: 'grok-4.6', reasoning_effort: 'high' } }
+      expect(PWN::AI::Grok).to receive(:grok_rest_call).with(hash_including(http_body: hash_including(model: 'grok-4.6', reasoning_effort: 'high'))).and_return({ choices: [{ message: { role: 'assistant', content: 'offline fixture' } }] }.to_json)
+      PWN::AI::Agent::Loop.send(:invoke_provider_chat, engine: :grok, messages: [{ role: 'user', content: 'fixture' }], tools: [])
+    end
+
+    it 'uses Enter for the current effort and permits cancellation in the legacy prompt' do
+      input = StringIO.new("\nq\n")
+      allow(input).to receive(:tty?).and_return(true)
+      previous = $stdin
+      $stdin = input
+      selection = { engine: 'grok', model: 'grok-4.6', efforts: %w[low medium high], default: 'high' }
+      expect(described_class.pwn_ai_prompt_reasoning(selection: selection)).to eq('high')
+      expect(described_class.pwn_ai_prompt_reasoning(selection: selection)).to be_nil
+    ensure
+      $stdin = previous
+    end
+
+    it 'does not offer effort controls for unsupported models' do
+      expect(described_class.pwn_ai_reasoning_selection(engine: 'grok', model: 'grok-4')[:efforts]).to eq([])
+      expect(described_class.pwn_ai_reasoning_selection(engine: 'openai', model: 'gpt-4o')[:efforts]).to eq([])
+      %w[anthropic gemini ollama openwebui].each do |engine|
+        expect(described_class.pwn_ai_reasoning_selection(engine: engine, model: 'fixture')[:efforts]).to eq([])
+      end
+    end
+
+    it 'cancels without changing any configuration or persisting' do
+      PWN::Env[:ai] = { active: 'ollama', ollama: { model: 'old' }, grok: { model: 'old', reasoning_effort: 'high' } }
+      before = Marshal.dump(PWN::Env[:ai])
+      expect(described_class).not_to receive(:persist_ai_selection)
+      described_class.pwn_ai_run_model(args: %w[grok grok-4.6], prompt: ->(_selection) {})
+      expect(Marshal.dump(PWN::Env[:ai])).to eq(before)
+    end
+
+    it 'skips effort prompts and catalogs for engines without effort support' do
+      PWN::Env[:ai] = { active: 'ollama', ollama: { model: 'old', think: false } }
+      allow(described_class).to receive(:persist_ai_selection).and_return(false)
+      expect(PWN::AI::OpenAI).not_to receive(:get_models)
+      prompt = double('prompt')
+      expect(prompt).not_to receive(:call)
+      described_class.pwn_ai_run_model(args: %w[ollama fixture], prompt: prompt)
+      expect(PWN::Env[:ai][:ollama]).to eq(model: 'fixture', think: false)
+    end
+
+    it 'merges reasoning and model into an encrypted sandbox vault without replacing other values' do
+      require 'yaml'
+      previous_driver_opts = PWN::Env[:driver_opts]
+      PWN::Env[:driver_opts] = previous_driver_opts.to_h.dup
+      path = File.join(@tmp, 'selection.yaml')
+      key = Base64.strict_encode64('k' * 32)
+      iv = Base64.strict_encode64('i' * 16)
+      original = { ai: { active: 'ollama', openai: { model: 'old', key: 'fixture', reasoning_effort: 'low', oauth: { account_id: 'fixture' } }, ollama: { model: 'keep' } }, unrelated: 'keep' }
+      File.write(path, YAML.dump(original))
+      File.write("#{path}.decryptor", YAML.dump(key: key, iv: iv))
+      PWN::Plugins::Vault.encrypt(file: path, key: key, iv: iv)
+      PWN::Env[:driver_opts][:pwn_env_path] = path
+      PWN::Env[:driver_opts][:pwn_dec_path] = "#{path}.decryptor"
+      expect(described_class.persist_ai_selection(engine: 'openai', model: 'gpt-6-astra', reasoning_effort: 'high')).to be(true)
+      expect(File.read(path)).not_to include('reasoning_effort')
+      PWN::Plugins::Vault.decrypt(file: path, key: key, iv: iv)
+      original[:ai][:active] = 'openai'
+      original[:ai][:openai].merge!(model: 'gpt-6-astra', reasoning_effort: 'high')
+      expect(YAML.load_file(path, symbolize_names: true)).to eq(original)
+    ensure
+      PWN::Env[:driver_opts] = previous_driver_opts
+    end
+
+    it 'offers catalog efforts before applying either model or effort' do
+      PWN::Env[:ai] = { active: 'ollama', ollama: { model: 'old' }, openai: { model: 'old', reasoning_effort: 'high' } }
+      allow(PWN::AI::OpenAI).to receive(:get_models).and_return(data: [{ id: 'gpt-6-astra', supported_reasoning_levels: [{ effort: 'low' }, { effort: 'high' }], default_reasoning_level: 'low' }])
+      allow(described_class).to receive(:persist_ai_selection).and_return(false)
+      described_class.pwn_ai_run_model(args: %w[openai gpt-6-astra], prompt: lambda { |selection|
+        expect(PWN::Env[:ai][:active]).to eq('ollama')
+        expect(selection).to include(efforts: %w[low high], default: 'high')
+        'low'
+      })
+      expect(PWN::Env[:ai]).to include(active: 'openai', openai: { model: 'gpt-6-astra', reasoning_effort: 'low' })
+      expect(described_class).to have_received(:persist_ai_selection).with(engine: 'openai', model: 'gpt-6-astra', reasoning_effort: 'low')
+    end
+  end
+
   def command_src
     [
       described_class,
@@ -193,6 +349,16 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
   end
 
   describe 'pwn-ai completion menus' do
+    it 'handles idle steering and empty steering locally without eval or a model call' do
+      pry = double('local pry')
+      expect(pry).not_to receive(:eval)
+      expect(PWN::AI::Agent::Loop).not_to receive(:run)
+      expect { expect(described_class.pwn_ai_dispatch_slash!(request: '/steer', pry: pry)).to be(true) }.to output(%r{Usage: /steer <instruction>}).to_stdout
+      expect { expect(described_class.pwn_ai_dispatch_slash!(request: '/steer stop', pry: pry)).to be(true) }.to output(/no active request/).to_stdout
+      expect(described_class.pwn_ai_complete(target: '/st', line: '/st')).to include('/steer')
+      expect { described_class.pwn_ai_dispatch_slash!(request: '/help', pry: pry) }.to output(%r{/steer <instruction>}).to_stdout
+    end
+
     it 'classifies leading slash as command, other slash as path, else ruby' do
       expect(described_class).to respond_to(:pwn_ai_complete_kind)
       expect(described_class.pwn_ai_complete_kind(line: '/cron')).to eq(:command)
@@ -207,7 +373,7 @@ describe PWN::Plugins::REPL do # rubocop:disable Metrics/BlockLength
       hits = described_class.pwn_ai_complete(target: '/sk', line: '/sk')
       expect(hits).to include('/skills')
       hits = described_class.pwn_ai_complete(target: '/', line: '/')
-      %w[/cron /skills /sessions /memory /debug /trace /back /help /model /learning /mcp].each do |cmd|
+      %w[/cron /skills /sessions /memory /debug /trace /back /help /model /learning /mcp /system-role].each do |cmd|
         expect(hits).to include(cmd)
       end
       hits = described_class.pwn_ai_complete(target: 'li', line: '/cron li')