pwn 0.5.761 → 0.5.762

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

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'pry'
+
+RSpec.describe 'Swarm solve' do
+  include_context 'pwn tmp sandbox'
+
+  before do
+    @workspace = File.join(@tmp, 'work')
+    FileUtils.mkdir_p(@workspace)
+    allow(PWN::AI::Agent::Swarm).to receive(:build_persona_prompt).and_return('fixture')
+    allow(PWN::AI::Agent::Swarm).to receive(:child_inbox).and_return({})
+    allow(PWN::AI::Agent::Swarm).to receive(:child_honesty).and_return({})
+    allow(PWN::AI::Agent::Swarm).to receive(:bus_append).and_return({})
+    @turns = []
+    @bad = false
+    @reject = false
+    @repair = false
+    allow(PWN::AI::Agent::Loop).to receive(:run) do |opts|
+      handoff = JSON.parse(opts[:system_role_content].split("SOLVE HANDOFF\n").last, symbolize_names: true)
+      @turns << [opts, handoff]
+      revision = handoff[:revision]
+      answer = case handoff[:phase]
+               when 'assess' then { requirements: ['The file contains the requested greeting'], risks: ['Wrong bytes'] }
+               when 'build'
+                 File.write(File.join(@workspace, 'greeting.txt'), @bad ? 'wrong' : 'hello')
+                 { artifacts: ['greeting.txt'], summary: 'candidate' }
+               when 'critique' then { revision: revision, objections: @reject ? ['Wrong output'] : [] }
+               when 'verify'
+                 { revision: revision, checks: [{ requirements: handoff[:requirements].keys, command: 'cat greeting.txt', stdout: 'hello' }] }
+               when 'integrate'
+                 @bad = false if @repair
+                 { revision: revision, decision: handoff[:evidence].all? { |row| row[:passed] } ? 'accept' : 'repair', repair: 'Write hello', summary: 'Greeting delivered' }
+               end
+      @hook&.call(handoff, answer)
+      JSON.generate(answer)
+    end
+  end
+
+  it 'executes the real nested Loop with a deterministic provider and host tool' do
+    allow(PWN::AI::Agent::Loop).to receive(:run).and_call_original
+    allow(PWN::AI::Agent::TaskSummarizer).to receive(:enabled?).and_return(false)
+    PWN::Env[:ai][:active] = :openai
+    PWN::Env[:ai][:openai] = { key: 'offline-fixture-key' }
+    @agent_cfg[:plan_first] = false
+    runtime = double('enclosing request route')
+    expect(runtime).not_to receive(:call)
+    Thread.current[:pwn_request_runtime] = runtime
+    allow(PWN::AI::OpenAI).to receive(:chat_with_tools) do |opts|
+      system = opts[:messages].find { |row| row[:role].to_s == 'system' }[:content]
+      handoff = JSON.parse(system.split("SOLVE HANDOFF\n").last, symbolize_names: true)
+      phase = handoff[:phase]
+      revision = handoff[:revision]
+      content = case phase
+                when 'assess' then { requirements: ['Greeting bytes'], risks: [] }
+                when 'build'
+                  next({ choices: [{ message: { role: 'assistant', content: nil, tool_calls: [{ id: 'write-greeting', type: 'function', function: { name: 'shell', arguments: JSON.generate(command: "printf hello > #{Shellwords.escape(File.join(@workspace, 'greeting.txt'))}", timeout: 5) } }] } }] }) unless File.exist?(File.join(@workspace, 'greeting.txt'))
+
+                  { artifacts: ['greeting.txt'], summary: 'written' }
+                when 'critique' then { revision: revision, objections: [] }
+                when 'verify' then { revision: revision, checks: [{ requirements: %w[R0 R1], command: 'cat greeting.txt', stdout: 'hello' }] }
+                when 'integrate' then { revision: revision, decision: 'accept', summary: 'Verified greeting' }
+                end
+      { choices: [{ message: { role: 'assistant', content: JSON.generate(content), tool_calls: [] } }] }
+    end
+    require 'timeout'
+    controller = PWN::Plugins::REPL::AISwarm::Controller.new(session_id: 'real-loop-fixture')
+    out = Timeout.timeout(15) do
+      controller.execute(line: '/swarm mission Write hello to greeting.txt', workspace: @workspace)
+      controller.send(:workers).last.value
+    end
+    expect(out).to include(status: 'accepted')
+    expect(out[:evidence].first).to include(stdout: 'hello', exitstatus: 0)
+  ensure
+    controller&.close
+    Thread.current[:pwn_request_runtime] = nil
+  end
+
+  it 'runs all roles with the unchanged request and accepts only executed evidence for the artifact revision' do
+    request = 'Write the greeting hello to greeting.txt'
+    states = []
+    out = PWN::AI::Agent::Swarm.solve(
+      request: request, workspace: @workspace, on_state: ->(state) { states << state },
+      on_tool: ->(*) { expect(states.last[:roles]['verifier']).to eq('checking') }
+    )
+    expect(out).to include(ok: true, status: 'accepted', request: request)
+    expect(@turns.map { |_, handoff| handoff[:phase] }).to eq(%w[assess build critique verify integrate])
+    expect(@turns.map { |opts, _| opts[:request] }.uniq).to eq([request])
+    expect(out[:evidence].first).to include(passed: true, stdout: 'hello', exitstatus: 0, revision: out[:revision])
+    expect(File.read(File.join(@workspace, 'greeting.txt'))).to eq('hello')
+    record = JSON.parse(File.read(out[:record_path]))
+    expect(record['revision']).to eq(out[:revision])
+    expect(record['evidence'].first['stdout']).to eq('hello')
+    expect(record['records']).to include(include('phase' => 'candidate', 'revision' => out[:revision], 'artifacts' => out[:artifacts]))
+    expect(out[:reply]).to include('R0', 'greeting.txt', out[:revision])
+  end
+
+  it 'routes the legacy slash entry to an executed solve, not a normal model request' do
+    pry = Pry.new
+    controller = nil
+    Dir.chdir(@workspace) do
+      expect(PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/swarm mission Write hello to greeting.txt', pry: pry)).to be(true)
+      controller = pry.config.pwn_ai_swarm
+      expect(controller).to be_a(PWN::Plugins::REPL::AISwarm::Controller)
+      controller.send(:workers).each(&:join)
+      expect(controller.snapshot[:jobs].last[:state]).to eq('accepted')
+    end
+  ensure
+    controller&.close
+  end
+
+  it 'binds identical artifact bytes to the specific objective and solve run' do
+    first = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace)
+    second = PWN::AI::Agent::Swarm.solve(request: 'Write hello and inspect it', workspace: @workspace)
+    expect(first[:artifacts]).to eq(second[:artifacts])
+    expect(first[:revision]).not_to eq(second[:revision])
+  end
+
+  it 'rejects failing checks even when integration claims accept' do
+    @bad = true
+    @hook = ->(handoff, answer) { answer[:decision] = 'accept' if handoff[:phase] == 'integrate' }
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, rounds: 1)
+    expect(out).to include(status: 'incomplete', ok: false)
+    expect(out[:evidence].first).to include(stdout: 'wrong', exitstatus: 0, passed: false)
+  end
+
+  it 'repairs through the sole writer and reruns verification against changed bytes' do
+    @bad = @repair = true
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace)
+    expect(out[:status]).to eq('accepted')
+    builds = @turns.select { |_, row| row[:phase] == 'build' }
+    expect(builds.length).to eq(2)
+    expect(builds.last.last[:repair]).to include(instruction: 'Write hello')
+    verifications = out[:records].select { |row| row[:phase] == 'verification' }
+    expect(verifications.map { |row| row[:evidence].first[:passed] }).to eq([false, true])
+    expect(out[:records].select { |row| row[:phase] == 'verify' }.map { |row| row[:revision] }.uniq.length).to eq(2)
+  end
+
+  it 'does not accept unresolved objections or missing requirement coverage' do
+    @reject = true
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, rounds: 1)
+    expect(out[:status]).to eq('incomplete')
+    expect(out[:objections]).to eq(['Wrong output'])
+    @reject = false
+    @hook = ->(handoff, answer) { answer[:checks].first[:requirements] = ['R1'] if handoff[:phase] == 'verify' }
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, rounds: 1)
+    expect(out).to include(status: 'incomplete', uncovered: ['R0'])
+  end
+
+  it 'invalidates evidence if the working artifact changes during integration' do
+    @hook = ->(handoff, _answer) { File.write(File.join(@workspace, 'greeting.txt'), 'changed') if handoff[:phase] == 'integrate' }
+    expect(PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, rounds: 1)[:status]).to eq('incomplete')
+  end
+
+  it 'rejects stale handoffs and copy-modifying verification' do
+    @hook = ->(handoff, answer) { answer[:revision] = 'old' if handoff[:phase] == 'critique' }
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace)
+    expect(out[:reply]).to include('stale revision')
+    @hook = lambda do |handoff, answer|
+      answer[:checks].first[:command] = 'printf wrong > greeting.txt; printf hello' if handoff[:phase] == 'verify'
+    end
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, rounds: 1)
+    expect(out[:status]).to eq('incomplete')
+    expect(File.read(File.join(@workspace, 'greeting.txt'))).to eq('hello')
+  end
+
+  it 'propagates steering to every later role and invalidates the previous candidate' do
+    control = PWN::AI::Agent::Solve::Control.new(input: StringIO.new, output: StringIO.new)
+    steered = false
+    @hook = lambda do |handoff, _answer|
+      if handoff[:phase] == 'integrate' && !steered
+        control.submit('Also verify exact bytes')
+        steered = true
+      end
+    end
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, steering: control)
+    expect(out[:status]).to eq('accepted')
+    expect(@turns.count { |_, row| row[:phase] == 'build' }).to eq(2)
+    expect(out[:requirements]).to include('S1' => 'Also verify exact bytes')
+    expect(@turns.last(4).all? { |opts, row| opts[:request] == 'Write hello' && row[:guidance] == ['Also verify exact bytes'] }).to be(true)
+  end
+
+  it 'cancels at a tool boundary without claiming completion or undoing work' do
+    control = PWN::AI::Agent::Solve::Control.new(input: StringIO.new, output: StringIO.new)
+    @hook = ->(handoff, _answer) { control.stop if handoff[:phase] == 'build' }
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace, steering: control)
+    expect(out[:status]).to eq('cancelled')
+    expect(File.read(File.join(@workspace, 'greeting.txt'))).to eq('hello')
+    expect(@turns.length).to eq(2)
+  end
+
+  it 'refuses unconfigured providers before any role or login runs' do
+    PWN::Env[:ai][:active] = :openai
+    PWN::Env[:ai][:openai] = {}
+    expect(PWN::AI::Agent::Loop).not_to receive(:run)
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace)
+    expect(out[:reply]).to include('configure openai credentials')
+  end
+
+  it 'enforces read-only reviewers at Dispatch even for invented tool calls' do
+    @hook = lambda do |handoff, _answer|
+      next unless handoff[:phase] == 'critique'
+
+      raw = PWN::AI::Agent::Dispatch.call(tool_call: { function: { name: 'shell', arguments: JSON.generate(command: "touch #{Shellwords.escape(File.join(@workspace, 'forbidden'))}") } })
+      expect(JSON.parse(raw)['success']).to be(false)
+    end
+    PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace)
+    expect(File).not_to exist(File.join(@workspace, 'forbidden'))
+    expect(Thread.current[:pwn_solve_tools]).to be_nil
+  end
+
+  it 'routes configured roles without switching defaults or modifying the global registry' do
+    PWN::AI::Agent::Swarm.spawn(name: 'solve_antagonist', role: 'Review', engine: :ollama, model: 'Exact/Reviewer:Tag')
+    registry = File.binread(PWN::AI::Agent::Swarm::AGENTS_FILE)
+    routes = []
+    @hook = ->(handoff, _answer) { routes << [handoff[:role], Thread.current[:pwn_swarm_engine], Thread.current[:pwn_swarm_model]] }
+    out = PWN::AI::Agent::Swarm.solve(request: 'Write hello', workspace: @workspace)
+    expect(out[:status]).to eq('accepted')
+    expect(routes.select { |row| row.first == 'antagonist' }).to all(eq(['antagonist', 'ollama', 'Exact/Reviewer:Tag']))
+    expect(File.binread(PWN::AI::Agent::Swarm::AGENTS_FILE)).to eq(registry)
+    expect(Thread.current[:pwn_swarm_model]).to be_nil
+  end
+
+  it 'never opens OAuth or a credential prompt during a solve provider call' do
+    Thread.current[:pwn_solve_tools] = []
+    { openai: [PWN::AI::OpenAI, :open_ai_rest_call], anthropic: [PWN::AI::Anthropic, :anthropic_rest_call], grok: [PWN::AI::Grok, :grok_rest_call] }.each do |engine, (provider, method)|
+      PWN::Env[:ai][engine] = {}
+      expect(provider).not_to receive(:obtain_oauth_bearer_token)
+      expect(PWN::Plugins::AuthenticationHelper).not_to receive(:mask_password)
+      expect(provider.send(method, rest_call: 'fixture')).to be_nil
+    end
+  ensure
+    Thread.current[:pwn_solve_tools] = nil
+  end
+
+  it 'pauses dispatch, resumes, and cancels through the coordinator command entry' do
+    entered = Queue.new
+    release = Queue.new
+    @hook = lambda do |handoff, _answer|
+      if handoff[:phase] == 'assess'
+        entered << true
+        release.pop
+      end
+    end
+    controller = PWN::Plugins::REPL::AISwarm::Controller.new(session_id: 'fixture')
+    job = controller.execute(line: '/swarm mission Write hello', workspace: @workspace)
+    entered.pop
+    expect(controller.execute(line: "/swarm pause #{job[:job_id]}")[:ok]).to be(true)
+    release << true
+    expect(controller.snapshot[:jobs].last[:state]).to eq('paused')
+    expect(controller.execute(line: '/swarm dm other write')[:ok]).to be(false)
+    expect(controller.execute(line: "/swarm steer #{job[:job_id]} Check bytes")[:ok]).to be(true)
+    expect(controller.execute(line: "/swarm resume #{job[:job_id]}")[:ok]).to be(true)
+    controller.execute(line: "/swarm cancel #{job[:job_id]}")
+    expect(controller.send(:workers).last.join(3)).not_to be_nil
+    expect(controller.snapshot[:jobs].last[:state]).to eq('cancelled')
+  ensure
+    release << true if release
+    controller&.close
+  end
+
+  it 'bounds a nonconverging role without inventing a final answer' do
+    control = PWN::AI::Agent::Solve::Control.new(input: StringIO.new, output: StringIO.new)
+    control.begin_turn
+    25.times { control.model(messages: []) { :fixture } }
+    expect { control.model(messages: []) { :unreachable } }.to raise_error(PWN::AI::Agent::Solve::Control::Limit)
+  end
+
+  it 'runs a draft-preserving Mission with team through the curses confirmation entry' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    controller = PWN::Plugins::REPL::AISwarm::Controller.new(session_id: 'fixture')
+    console.instance_variable_set(:@swarm, controller)
+    editor = console.instance_variable_get(:@editor)
+    editor.place('Write hello to greeting.txt', 4)
+    Dir.chdir(@workspace) do
+      console.handle("\u0007")
+      console.handle('v')
+      expect(controller.snapshot[:jobs]).to be_empty
+      expect(console.swarm_content.join).to include('mission')
+      console.handle("\r")
+      controller.send(:workers).each(&:join)
+      expect(controller.snapshot[:jobs].last).to include(state: 'accepted', team: include(roles: include('verifier' => 'done')))
+      console.handle("\e")
+      expect([editor.text, editor.cursor]).to eq(['Write hello to greeting.txt', 4])
+    end
+  ensure
+    controller&.close
+  end
+end

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

@@ -3,6 +3,42 @@
 require 'spec_helper'
 
 describe PWN::Plugins::REPL::AIConsoleCommands do
+  it 'advertises the renamed swarm surface in both completers' do
+    line = '/swarm '
+    labels = described_class.complete(line: line, cursor: line.length)[:items].map { |item| item[:label] }
+    legacy = PWN::Plugins::REPL.pwn_ai_complete_command(line: line)
+    [labels, legacy].each do |commands|
+      expect(commands).to include('mission', 'agents', 'dm')
+      expect(commands & %w[solve roster ask]).to be_empty
+    end
+  end
+
+  it 'sorts every command group and nested live provider by displayed label' do
+    values = %w[zulu alpha Alpha Bravo]
+    allow(PWN::Plugins::REPL).to receive(:pwn_ai_engines).and_return(values)
+    allow(PWN::Cron).to receive(:list).and_return(values.to_h { |value| [value, {}] })
+    allow(PWN::Memory).to receive(:load).and_return(values.to_h { |value| [value, {}] })
+    allow(PWN::Sessions).to receive(:list).and_return(values.map { |value| { id: value } })
+    stub_const('PWN::Skills', values.to_h { |value| [value, {}] })
+    allow(PWN::AI::MCP).to receive(:backends).and_return(values.map { |value| { name: value, tools: values } })
+    controller = double(completion_context: { agents: values, jobs: values.map { |value| { id: value } } })
+    allow(Dir).to receive(:exist?).with(PWN::AI::Agent::Swarm::SWARM_ROOT).and_return(true)
+    allow(Dir).to receive(:children).with(PWN::AI::Agent::Swarm::SWARM_ROOT).and_return(values)
+    lines = ['/'] + described_class::COMMANDS.map { |command| "#{command} " } +
+            ['/cron run ', '/memory recall ', '/sessions resume ', '/skills recall ', '/model list ', '/learning list ',
+             '/mcp use ', '/mcp call ', '/swarm dm ', '/swarm cancel ', '/swarm use ', '/swarm debate ']
+    lines.each do |line|
+      items = described_class.complete(line: line, cursor: line.length, swarm: controller)[:items]
+      labels = items.map { |item| item[:label] }
+      expect(labels).to eq(labels.sort_by { |label| [label.downcase, label] }), line
+      items.each { |item| expect(item[:text]).to eq(line == '/' ? item[:label] : "#{line}#{item[:label]}") }
+    end
+    line = '/swarm dm '
+    expect(described_class.complete(line: line, cursor: line.length, swarm: controller)[:items].first[:label]).to eq('Alpha')
+    values << 'aardvark'
+    expect(described_class.complete(line: line, cursor: line.length, swarm: controller)[:items].first[:label]).to eq('aardvark')
+  end
+
   it 'completes command names and parameter positions without a provider call' do
     allow(PWN::Plugins::REPL).to receive(:pwn_ai_engines).and_return(%w[openai grok])
     first = described_class.complete(line: '/mo', cursor: 3)
@@ -13,7 +49,7 @@ describe PWN::Plugins::REPL::AIConsoleCommands do
     expect(engines[:items].map { |item| item[:label] }).to include('openai', 'list')
     expect(engines[:items].map { |item| item[:text] }).to include('/model openai')
     verbose = described_class.complete(line: '/verbose ', cursor: 9)
-    expect(verbose[:items].map { |item| item[:label] }).to eq(%w[on off])
+    expect(verbose[:items].map { |item| item[:label] }).to eq(%w[off on])
     free = described_class.complete(line: '/steer keep ', cursor: 12)
     expect(free[:items]).to be_empty
     expect(free[:hint]).to include('free text')

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

@@ -17,7 +17,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     allow(PWN::AI::Agent::Loop).to receive(:may_finalize?).and_return(true)
   end
 
-  def launch(keys, &tick)
+  def launch(keys, startup_delay: 0, render_delay: 0, &tick)
     require 'pty'
     require 'timeout'
     master, input = PTY.open
@@ -28,7 +28,10 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     frame = []
     position = [0, 0]
     allow(window).to receive(:erase) { frame = [] }
-    allow(window).to receive(:refresh) { @rendered = frame.dup }
+    allow(window).to receive(:refresh) do
+      sleep render_delay if render_delay.positive? && !keys.empty?
+      @rendered = frame.dup
+    end
     @positions = []
     allow(window).to receive(:setpos) do |*coords|
       position = coords
@@ -42,6 +45,10 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     allow(window).to receive(:attron) { |_attribute, &block| block.call }
     screen = double('curses', init_screen: window, raw: nil, noecho: nil, curs_set: nil, close_screen: nil,
                               lines: 30, cols: 110, stdscr: window, has_colors?: false, resizeterm: nil)
+    allow(screen).to receive(:init_screen) do
+      sleep startup_delay if startup_delay.positive?
+      window
+    end
     @pry = Pry.new
     @pry.config.pwn_ai_session_id = PWN::Sessions.create(title: 'console')[:id]
     @pry.config.pwn_ai = true
@@ -258,28 +265,51 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     foreign&.join
   end
 
-  it 'leaves a provider blocked in native IO without waiting for that read to return' do
-    started = nil
-    allow(PWN::AI::Agent::Loop).to receive(:call_engine) do
-      Thread.handle_interrupt(Exception => :never) { sleep 8 }
-    end
-    keys = "what color is a lemon?\n".chars
-    cancelled = false
-    launch(keys) do
-      if !cancelled && @paint.any? { |row| row.include?('Elapsed') }
-        cancelled = true
-        # Time cancellation, not typing, cold artwork or mock screen painting.
-        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        "\u0003"
-      elsif @paint.any? { |row| row.include?('Request cancelled at a safe boundary') }
-        "\u0004"
-      else
-        Thread.pass
-        nil
+  [0, 3.1].each do |startup_delay|
+    it "leaves a provider blocked in native IO without waiting for that read to return (startup #{startup_delay}s)" do
+      entered = Queue.new
+      returned = Queue.new
+      provider = nil
+      started = nil
+      allow(PWN::AI::Agent::Loop).to receive(:call_engine) do
+        Thread.handle_interrupt(Exception => :never) do
+          entered << Thread.current
+          sleep 8
+          returned << true
+        end
       end
+      keys = "what color is a lemon?\n".chars
+      launched = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      launch(keys, startup_delay: startup_delay, render_delay: startup_delay.positive? ? 0.02 : 0) do
+        provider ||= entered.pop unless entered.empty?
+        if !started && provider&.status == 'sleep'
+          # Elapsed is painted before call_engine: it is not a provider barrier.
+          # Time from delivered Ctrl+C, excluding startup and per-key rendering.
+          started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          "\u0003"
+        elsif @paint.any? { |row| row.include?('Request cancelled at a safe boundary') }
+          "\u0004"
+        else
+          Thread.pass
+          nil
+        end
+      end
+      expect(started).not_to be_nil
+      expect(started - launched).to be >= startup_delay
+      expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 3
+      expect(returned).to be_empty
+    ensure
+      # Cancellation deliberately abandons masked IO. Release this fixture only
+      # after measuring return, then reap it before RSpec removes its mocks.
+      provider ||= entered.pop unless entered.empty?
+      begin
+        provider&.wakeup if provider&.alive?
+      rescue ThreadError
+        nil # The provider exited between alive? and wakeup.
+      end
+      provider&.join(2)
+      expect(provider).not_to be_alive if provider
     end
-    expect(started).not_to be_nil
-    expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 3
   end
 
   it 'forwards tool input, preserves completed evidence before steering, and locks settings while running' do
@@ -345,7 +375,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     console.seed_request_history
     '/verbose '.each_char { |key| console.handle(key) }
     menu = console.instance_variable_get(:@menu)
-    expect(menu.map { |item| item[:label] }).to eq(%w[on off])
+    expect(menu.map { |item| item[:label] }).to eq(%w[off on])
     draft = [editor.text.dup, editor.cursor]
     console.handle(:up)
     expect(console.instance_variable_get(:@menu_index)).to eq(1)
@@ -377,7 +407,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     '/verbose '.each_char { |key| console.handle(key) }
     console.handle(:down)
     console.handle("\t")
-    expect(editor.text.strip).to eq('/verbose off')
+    expect(editor.text.strip).to eq('/verbose on')
     console.handle("\u0015")
     '/verbose '.each_char { |key| console.handle(key) }
     console.handle(:up)
@@ -1490,7 +1520,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
   it 'keeps slash parameter completion live across spaces and clears stale menus on submit' do
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
     '/verbose '.chars.each { |key| console.handle(key) }
-    expect(console.instance_variable_get(:@menu).map { |item| item[:label] }).to eq(%w[on off])
+    expect(console.instance_variable_get(:@menu).map { |item| item[:label] }).to eq(%w[off on])
     console.handle('o')
     console.handle('f')
     console.handle('f')

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

@@ -5,9 +5,69 @@ require 'spec_helper'
 describe PWN::Plugins::REPL::AISwarm::Controller do
   include_context 'pwn tmp sandbox'
 
+  it 'routes renamed commands and missing arguments through both console entry points' do
+    allow(PWN::AI::Agent::Swarm).to receive(:personas).and_return(scout: { role: 'Inspect' })
+    allow(PWN::AI::Agent::Swarm).to receive(:create).and_return(swarm_id: 'fixture')
+    allow(PWN::AI::Agent::Swarm).to receive(:ask).and_return(reply: 'Direct reply')
+    pry = Pry.new
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: pry, input: StringIO.new, curses: nil, getch: nil)
+    controller = described_class.new(session_id: 'fixture')
+    console.instance_variable_set(:@swarm, controller)
+    pry.config.pwn_ai_swarm = controller
+    ['/swarm mission', '/swarm dm', '/swarm dm scout'].each do |line|
+      usage = line.include?('mission') ? 'usage: mission REQUEST' : 'usage: dm NAME REQUEST'
+      console.submit(line)
+      expect(console.instance_variable_get(:@timeline).last[1]).to include(usage)
+      expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: line, pry: pry) }.to output(/#{usage}/).to_stdout
+    end
+    expect(controller.snapshot[:jobs]).to be_empty
+    %w[solve roster ask].each do |old|
+      expect(controller.execute(line: "/swarm #{old}")[:error]).to eq("unknown /swarm command: #{old}")
+    end
+    console.submit('/swarm agents')
+    expect(console.instance_variable_get(:@timeline).last[1]).to include('scout')
+    expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/swarm agents', pry: pry) }.to output(/scout/).to_stdout
+    expect { PWN::Plugins::REPL.pwn_ai_dispatch_slash!(request: '/swarm dm scout inspect', pry: pry) }.to output(/queued/).to_stdout
+    controller.send(:workers).each(&:join)
+    expect(controller.snapshot[:jobs].last).to include(command: 'dm', result: 'Direct reply')
+  ensure
+    controller&.close
+  end
+
+  it 'rejects a mission without an original request before starting work' do
+    controller = described_class.new(session_id: 'fixture')
+    expect(PWN::AI::Agent::Swarm).not_to receive(:create)
+    expect(controller.execute(line: '/swarm mission')).to include(ok: false, error: 'usage: mission REQUEST')
+  ensure
+    controller&.close
+  end
+
+  it 'returns visible errors for malformed commands and synchronous backend failures' do
+    controller = described_class.new(session_id: 'fixture')
+    expect(controller.execute(line: '/swarm pause absent')).to include(ok: false, error: 'job not found')
+  ensure
+    controller&.close
+  end
+
+  it 'preserves solve request bytes and exposes real team state and incomplete outcomes' do
+    request = "Write  'hello'\nthen verify --literal"
+    allow(PWN::AI::Agent::Swarm).to receive(:solve) do |opts|
+      expect(opts[:request]).to eq(request)
+      expect(opts[:steering]).to be_a(PWN::AI::Agent::Solve::Control)
+      opts[:on_state].call(roles: { protagonist: 'build', antagonist: 'done', verifier: 'waiting', integrator: 'waiting' })
+      { status: 'incomplete', reply: 'INCOMPLETE: missing check' }
+    end
+    controller = described_class.new(session_id: 'fixture')
+    controller.execute(line: "/swarm mission #{request}")
+    controller.send(:workers).each(&:join)
+    expect(controller.snapshot[:jobs].first).to include(state: 'incomplete', team: include(roles: include(protagonist: 'build')))
+  ensure
+    controller&.close
+  end
+
   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)
+    expect(controller.execute(line: '/swarm dm 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
@@ -20,7 +80,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     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')
+    queued = controller.execute(line: '/swarm dm 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)
@@ -40,7 +100,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
       { reply: 'done' }
     end
     controller = described_class.new(session_id: 'fixture')
-    controller.execute(line: '/swarm ask scout inspect')
+    controller.execute(line: '/swarm dm scout inspect')
     owner, worker, local, marker = entered.pop
     expect(owner).to eq(worker)
     expect(local).to eq(:copied)
@@ -64,7 +124,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     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.execute(line: '/swarm dm broken inspect')
     controller.send(:workers).each(&:join)
     expect(controller.snapshot[:jobs].last).to include(state: 'failed', error: 'IOError: fixture unavailable')
   ensure
@@ -83,7 +143,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
       opts[:steering].checkpoint(messages: [])
     end
     controller = described_class.new(session_id: 'fixture')
-    job = controller.execute(line: '/swarm ask scout inspect')
+    job = controller.execute(line: '/swarm dm 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)
@@ -92,7 +152,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     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)
+    expect(controller.execute(line: '/swarm dm scout again')[:ok]).to be(false)
   ensure
     controller&.close
     foreign&.kill&.join
@@ -111,7 +171,7 @@ describe PWN::Plugins::REPL::AISwarm::Controller do
     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] })
+    queued = controller.execute(line: '/swarm dm 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')