pwn 0.5.761 → 0.5.762

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

@@ -237,7 +237,7 @@ module PWN
           prior_id = Thread.current[:pwn_swarm_id]
           prior_honesty = Thread.current[:pwn_swarm_honesty]
           sid     = opts[:swarm_id] || create(topic: opts[:request].to_s[0, 60])[:swarm_id]
-          persona = personas(swarm_id: sid)[name.to_sym]
+          persona = opts[:persona] || personas(swarm_id: sid)[name.to_sym]
           raise ArgumentError, "unknown persona: #{name} (see #{AGENTS_FILE})" unless persona
 
           if opts[:unit].to_s != ''
@@ -256,6 +256,7 @@ module PWN
           session_id = persona_session(swarm_id: sid, name: name)
           sys        = build_persona_prompt(name: name, persona: persona,
                                             swarm_id: sid, session_id: session_id)
+          sys = "#{sys}\n#{opts[:handoff]}" if opts[:handoff]
 
           empty_tools = opts[:text_only] == true || Array(persona[:toolsets]).empty?
           Thread.current[:pwn_swarm_depth] = depth + 1
@@ -269,6 +270,7 @@ module PWN
               enabled_toolsets: empty_tools ? [] : persona[:toolsets],
               core_only: empty_tools ? false : true,
               system_role_content: sys,
+              solve_handoff: !opts[:handoff].nil?,
               on_tool: opts[:on_tool],
               steering: opts[:steering],
               nested: true
@@ -354,6 +356,30 @@ module PWN
           { swarm_id: sid, replies: replies }
         end
 
+        # Run the built-in four-role workflow with host-observed verification.
+        # Supported Method Parameters::
+        #   PWN::AI::Agent::Swarm.solve(
+        #     request: 'required - original objective, preserved for every role',
+        #     workspace: 'optional - artifact root, defaults to current directory',
+        #     rounds: 'optional - bounded repair rounds, 1..10, default 3',
+        #     swarm_id: 'optional - existing swarm registry',
+        #     steering: 'optional - Solve::Control coordinator control',
+        #     on_state: 'optional - observed role state callback',
+        #     on_tool: 'optional - tool observation callback',
+        #     usage_observer: 'optional - provider usage callback'
+        #   )
+        public_class_method def self.solve(opts = {})
+          prior_id = Thread.current[:pwn_swarm_id]
+          prior_honesty = Thread.current[:pwn_swarm_honesty]
+          raise ArgumentError, 'request is required' if opts[:request].to_s.strip.empty?
+
+          Thread.current[:pwn_swarm_honesty] = nil
+          Solve::Run.new(opts).run
+        ensure
+          Thread.current[:pwn_swarm_id] = prior_id
+          Thread.current[:pwn_swarm_honesty] = prior_honesty
+        end
+
         # ------------------------------------------------------------------
         # privates
         # ------------------------------------------------------------------
@@ -754,6 +780,8 @@ module PWN
               on_tool: 'optional - ->(name, args, result) live-UI callback',
               steering: 'optional - Loop::Steering for this persona turn',
               usage_observer: 'optional - callable receiving provider usage',
+              persona: 'optional - explicit in-memory persona for the built-in coordinator',
+              handoff: 'optional - structured coordinator context, not a replacement request',
               from: 'optional - sender account or address to bind as operator (defaults to caller_label)',
               text_only: 'required - text only value consumed by #ask',
               unit: 'optional - claim key (host+phase) before the child runs',
@@ -761,6 +789,18 @@ module PWN
               engagement_id: 'optional - claim namespace (defaults to swarm_id)'
             )
 
+            # Solve the unchanged objective with four roles and executed evidence.
+            #{self}.solve(
+              request: 'required - original objective preserved for every role',
+              workspace: 'optional - artifact root, defaults to current directory',
+              rounds: 'optional - repair round cap, 1..10, default 3',
+              swarm_id: 'optional - registry from which role overrides are inherited',
+              steering: 'optional - Solve::Control for coordinator steering/cancellation/pause',
+              on_state: 'optional - observed four-role state callback',
+              on_tool: 'optional - observed tool callback',
+              usage_observer: 'optional - provider usage callback'
+            )
+
             # Run debate and return its result
             #{self}.debate(
               names: 'required - Array of persona names, order = speaking order',

data/lib/pwn/ai/agent.rb

@@ -36,6 +36,7 @@ module PWN
       autoload :Extrospection, 'pwn/ai/agent/extrospection'
       autoload :Reflect,       'pwn/ai/agent/reflect'
       autoload :Swarm,         'pwn/ai/agent/swarm'
+      autoload :Solve,         'pwn/ai/agent/solve'
       autoload :Reward,        'pwn/ai/agent/reward'
       autoload :Verification,  'pwn/ai/agent/verification'
       autoload :Curriculum,    'pwn/ai/agent/curriculum'

data/lib/pwn/ai/anthropic.rb

@@ -325,6 +325,7 @@ module PWN
       # )
 
       private_class_method def self.anthropic_rest_call(opts = {})
+        opts = opts.merge(non_interactive: true) if Thread.current[:pwn_solve_tools]
         engine = PWN::Env[:ai][:anthropic] if defined?(PWN::Env)
         raise 'ERROR: Anthropic Hash not found in PWN::Env.  Run `pwn -Y default.yaml`, then `PWN::Env` for usage.' if engine.nil?
 

data/lib/pwn/ai/grok.rb

@@ -345,6 +345,7 @@ module PWN
       #   spinner: 'optional - display spinner (defaults to false)'
       # )
       private_class_method def self.grok_rest_call(opts = {})
+        opts = opts.merge(non_interactive: true) if Thread.current[:pwn_solve_tools]
         engine = PWN::Env.dig(:ai, :grok) if defined?(PWN::Env)
         raise 'ERROR: Grok Hash not found in PWN::Env.  Run `pwn -Y default.yaml`, then `PWN::Env` for usage.' if engine.nil?
 

data/lib/pwn/ai/open_ai.rb

@@ -391,6 +391,7 @@ module PWN
       # )
 
       private_class_method def self.open_ai_rest_call(opts = {})
+        opts = opts.merge(non_interactive: true) if Thread.current[:pwn_solve_tools]
         engine = PWN::Env[:ai][:openai] if defined?(PWN::Env)
         raise 'ERROR: OpenAI Hash not found in PWN::Env.  Run `pwn -Y default.yaml`, then `PWN::Env` for usage.' if engine.nil?
 

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

@@ -610,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.')
@@ -1062,7 +1062,7 @@ 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}",
@@ -1559,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
@@ -1582,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
@@ -1614,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
@@ -1632,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
@@ -1648,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.761'
+  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