pwn 0.5.760 → 0.5.762

data/lib/pwn/plugins/repl/ai.rb

@@ -249,7 +249,7 @@ module PWN
           end
         end
         PWN_AI_SLASH_COMMANDS = %w[
-          /back /cron /debug /delegate /help /learning /memory /mcp /model /sessions /skills /steer /system-role /trace
+          /back /cron /debug /delegate /help /learning /memory /mcp /model /sessions /skills /steer /swarm /system-role /trace
         ].freeze
 
         PWN_AI_SLASH_SUBCOMMANDS = {
@@ -261,6 +261,7 @@ module PWN
           '/memory' => %w[list recall remember forget clear],
           '/mcp' => %w[list backends use current connect disconnect ping tools call status help],
           '/model' => %w[list],
+          '/swarm' => %w[mission agents status create use spawn retire dm debate broadcast tail steer pause resume cancel help],
           '/sessions' => %w[list resume delete stats],
           '/skills' => %w[list recall],
           '/learning' => %w[list requeue]
@@ -524,6 +525,10 @@ module PWN
             args = tokens[1..]
             pi = opts[:pry]
             case cmd
+            when '/swarm'
+              pi.config.pwn_ai_swarm ||= AISwarm::Controller.new(session_id: pi.config.pwn_ai_session_id)
+              result = pi.config.pwn_ai_swarm.execute(line: request, on_event: ->(_type, text) { puts text })
+              puts(result[:usage] || result[:error] || result.inspect)
             when '/steer'
               puts(args.empty? ? '[pwn-ai] Usage: /steer <instruction>' : '[pwn-ai] /steer: no active request; submit a normal request instead')
             when '/help'

data/lib/pwn/plugins/repl/ai_console.rb

@@ -105,6 +105,8 @@ module PWN
 
         # Read a duplicated terminal rather than stdin, which belongs to tools.
         class Keyboard
+          attr_writer :interval
+
           KEYS = {
             "\e[A" => :up, "\e[B" => :down, "\e[C" => :right, "\e[D" => :left,
             "\eOA" => :up, "\eOB" => :down, "\eOC" => :right, "\eOD" => :left,
@@ -120,7 +122,7 @@ module PWN
           end
 
           def call
-            if @source.wait_readable(@buffer.empty? ? 0.04 : 0)
+            if @source.wait_readable(@buffer.empty? ? (@interval || 0.04) : 0)
               chunk = @source.read_nonblock(4096, exception: false)
               return :eof if chunk.nil? && @buffer.empty?
 
@@ -402,6 +404,7 @@ module PWN
               break if @leaving && !busy?
 
               draw
+              @getch.interval = @focus == :animation && %i[asteroids galaga frogger].include?(@banner_name) ? 0.01 : 0.04 if @getch.is_a?(Keyboard)
               handle(@getch.call)
             rescue Interrupt
               cancel
@@ -607,7 +610,7 @@ module PWN
               clear_view
             elsif line.match?(%r{\A/verbose(?:\s|$)})
               toggle_verbose(line)
-            elsif line.start_with?('/swarm') && %w[status tail steer cancel help roster].include?(line.split[1])
+            elsif line.start_with?('/swarm') && %w[status tail steer cancel pause resume help agents].include?(line.split[1])
               run_swarm(line)
             else
               add(:warning, 'Request running. Settings and new requests wait until idle. Use /steer, /input, /swarm status|steer|cancel, /clear, or /verbose.')
@@ -690,7 +693,7 @@ module PWN
 
             return clear_view if key == "\u000c"
 
-            if ["\u0007", "\u0013"].include?(key)
+            if key == "\u0013" || (key == "\u0007" && (@focus != :animation || @workspace))
               @workspace ? @workspace = nil : open_swarm
               return
             end
@@ -801,12 +804,22 @@ module PWN
           end
 
           def handle_animation(key)
-            if key == :paste_start
+            if key == "\u0007"
+              names = PWN::Banner.mini_names
+              @banner_name = names[(names.index(@banner_name).to_i + 1) % names.length]
+              @banner_frame_seconds = PWN::Banner.mini_frame_seconds(name: @banner_name)
+              @banner_started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              @banner_game = @banner_game_key = @banner_game_tick = nil
+            elsif key == :paste_start
               @focus = :mission
               @paste = true
               @banner_game&.controls
             elsif [:up, :down, :left, :right, ' '].include?(key)
+              return if %i[asteroids galaga frogger].include?(@banner_name) && @banner_game_frame&.dig(:state, :explosion).to_i.positive?
+
               @banner_game&.key(key)
+              # Paint a discrete control immediately, not after the next idle tick.
+              @banner_game_tick = nil if %i[asteroids galaga frogger].include?(@banner_name)
             elsif ["\r", "\n", "\e", :newline].include?(key)
               @focus = :mission
               @banner_game&.controls
@@ -1049,11 +1062,11 @@ module PWN
             usage = @usage.snapshot
             cost = usage[:estimated_cost_usd] ? format('$%.4f est.', usage[:estimated_cost_usd]) : usage[:cost_status]
             swarm = @swarm&.snapshot || {}
-            active = Array(swarm[:jobs]).count { |job| %w[queued running steering cancelling].include?(job[:state]) }
+            active = Array(swarm[:jobs]).count { |job| AISwarm::Controller::ACTIVE.include?(job[:state]) }
             ['REQUEST', state, "Elapsed #{elapsed}", "Completed tools #{@completed_tools}",
              "Events #{@event_count}", '', 'TOKENS', "#{usage[:input_tokens]} in · #{usage[:output_tokens]} out",
              "cached #{usage[:cached_tokens]} · calls #{usage[:calls]}", "Cost #{cost}",
-             '', 'SWARM', swarm[:swarm_id] || 'none', "#{active} active · ^G swarm",
+             '', 'SWARM', swarm[:swarm_id] || 'none', "#{active} active · ^S swarm",
              '', 'VIEW', @verbose ? 'verbose' : 'compact · /verbose', scroll_status,
              '', 'LAST TOOL', @last_tool || 'not observed']
           end
@@ -1226,6 +1239,7 @@ module PWN
             cadence = cells ? @banner_frame_seconds : PWN::Banner::MINI_FRAME_SECONDS
             frame = ((now - @banner_started) / cadence).floor % PWN::Banner::MINI_FRAME_COUNT
             return playable_banner(size, now) if cells && @focus == :animation
+            return automatic_banner(size, now) if cells && size >= 5 && %i[pacman galaga frogger].include?(@banner_name)
             return PWN::Banner.mini_cells(name: @banner_name, frame: frame, width: size, height: size, seed: @banner_seed, branding: false) if cells
 
             art = PWN::Banner.mini_frame(name: @banner_name, frame: frame, width: size, height: size, branding: false)
@@ -1235,6 +1249,24 @@ module PWN
             canvas
           end
 
+          def automatic_banner(size, now)
+            key = [@banner_session, @banner_name, size, @banner_seed]
+            if @banner_demo_key != key
+              @banner_demo_key = key
+              @banner_demo = PWN::Banner::MiniGame.new(name: @banner_name, width: size, height: size, seed: @banner_seed, demo: true)
+              @banner_demo.step
+              @banner_demo_tick = nil
+            end
+            tick = (now / @banner_frame_seconds).floor
+            if @banner_demo_tick != tick
+              # Advance one frame, never build 1800 or catch up after a modal.
+              @banner_demo_frame = @banner_demo.step
+              @banner_demo_cells = @banner_demo.cells(@banner_demo_frame)
+              @banner_demo_tick = tick
+            end
+            @banner_demo_cells
+          end
+
           def playable_banner(size, now)
             key = [@banner_session, @banner_name, size, @banner_seed]
             if @banner_game_key != key
@@ -1242,9 +1274,13 @@ module PWN
               @banner_game = PWN::Banner::MiniGame.new(name: @banner_name, width: size, height: size, seed: @banner_seed)
               @banner_game_tick = nil
             end
-            tick = (now / @banner_frame_seconds).floor
+            # Human Snake input needs a full reaction interval on its tiny board;
+            # decorative replay cadence is independent of player movement.
+            cadence = @banner_name == :snake ? 0.2 : @banner_frame_seconds
+            tick = (now / cadence).floor
             if @banner_game_tick != tick
-              @banner_game_cells = @banner_game.cells(@banner_game.step)
+              @banner_game_frame = @banner_game.step
+              @banner_game_cells = @banner_game.cells(@banner_game_frame)
               @banner_game_tick = tick
             end
             @banner_game_cells
@@ -1308,9 +1344,10 @@ module PWN
           def footer_text
             text = '/ menu · ^C=cancel · ^D=back · ^L=clear · ^T=toggle pane · ^S=swarm · ^R=search ^O=operations · ↑↓ history · Shift+Enter=newline · Enter=send'
             if @focus == :animation
-              controls = { pong: '↑↓ paddle', snake: '↑↓←→ steer', falling_blocks: '←→ move · ↓ faster · Space=rotate',
-                           asteroids: '←→ turn · ↑↓ thrust/reverse · Space=fire' }.fetch(@banner_name, '↑↓←→ play')
-              return text.sub('↑↓ history', controls).sub('Shift+Enter=newline · Enter=send', 'Enter/Esc=draft')
+              controls = { pacman: '↑↓←→ start/steer · ● power', snake: '↑↓←→ start/steer', falling_blocks: '←→ move · ↓ faster · Space=rotate',
+                           asteroids: '←→ turn · ↑↓ thrust/reverse · Space=fire', galaga: '↑↓←→ move · Space=fire',
+                           frogger: '↑↓←→ hop · logs → goals' }.fetch(@banner_name, '↑↓←→ play')
+              return text.sub('↑↓ history', "^G=next game · #{controls}").sub('Shift+Enter=newline · Enter=send', 'Enter/Esc=draft')
             end
             @focus == :session ? text.sub('↑↓ history', '↑↓ scroll · HOME · PGUP · PGDN · END') : text
           end
@@ -1522,6 +1559,10 @@ module PWN
             when :home then view[:offset] = 0
             when :end then view[:offset] = 1_000_000
             when 'r' then refresh_swarm
+            when 'v'
+              view[:confirm] = ['mission', @editor.text] unless @editor.text.strip.empty?
+            when 'p', 'u'
+              view[:confirm] = [key == 'p' ? 'pause' : 'resume', item[:id]] if view[:tab] == :jobs && item
             when 'a', 'b', 'd' then prepare_swarm_mission(key, item)
             when 'c', "\u0003"
               return unless view[:tab] == :jobs && item
@@ -1545,9 +1586,9 @@ module PWN
             minimum = key == 'd' ? 2 : 1
             return view[:notice] = "Select at least #{minimum} agent(s) with Space." if names.length < minimum
 
-            command = { 'a' => 'ask', 'b' => 'broadcast', 'd' => 'debate' }.fetch(key)
+            command = { 'a' => 'dm', 'b' => 'broadcast', 'd' => 'debate' }.fetch(key)
             view[:confirm] = case command
-                             when 'ask' then [command, names.first, @editor.text]
+                             when 'dm' then [command, names.first, @editor.text]
                              when 'broadcast' then [command, '--names', names.join(','), '--', @editor.text]
                              else [command, names.join(','), '--', @editor.text]
                              end
@@ -1577,17 +1618,21 @@ module PWN
 
           def execute_swarm_action
             args = @workspace.delete(:confirm)
-            result = @swarm.execute(line: Shellwords.join(['/swarm'] + args), on_event: ->(type, text) { @events << [type, text] }, usage_observer: @usage.method(:record))
+            options = { line: Shellwords.join(['/swarm'] + args), on_event: ->(type, text) { @events << [type, text] }, usage_observer: @usage.method(:record) }
+            options[:solve_request] = args.last if args.first == 'mission'
+            result = @swarm.execute(options)
             @workspace[:notice] = result[:error] || "#{args.first}: accepted#{" · job #{result[:job_id]}" if result[:job_id]}"
             add(result[:ok] == false ? :warning : :notice, @workspace[:notice])
             refresh_swarm if args.first == 'spawn'
-            @workspace.merge!(tab: :jobs, index: 0, offset: 0, detail: true) if result[:ok] && %w[ask broadcast debate].include?(args.first)
+            @workspace.merge!(tab: :jobs, index: 0, offset: 0, detail: true) if result[:ok] && %w[mission dm broadcast debate].include?(args.first)
           end
 
           def swarm_content
             view = @workspace
             if view[:confirm]
               args = view[:confirm]
+              return [[false, "ACTION: mission\nTEAM: protagonist builds; antagonist assesses independently and critiques; verifier runs checks; integrator accepts or requests repair.\nOnly protagonist writes. Verification uses disposable artifact copies (not an OS sandbox).\nORIGINAL REQUEST:\n#{args.last}"]] if args.first == 'mission'
+
               target = args.first == 'broadcast' ? args[2] : args[1]
               return [[false, "ACTION: #{args.first}\nTARGET: #{target}\n#{args.first == 'cancel' ? 'Cancel at a safe boundary; completed work is not undone.' : args.last}"]]
             end
@@ -1595,7 +1640,13 @@ module PWN
             item = items[view[:index]]
             rows = []
             if view[:detail] && item
-              item.each { |key, value| rows << [false, "#{key.to_s.upcase}: #{value}"] }
+              item.each do |key, value|
+                if key == :team
+                  rows.concat(solve_rows(value))
+                else
+                  rows << [false, "#{key.to_s.upcase}: #{value}"]
+                end
+              end
             elsif items.empty?
               rows << [false, view[:tab] == :roster ? 'No agents. Press n to add a local persona (no model call).' : 'No jobs yet. Tab to roster; a sends your draft after confirmation.']
             else
@@ -1611,13 +1662,25 @@ module PWN
             rows
           end
 
+          def solve_rows(team)
+            rows = [[false, "ORIGINAL REQUEST: #{team[:request]}"], [false, "ROUND: #{team[:round]} · REVISION: #{team[:revision]}"]]
+            (team[:roles] || {}).each do |role, state|
+              routing = team.dig(:routing, role) || {}
+              rows << [false, "#{role.upcase}: #{state} · #{routing[:engine]} / #{routing[:model] || 'provider default'}"]
+            end
+            (team[:requirements] || {}).each { |id, text| rows << [false, "#{id}: #{text}"] }
+            (team[:artifacts] || {}).each { |path, sha| rows << [false, "ARTIFACT: #{path} · #{sha}"] }
+            Array(team[:objections]).each { |text| rows << [false, "OPEN: #{text}"] }
+            rows
+          end
+
           def draw_swarm
             @screen.erase
             view = @workspace
             box(0, 0, @height - 1, @width - 1, "SWARM WORKSPACE · #{view[:tab].to_s.upcase}")
             swarm_put(1, 'Tab roster/jobs · j/k move · Enter details', :footer)
-            swarm_put(2, 'Space pick · a ask · b broadcast · d debate', :footer)
-            swarm_put(3, 'n new · r refresh · s steer · c cancel', :footer)
+            swarm_put(2, 'v Mission with team · Space pick · a dm · b broadcast · d debate', :footer)
+            swarm_put(3, 'n new · r refresh · s steer · p pause · u resume · c cancel', :footer)
             swarm_put(4, 'PgUp/Dn Home/End scroll · Esc back', :footer)
             rows = swarm_content.flat_map { |selected, text| wrap(swarm_safe(text), @width - 7).map { |row| [selected, row] } }
             page = @height - 10

data/lib/pwn/plugins/repl/ai_console_commands.rb

@@ -9,7 +9,7 @@ module PWN
           /back /clear /cron /debug /delegate /help /input /learning /mcp /memory /menu /model /system-role
           /sessions /skills /status /steer /swarm /trace /verbose
         ].freeze
-        SWARM = %w[dashboard help roster status create use spawn retire ask debate broadcast tail steer cancel].freeze
+        SWARM = %w[dashboard help mission agents status create use spawn retire dm debate broadcast tail steer pause resume cancel].freeze
 
         public_class_method def self.complete(opts = {})
           line = opts[:line].to_s
@@ -24,7 +24,8 @@ module PWN
                          else
                            candidates(tokens: tokens, prefix: prefix, pry: opts[:pry], swarm: opts[:swarm])
                          end
-          items = values.map do |value|
+          # Every depth is resolved live; sort here so no provider can bypass ordering.
+          items = values.sort_by { |value| [value.downcase, value] }.map do |value|
             replacement = line_replace(line: line, token: current, value: value)
             { label: value, text: replacement[:text], cursor: replacement[:cursor] }
           end
@@ -252,10 +253,10 @@ module PWN
           jobs = Array(context[:jobs]).map { |job| job[:id] || job['id'] }
           agents = Array(context[:agents])
           case action
-          when 'status', 'steer', 'cancel' then [filter(values: jobs + (action == 'cancel' ? ['all'] : []), prefix: prefix), 'job id']
+          when 'status', 'steer', 'cancel', 'pause', 'resume' then [filter(values: jobs + (action == 'cancel' ? ['all'] : []), prefix: prefix), 'job id']
           when 'use' then [filter(values: existing_swarms, prefix: prefix), 'swarm id']
           when 'spawn' then [[], position == 2 ? 'persona name' : 'role text']
-          when 'retire', 'ask' then [filter(values: agents, prefix: prefix), 'persona']
+          when 'retire', 'dm' then [filter(values: agents, prefix: prefix), 'persona']
           when 'debate' then [filter(values: agents, prefix: prefix), 'comma-separated personas, then topic']
           when 'tail' then [[], 'message limit']
           else [[], 'free text']

data/lib/pwn/plugins/repl/ai_swarm.rb

@@ -35,7 +35,7 @@ module PWN
         # Session-scoped swarm jobs. Workers never draw the terminal.
         class Controller # rubocop:disable Metrics/ClassLength -- one session-scoped swarm command surface
           MAX_JOBS = 8
-          ACTIVE = %w[queued running steering cancelling].freeze
+          ACTIVE = %w[queued running steering cancelling paused].freeze
 
           def initialize(session_id:)
             @session_id = session_id.to_s
@@ -46,6 +46,10 @@ module PWN
           end
 
           def execute(opts = {})
+            if (match = opts[:line].to_s.match(%r{\A\s*/swarm[ \t]+mission(?:[ \t](.*))?\z}m))
+              return solve([], opts.merge(solve_request: opts.fetch(:solve_request, match[1].to_s)))
+            end
+
             line = opts[:line].to_s.strip
             tokens = Shellwords.split(line)
             tokens.shift if tokens.first == '/swarm'
@@ -59,7 +63,7 @@ module PWN
             @mutex.synchronize do
               {
                 swarm_id: @swarm_id,
-                jobs: @jobs.values.map { |job| job.slice(:id, :agent, :state, :command, :result, :error, :last_tool).transform_values { |value| value.is_a?(String) ? value.dup : value } }
+                jobs: @jobs.values.map { |job| Marshal.load(Marshal.dump(job.slice(:id, :agent, :state, :command, :result, :error, :last_tool, :team))) }
               }
             end
           end
@@ -97,18 +101,20 @@ module PWN
           def dispatch(command, tokens, opts)
             case command
             when 'help', 'dashboard' then help_text
-            when 'roster' then { ok: true, agents: roster, swarm_id: @swarm_id }
+            when 'agents' then { ok: true, agents: roster, swarm_id: @swarm_id }
             when 'status' then status(tokens.first)
             when 'create' then create(tokens.join(' '))
             when 'use' then use(tokens.first)
             when 'spawn' then spawn(tokens)
             when 'retire' then retire(tokens.first)
-            when 'ask' then ask(tokens, opts)
+            when 'dm' then ask(tokens, opts)
+            when 'mission' then solve(tokens, opts)
             when 'debate' then debate(tokens, opts)
             when 'broadcast' then broadcast(tokens, opts)
             when 'tail' then tail(tokens.first)
             when 'steer' then steer(tokens, opts)
             when 'cancel' then cancel(tokens.first)
+            when 'pause', 'resume' then pause(tokens.first, command == 'pause')
             else { ok: false, error: "unknown /swarm command: #{command}", hint: help_text[:usage] }
             end
           end
@@ -116,7 +122,7 @@ module PWN
           def help_text
             {
               ok: true,
-              usage: '/swarm roster|status [JOB]|create [topic]|use ID|spawn NAME ROLE [--engine E --model M --toolsets a,b]|retire NAME|ask NAME REQUEST|debate NAMES TOPIC [--rounds N]|broadcast REQUEST [--names a,b]|tail [N]|steer JOB INSTRUCTION|cancel JOB|all'
+              usage: '/swarm mission REQUEST|agents|status [JOB]|create [topic]|use ID|spawn NAME ROLE [--engine E --model M --toolsets a,b]|retire NAME|dm NAME REQUEST|debate NAMES TOPIC [--rounds N]|broadcast REQUEST [--names a,b]|tail [N]|steer JOB INSTRUCTION|pause JOB|resume JOB|cancel JOB|all'
             }
           end
 
@@ -161,13 +167,26 @@ module PWN
           def ask(tokens, opts)
             name = tokens.shift
             request = tokens.join(' ')
-            return { ok: false, error: 'usage: ask NAME REQUEST' } if name.to_s.empty? || request.empty?
+            return { ok: false, error: 'usage: dm NAME REQUEST' } if name.to_s.empty? || request.empty?
 
-            start_job(agent: name, command: 'ask', opts: opts) do |job|
+            start_job(agent: name, command: 'dm', opts: opts) do |job|
               PWN::AI::Agent::Swarm.ask(name: name, request: request, swarm_id: ensure_swarm, steering: job[:control], usage_observer: opts[:usage_observer], on_tool: tool_callback(job, opts))
             end
           end
 
+          def solve(tokens, opts)
+            request = opts.fetch(:solve_request, tokens.join(' '))
+            return { ok: false, error: 'usage: mission REQUEST' } if request.strip.empty?
+
+            start_job(agent: 'team', command: 'mission', opts: opts) do |job|
+              PWN::AI::Agent::Swarm.solve(
+                request: request, swarm_id: ensure_swarm, steering: job[:control],
+                workspace: opts[:workspace], usage_observer: opts[:usage_observer], on_tool: tool_callback(job, opts),
+                on_state: ->(state) { @mutex.synchronize { job[:team] = state } }
+              )
+            end
+          end
+
           def debate(tokens, opts)
             flags, positional = split_flags(tokens)
             names = positional.shift.to_s.split(',')
@@ -219,6 +238,16 @@ module PWN
             { ok: true, job_id: job[:id] }
           end
 
+          def pause(id, paused)
+            job = find_job(id)
+            return { ok: false, error: 'job not found' } unless job
+            return { ok: false, error: 'pause/resume applies to mission jobs only' } unless job[:command] == 'mission'
+            return { ok: false, error: 'job is no longer active' } unless update_active(job, paused ? 'paused' : 'running')
+
+            job[:control].pause(paused)
+            { ok: true, job_id: id, state: job[:state] }
+          end
+
           def cancel(id)
             return cancel_all if id.nil? || id == 'all'
 
@@ -245,6 +274,8 @@ module PWN
 
           def start_job(agent:, command:, opts:)
             return { ok: false, error: 'swarm controller is closed' } if @closed
+            return { ok: false, error: 'mission requires exclusive workspace ownership; wait or cancel active jobs' } if (command == 'mission' && busy?) || snapshot[:jobs].any? { |row| row[:command] == 'mission' && ACTIVE.include?(row[:state]) }
+
             return { ok: false, error: "job limit #{MAX_JOBS} reached" } if busy_count >= MAX_JOBS
 
             ensure_swarm
@@ -257,16 +288,18 @@ module PWN
             job[:worker] = Thread.new do
               locals.each { |key, value| Thread.current[key] = value }
               variables.each { |key, value| Thread.current.thread_variable_set(key, value) }
-              job[:control] = JobControl.new(input: StringIO.new, output: StringIO.new)
+              control_class = command == 'mission' ? PWN::AI::Agent::Solve::Control : JobControl
+              job[:control] = control_class.new(input: StringIO.new, output: StringIO.new)
               Thread.current[:pwn_steering_input] = job[:control]
               ready << true
               update(job, 'running')
               result = yield(job)
               job[:control].check_stop
-              update(job, 'completed', result: summarize(result))
-              opts[:on_event]&.call(:assistant, "#{agent} [#{id}] #{command} complete\n#{summarize(result)}")
+              state = command == 'mission' ? result[:status] : 'completed'
+              update(job, state, result: summarize(result))
+              opts[:on_event]&.call(:assistant, "#{agent} [#{id}] #{command} #{state}\n#{summarize(result)}")
               result
-            rescue JobControl::Stopped => e
+            rescue JobControl::Stopped, PWN::AI::Agent::Solve::Control::Stopped => e
               update(job, 'cancelled', error: e.message)
               opts[:on_event]&.call(:warning, "#{agent} [#{id}] #{e.message}")
             rescue StandardError => e

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.760'
+  VERSION = '0.5.762'
 end

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

@@ -1081,7 +1081,8 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
         )
       ).to eq false
       src = File.read(described_class.method(:run).source_location.first)
-      expect(src).to match(/skip_plan.*catalog/)
+      expect(src).to match(/skip_compass.*catalog/)
+      expect(src).to match(/skip_plan.*skip_compass/)
       expect(src).to match(/force_plan && cal_state\[:cal\] && !skip_plan/)
     end