pwn 0.5.759 → 0.5.760

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ef7228011e10bd0573cab148f192e8ef963608a002d4e3d833fcd2e380fd973
-  data.tar.gz: 8f238e16e7d0d521deb4b4abdad45fed2d15fb82d92bcc8448b0877bc23b8783
+  metadata.gz: 2115a19977c0539855a44ecea57a2fb74bc48ae80ff3a713d2c08b95bdb04e55
+  data.tar.gz: 3c237b68883205d53dee7911e18be1e5b5454184f27c7d093e655e75611f5184
 SHA512:
-  metadata.gz: d6eb621a41250c5332e00f941c8b6b7444f796fcb30c009d774d7a0814f3c268809152275f2c63f7f7076450c75bbe662c0248ec6b21abb9730b44b097fdb139
-  data.tar.gz: 8ea184fdfa2018bc59f00aef8585d190907236a3d71df302c21db3eb025813111cd5a7bb289513c5a7f51a816f1c7e094f5b6c0bf420ff50d9a7a27a11ffbc65
+  metadata.gz: 01c9e98a32745f26186d2f664d62f7d1801eea05a56ffe149ea20b84aaef383d5d46d909e5be97247454cedad4781c3ce393783dcc64707a07bbd818a37872c5
+  data.tar.gz: 562ea7604c6e23cbe128864aca11338e9c60bd7d83bd5e54692c956f136f29f036e1fb7b63c6cdb9f0defd3168c616cfff5c9194f169b9df209094952e0ae66b

data/Gemfile

@@ -49,7 +49,7 @@ gem 'jwt', '3.3.0'
 gem 'libusb', '0.8.0'
 gem 'luhn', '3.0.0'
 gem 'mail', '2.9.1'
-gem 'mcp', '1.6.1'
+gem 'mcp', '1.7.0'
 gem 'meshtastic', '0.0.186'
 gem 'metasm', '1.0.6'
 gem 'mongo', '2.26.0'

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

@@ -59,8 +59,78 @@ module PWN
       #     (:escalation_persona) — the local model still produces the final
       #     answer so Learning/Metrics stay attributed to :ollama.
       module Loop
+        # Provider calls run on a child. Thread#raise does not wake a native read,
+        # so the owner waits in Ruby and leaves within one poll on cancel.
+        class ProviderWindow
+          def request_model_cancel
+            @mutex.synchronize do
+              @cancel_requested = true
+              if @phase == :model && !@model_signal_sent
+                @model_signal_sent = true
+                @owner.raise(Steering::ModelCancelled)
+              end
+            end
+          end
+
+          def model(messages:, &block)
+            result = nil
+            worker = nil
+            Thread.handle_interrupt(Steering::ModelCancelled => :never) do
+              checkpoint(messages: messages, phase: :model)
+              raise Steering::ModelCancelled if cancel_requested?
+
+              worker = provider_thread(&block)
+              Thread.handle_interrupt(Steering::ModelCancelled => :immediate) do
+                loop do
+                  raise Steering::ModelCancelled if cancel_requested?
+
+                  break if worker.join(0.05)
+                end
+              end
+              result = worker.value
+            ensure
+              abandon_provider(worker)
+              @mutex.synchronize { @phase = :boundary }
+              begin
+                Thread.handle_interrupt(Steering::ModelCancelled => :immediate) { nil }
+              rescue Steering::ModelCancelled
+                nil
+              end
+            end
+            result
+          rescue Steering::ModelCancelled
+            nil
+          end
+
+          private
+
+          def cancel_requested?
+            @mutex.synchronize { @cancel_requested }
+          end
+
+          def provider_thread(&block)
+            parent = Thread.current
+            locals = parent.keys.select { |key| key.to_s.start_with?('pwn_') }.to_h { |key| [key, parent[key]] }
+            variables = parent.thread_variables.select { |key| key.to_s.start_with?('pwn_') }.to_h { |key| [key, parent.thread_variable_get(key)] }
+            Thread.new do
+              Thread.current.report_on_exception = false
+              locals.each { |key, value| Thread.current[key] = value }
+              variables.each { |key, value| Thread.current.thread_variable_set(key, value) }
+              Thread.handle_interrupt(Steering::ModelCancelled => :never, &block)
+            end
+          end
+
+          def abandon_provider(worker)
+            return unless worker&.alive?
+
+            worker.raise(Steering::ModelCancelled)
+            worker.join(0.2)
+            worker.kill if worker.alive?
+          end
+        end
+
         # Request-owned input broker; only the provider window is interruptible.
-        class Steering
+        class Steering < ProviderWindow
           INPUT_LOCK = Mutex.new
           INPUT_OWNERS = {} # rubocop:disable Style/MutableConstant -- guarded by INPUT_LOCK
 
@@ -80,12 +150,14 @@ module PWN
           attr_reader :reader
 
           def initialize(input:, output:)
+            super()
             @input = input
             @output = output
             @owner = Thread.current
             @mutex = Mutex.new
             @pending = []
             @phase = :boundary
+            @cancel_requested = false
           end
 
           def submit(text)
@@ -127,23 +199,6 @@ module PWN
             raise Restart.new(messages, instructions)
           end
 
-          def model(messages:, &block)
-            # Drain an in-flight signal inside this rescue, never in a tool.
-            Thread.handle_interrupt(ModelCancelled => :never) do
-              checkpoint(messages: messages, phase: :model)
-              Thread.handle_interrupt(ModelCancelled => :immediate, &block)
-            ensure
-              @mutex.synchronize { @phase = :boundary }
-              begin
-                Thread.handle_interrupt(ModelCancelled => :immediate) { nil }
-              rescue ModelCancelled
-                nil
-              end
-            end
-          rescue ModelCancelled
-            nil
-          end
-
           def with_reader
             require 'io/console'
             input_id = @input.fileno

data/lib/pwn/banner.rb

@@ -187,6 +187,59 @@ module PWN
       end
     end
 
+    # Caller-owned simulation: yields on the UI thread, never reads input or
+    # accumulates a replay. The caller supplies the clock and normalized keys.
+    class MiniGame
+      def initialize(name:, width:, height:, seed: MINI_SEED)
+        @name = name.to_s
+        raise ArgumentError, "Unknown mini-banner: #{name}" unless Banner.mini_names.map(&:to_s).include?(@name)
+
+        limit = @name == 'falling_blocks' ? 64 : MINI_WIDTH
+        @width = width.clamp(5, limit)
+        @height = height.clamp(5, limit)
+        @keys = []
+        @simulation = Fiber.new do
+          options = { frames: self, width: @width, height: @name == 'falling_blocks' ? @height * 2 : @height,
+                      rng: Random.new(seed), player: self }
+          Banner.send("mini_simulate_#{@name}", options)
+        end
+      end
+
+      def key(key)
+        @keys << key if @keys.length < 16
+      end
+
+      def controls
+        keys = @keys
+        @keys = []
+        keys
+      end
+
+      def step
+        @simulation.resume
+      end
+
+      def cells(frame)
+        rows = frame[:rows].drop(1)
+        rows = Banner.send(:mini_block_board, board: rows) if @name == 'falling_blocks'
+        rows = Banner.send(:mini_quarter_board, board: rows, name: @name) if @name == 'snake'
+        rows.map do |row|
+          row.chars.map do |pixel|
+            glyph, foreground, background = MINI_PIXELS.fetch(pixel)
+            { glyph: glyph.dup, foreground: foreground, background: background || :black }
+          end
+        end
+      end
+
+      def <<(frame)
+        Fiber.yield(frame)
+      end
+
+      def length
+        0
+      end
+    end
+
     # Six immutable, compact replays bound memory even when callers resize/reseed.
     private_class_method def self.mini_replay(opts = {})
       key = [opts[:name].to_s.dup.freeze, opts[:width], opts[:height], opts[:seed]].freeze
@@ -347,56 +400,99 @@ module PWN
         bag = (0...MINI_SHAPES.length).to_a.shuffle(random: rng) if bag.empty?
         type = bag.shift
         shape = MINI_SHAPES[type]
-        landing = mini_landing(board: board, shape: shape, rng: rng)
+        landing = opts[:player] ? {} : mini_landing(board: board, shape: shape, rng: rng)
         x = (width - shape.map(&:first).max - 1) / 2
         unless landing && mini_fits?(board: board, shape: shape, x: x, y: 0)
           mini_reset_board(frames: frames, board: board)
           board = Array.new(height) { ' ' * width }
           next
         end
-        rotations = mini_rotations(shape: shape)
-        plan = [[shape, x, 0]]
-        blocked = false
-        (1..landing[:rotation]).each do |rotation|
-          shape = rotations[rotation]
-          if mini_fits?(board: board, shape: shape, x: x, y: 0)
-            plan << [shape, x, 0]
-          else
-            blocked = true
+        if opts[:player]
+          shape, x, y = mini_play_piece(board: board, type: type, frames: frames, player: opts[:player])
+          landing = { x: x, y: y }
+        else
+          shape, x = mini_block_plan(board: board, shape: shape, x: x, landing: landing, frames: frames, type: type)
+          unless shape
+            mini_reset_board(frames: frames, board: board)
+            board = Array.new(height) { ' ' * width }
+            next
           end
         end
-        until x == landing[:x] || blocked
-          x += landing[:x] <=> x
-          blocked = !mini_fits?(board: board, shape: shape, x: x, y: 0)
-          plan << [shape, x, 0] unless blocked
-        end
-        if blocked
-          mini_reset_board(frames: frames, board: board)
-          board = Array.new(height) { ' ' * width }
-          next
-        end
-        (1..landing[:y]).each { |y| plan << [shape, x, y] }
         color = %w[c y m b r g g][type]
-        plan.each do |piece, px, py|
-          picture = board.map(&:dup)
-          active = piece.map { |dx, dy| [px + dx, py + dy] }
-          active.each { |ax, ay| picture[ay][ax] = color }
-          mini_emit(frames: frames, board: picture,
-                    state: { active: active, stack: board.map(&:dup), type: type })
-        end
         shape.each { |dx, dy| board[landing[:y] + dy][x + dx] = color }
         mini_emit(frames: frames, board: board, event: :lock, ticks: 2)
-        full = board.each_index.reject { |y| board[y].include?(' ') }
+        full = board.each_index.reject { |row| board[row].include?(' ') }
         next if full.empty?
 
         flash = board.map(&:dup)
-        full.each { |y| flash[y] = 'w' * width }
+        full.each { |row| flash[row] = 'w' * width }
         mini_emit(frames: frames, board: flash, event: :clear, state: { lines: full }, ticks: 3)
-        board = Array.new(full.length) { ' ' * width } + board.each_with_index.filter_map { |row, y| row unless full.include?(y) }
+        board = Array.new(full.length) { ' ' * width } + board.each_with_index.filter_map { |row, index| row unless full.include?(index) }
         mini_emit(frames: frames, board: board, event: :collapse, ticks: 2)
       end
     end
 
+    private_class_method def self.mini_block_plan(opts = {})
+      board, shape, x, landing, frames, type = opts.values_at(:board, :shape, :x, :landing, :frames, :type)
+      rotations = mini_rotations(shape: shape)
+      plan = [[shape, x, 0]]
+      blocked = false
+      (1..landing[:rotation]).each do |rotation|
+        shape = rotations[rotation]
+        if mini_fits?(board: board, shape: shape, x: x, y: 0)
+          plan << [shape, x, 0]
+        else
+          blocked = true
+        end
+      end
+      until x == landing[:x] || blocked
+        x += landing[:x] <=> x
+        blocked = !mini_fits?(board: board, shape: shape, x: x, y: 0)
+        plan << [shape, x, 0] unless blocked
+      end
+      return if blocked
+
+      (1..landing[:y]).each { |y| plan << [shape, x, y] }
+      color = %w[c y m b r g g][type]
+      plan.each do |piece, px, py|
+        picture = board.map(&:dup)
+        active = piece.map { |dx, dy| [px + dx, py + dy] }
+        active.each { |ax, ay| picture[ay][ax] = color }
+        mini_emit(frames: frames, board: picture,
+                  state: { active: active, stack: board.map(&:dup), type: type })
+      end
+      [shape, x]
+    end
+
+    private_class_method def self.mini_play_piece(opts = {})
+      board, type, frames, player = opts.values_at(:board, :type, :frames, :player)
+      shape = MINI_SHAPES[type]
+      x = (board.first.length - shape.map(&:first).max - 1) / 2
+      y = 0
+      tick = 0
+      loop do
+        active = shape.map { |dx, dy| [x + dx, y + dy] }
+        picture = board.map(&:dup)
+        active.each { |ax, ay| picture[ay][ax] = %w[c y m b r g g][type] }
+        mini_emit(frames: frames, board: picture, state: { active: active, stack: board.map(&:dup), type: type })
+        keys = player.controls
+        keys.each do |key|
+          candidate = key == ' ' ? mini_rotations(shape: shape).fetch(1, shape) : shape
+          nx = x + { left: -1, right: 1 }.fetch(key, 0)
+          next unless mini_fits?(board: board, shape: candidate, x: nx, y: y)
+
+          shape = candidate
+          x = nx
+        end
+        tick += 1
+        next unless keys.include?(:down) || (tick % 5).zero?
+        break unless mini_fits?(board: board, shape: shape, x: x, y: y + 1)
+
+        y += 1
+      end
+      [shape, x, y]
+    end
+
     private_class_method def self.mini_reset_board(opts = {})
       board = opts[:board].map { |row| row.gsub(/[^ ]/, 'w') }
       mini_emit(frames: opts[:frames], board: board, event: :game_over, ticks: 8)
@@ -442,19 +538,31 @@ module PWN
       height = opts[:height]
       rng = opts[:rng]
       spaces = (0...height).flat_map { |y| (0...width).map { |x| [x, y] } }
+      player = opts[:player]
       while frames.length < MINI_FRAME_COUNT
         y = rng.rand(height)
         body = [[2, y], [1, y], [0, y]]
+        direction = [1, 0]
         food = (spaces - body).sample(random: rng)
         steps = 0
         loop do
           board = Array.new(height) { ' ' * width }
           body.each_with_index { |(x, row), index| board[row][x] = index.zero? ? 'y' : 'g' }
           board[food[1]][food[0]] = 'f' if food
-          mini_emit(frames: frames, board: board, ticks: 2, state: { body: body.map(&:dup), food: food&.dup })
+          mini_emit(frames: frames, board: board, ticks: player ? 1 : 2, state: { body: body.map(&:dup), food: food&.dup })
           break if frames.length >= MINI_FRAME_COUNT
 
-          target = mini_snake_route(body: body, food: food, width: width, height: height, rng: rng) if food
+          if player
+            turn = player.controls.filter_map { |key| { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] }[key] }.find do |dx, dy|
+              [dx, dy] != direction && [dx, dy] != direction.map(&:-@)
+            end
+            direction = turn if turn
+            target = [body.first[0] + direction[0], body.first[1] + direction[1]]
+            occupied = target == food ? body : body.take(body.length - 1)
+            target = nil unless spaces.include?(target) && !occupied.include?(target)
+          elsif food
+            target = mini_snake_route(body: body, food: food, width: width, height: height, rng: rng)
+          end
           if !food || !target || steps >= width * height * 4
             mini_reset_board(frames: frames, board: board)
             break
@@ -477,6 +585,7 @@ module PWN
       height = opts[:height]
       rng = opts[:rng]
       paddles = [(height - 1) / 2.0, (height - 1) / 2.0]
+      player = opts[:player]
       scores = [0, 0]
       while frames.length < MINI_FRAME_COUNT
         x = (width - 1) / 2.0
@@ -485,9 +594,14 @@ module PWN
         vy = ((rng.rand * 0.4) + 0.1) * (rng.rand(2).zero? ? -1 : 1)
         bias = Array.new(2) { rng.rand(5).zero? ? rng.rand(-2..2) : rng.rand - 0.5 }
         rally = 0
-        mini_pong_snapshot(frames: frames, width: width, height: height, paddles: paddles, ball: [x, y], scores: scores, event: :serve, ticks: 16)
+        mini_pong_snapshot(frames: frames, width: width, height: height, paddles: paddles, ball: [x, y], scores: scores, event: :serve, ticks: player ? 1 : 16)
         loop do
+          player&.controls&.each do |key|
+            paddles[0] = (paddles[0] + { up: -0.5, down: 0.5 }.fetch(key, 0)).clamp(0, height - 1)
+          end
           paddles.each_index do |side|
+            next if player && side.zero?
+
             incoming = side.zero? ? vx.negative? : vx.positive?
             target = incoming ? y - 0.25 + bias[side] : (height - 1) / 2.0
             speed = incoming ? 0.275 : 0.11
@@ -519,7 +633,7 @@ module PWN
           y = ny
           if x.negative? || x > width - 1
             scores[x.negative? ? 1 : 0] += 1
-            mini_pong_snapshot(frames: frames, width: width, height: height, paddles: paddles, ball: nil, scores: scores, event: :score, ticks: 20)
+            mini_pong_snapshot(frames: frames, width: width, height: height, paddles: paddles, ball: nil, scores: scores, event: :score, ticks: player ? 1 : 20)
             break
           end
           mini_pong_snapshot(frames: frames, width: width, height: height, paddles: paddles, ball: [x, y], scores: scores, event: event, rally: rally)
@@ -594,13 +708,18 @@ module PWN
         end
         angle = Math.atan2(mini_delta(from: ship[1], to: target[1], span: height), mini_delta(from: ship[0], to: target[0], span: width))
         turn = mini_delta(from: ship[2], to: angle, span: Math::PI * 2).clamp(-0.1, 0.1)
+        keys = opts[:player]&.controls
+        turn = keys.sum { |key| { left: -0.2, right: 0.2 }.fetch(key, 0) } if keys
         ship[2] = (ship[2] + turn) % (Math::PI * 2)
-        thrust = tick % 80 < 24
+        power = tick % 80 < 24 ? 1 : 0
+        power = keys.sum { |key| { up: 1, down: -1 }.fetch(key, 0) }.clamp(-1, 1) if keys
+        thrust = !power.zero?
         [Math.cos(ship[2]), Math.sin(ship[2])].each_with_index do |direction, axis|
-          velocity[axis] = ((velocity[axis] * 0.99) + (thrust ? direction * 0.006 : 0)).clamp(-0.15, 0.15)
+          velocity[axis] = ((velocity[axis] * 0.99) + (direction * 0.006 * power)).clamp(-0.15, 0.15)
           ship[axis] = (ship[axis] + velocity[axis]) % (axis.zero? ? width : height)
         end
-        shots << [ship[0], ship[1], Math.cos(ship[2]) * 0.36, Math.sin(ship[2]) * 0.36, 24] if (tick % 12).zero?
+        fire = keys ? keys.include?(' ') : (tick % 12).zero?
+        shots << [ship[0], ship[1], Math.cos(ship[2]) * 0.36, Math.sin(ship[2]) * 0.36, 24] if fire
         shots.each do |shot|
           shot[0] = (shot[0] + shot[2]) % width
           shot[1] = (shot[1] + shot[3]) % height

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

@@ -86,6 +86,7 @@ module PWN
 
           def stop
             @stopping = true
+            request_model_cancel
             submit('Stop the active request.')
           end
 
@@ -524,13 +525,12 @@ module PWN
 
           def cancel
             if busy?
-              return if @cancelling
-
+              first = !@cancelling
               @cancelling = true
               @control&.stop
               @swarm&.cancel_all
               @tool_input.close unless @tool_input.closed?
-              add(:warning, 'Cancellation requested. Waiting for the active tool to finish; work already started is not undone.')
+              add(:warning, 'Cancellation requested. Waiting for a safe boundary; work already started is not undone.') if first
             else
               @editor.replace('')
             end
@@ -681,6 +681,7 @@ module PWN
           def handle(key)
             return if key.nil?
             return handle_system_role(key) if @role_editor && (!@too_small || ["\e", "\u0003", "\u0004", :eof].include?(key))
+            return cancel if key == "\u0003" && busy?
 
             return if @too_small && ![:eof, "\u0003", "\u0004"].include?(key)
             return cancel if @too_small && key == "\u0003" && !@model_prompt
@@ -714,7 +715,10 @@ module PWN
 
             if ["\u0018", "\u0014"].include?(key)
               @menu = nil
-              @focus = @focus == :session ? :mission : :session
+              panes = @header_pane_height ? %i[mission session animation] : %i[mission session]
+              @focus = panes[(panes.index(@focus).to_i + 1) % panes.length]
+              @banner_game&.controls
+              @banner_game_tick = nil
               return
             end
 
@@ -726,6 +730,8 @@ module PWN
               @menu = nil
               return
             end
+            return handle_animation(key) if @focus == :animation && ![:eof, "\u0003", "\u0004"].include?(key)
+
             case key
             when :eof, "\u0004"
               @leaving = true
@@ -794,6 +800,24 @@ module PWN
             end
           end
 
+          def handle_animation(key)
+            if key == :paste_start
+              @focus = :mission
+              @paste = true
+              @banner_game&.controls
+            elsif [:up, :down, :left, :right, ' '].include?(key)
+              @banner_game&.key(key)
+            elsif ["\r", "\n", "\e", :newline].include?(key)
+              @focus = :mission
+              @banner_game&.controls
+            elsif key.is_a?(String) && key.ord >= 32
+              @focus = :mission
+              @banner_game&.controls
+              @editor.insert(key)
+              refresh_completion
+            end
+          end
+
           def open_system_role
             return add(:warning, 'System role cannot change while a request or swarm job is running.') if busy?
 
@@ -1201,6 +1225,7 @@ module PWN
             end
             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 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)
@@ -1210,6 +1235,21 @@ module PWN
             canvas
           end
 
+          def playable_banner(size, now)
+            key = [@banner_session, @banner_name, size, @banner_seed]
+            if @banner_game_key != key
+              @banner_game_key = key
+              @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
+            if @banner_game_tick != tick
+              @banner_game_cells = @banner_game.cells(@banner_game.step)
+              @banner_game_tick = tick
+            end
+            @banner_game_cells
+          end
+
           def draw_banner(size)
             cells = banner_frame(size, cells: true)
             top = [(size - cells.length) / 2, 0].max
@@ -1267,6 +1307,11 @@ 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')
+            end
             @focus == :session ? text.sub('↑↓ history', '↑↓ scroll · HOME · PGUP · PGDN · END') : text
           end
 
@@ -1295,6 +1340,7 @@ module PWN
             visible.each_with_index { |spans, index| put_spans(2 + index, @header_text_column, spans) }
             if @header_pane_height
               box(0, 0, height, height, '')
+              mark_active(0, 0, height, 'PLAY') if @focus == :animation
               draw_banner(height - 2)
             end
             height
@@ -1338,6 +1384,8 @@ module PWN
             end
             engine = PWN::Env.dig(:ai, :active).to_s
             model = REPL.pwn_ai_engine_model(engine: engine)
+            header_layout(engine, model)
+            @focus = :mission if @focus == :animation && !@header_pane_height
             footer, compose_height, footer_height = layout_chrome
             @compose_height = compose_height
             @footer_height = footer_height
@@ -1359,9 +1407,9 @@ module PWN
             rows.slice(start, @page_size).to_a.each_with_index { |(color, row), index| put(header_height + 1 + index, 2, row, color) }
             draw_sidebar(header_height, pane_width + 1, timeline_height) if sidebar.positive?
             compose_y = @height - compose_height - footer_height
-            mission_title = @focus == :session ? 'MISSION CONTROL' : 'MISSION CONTROL · active'
+            mission_title = @focus == :mission ? 'MISSION CONTROL · active' : 'MISSION CONTROL'
             box(compose_y, 0, compose_height, @width - 1, mission_title)
-            mark_active(compose_y, 0, @width - 1, mission_title) if @focus != :session
+            mark_active(compose_y, 0, @width - 1, mission_title) if @focus == :mission
             draw_composer(compose_y, height: compose_height)
             footer_top = @height - footer_height
             footer.first(footer_height).each_with_index { |line, index| put(footer_top + index, 1, line, tone(:footer)) }
@@ -1370,7 +1418,9 @@ module PWN
             draw_details(engine, model) if @details
             draw_swarm if @workspace
             draw_system_role if @role_editor
-            if @focus == :session && !(@details || @workspace || @role_editor)
+            if @focus == :animation && !(@details || @workspace || @role_editor || @model_prompt)
+              @screen.setpos(1, 1)
+            elsif @focus == :session && !(@details || @workspace || @role_editor)
               @screen.setpos(header_height + 1, 2)
             elsif @role_editor || !(@details || @workspace)
               @screen.setpos(*@cursor_position)

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

@@ -15,6 +15,7 @@ module PWN
 
           def stop
             @stopping = true
+            request_model_cancel
             submit('Stop this swarm job.')
           end
 

data/lib/pwn/version.rb

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

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

@@ -228,7 +228,7 @@ describe PWN::AI::Agent::Loop do # rubocop:disable Metrics/BlockLength
       calls = []
       owner = Thread.current
       allow(described_class).to receive(:call_engine) do |opts|
-        expect(Thread.current).to eq(owner)
+        expect(Thread.current).not_to eq(owner)
         calls << Marshal.load(Marshal.dump(opts[:messages]))
         if calls.length == 1
           entered << true

data/spec/lib/pwn/banner_spec.rb

@@ -25,7 +25,103 @@ describe PWN::Banner do
       end
     end
   end
+end
+
+describe PWN::Banner::MiniGame do
+  it 'renders bounded, unbranded colored frames without accumulating a replay' do
+    PWN::Banner.mini_names.product([5, 8, 16]).each do |name, size|
+      game = described_class.new(name: name, width: size, height: size)
+      40.times do
+        frame = game.step
+        cells = game.cells(frame)
+        expect(cells.length).to eq(size)
+        expect(cells.map(&:length)).to all(eq(size))
+        expect(cells.flatten.map { |cell| cell[:glyph] }.join).not_to match(/[PWN]/)
+        expect(cells.flatten).to all(include(:foreground, :background))
+      end
+      expect(game.length).to eq(0)
+    end
+  end
+
+  it 'lets the player move only the left Pong paddle while the ball and opponent keep playing' do
+    game = PWN::Banner::MiniGame.new(name: :pong, width: 8, height: 8, seed: 73)
+    first = game.step
+    game.key(:up)
+    moved = game.step
+    expect(moved[:state][:paddles][0]).to be < first[:state][:paddles][0]
+    expect(moved[:state][:ball]).not_to eq(first[:state][:ball])
+    game.key(:down)
+    expect(game.step[:state][:paddles][0]).to eq(first[:state][:paddles][0])
+    game.key(:left)
+    expect(game.step[:state][:paddles][0]).to eq(first[:state][:paddles][0])
+    100.times do
+      game.key(:up)
+      game.step
+    end
+    expect(game.step[:state][:paddles][0]).to eq(0)
+  end
+
+  it 'steers Snake with arrows without reversing into its neck or changing direction twice per tick' do
+    game = PWN::Banner::MiniGame.new(name: :snake, width: 16, height: 16, seed: 73)
+    first = game.step[:state]
+    game.key(:left)
+    moved = game.step[:state]
+    expect(moved[:body].first).to eq([first[:body][0][0] + 1, first[:body][0][1]])
+    turn = moved[:body][0][1].positive? ? :up : :down
+    game.key(turn)
+    game.key(:left)
+    turned = game.step[:state]
+    expect(turned[:body].first).to eq([moved[:body][0][0], moved[:body][0][1] + (turn == :up ? -1 : 1)])
+    game.key(:left)
+    expect(game.step[:state][:body].first[0]).to eq(turned[:body][0][0] - 1)
+  end
+
+  it 'moves Tetris sideways, rotates with space and soft drops one row with down' do
+    game = PWN::Banner::MiniGame.new(name: :falling_blocks, width: 8, height: 8, seed: 73)
+    first = game.step[:state]
+    game.key(:left)
+    left = game.step[:state]
+    expect(left[:active]).to eq(first[:active].map { |x, y| [x - 1, y] })
+    game.key(:right)
+    expect(game.step[:state][:active]).to eq(first[:active])
+    game.key(' ')
+    rotated = game.step[:state]
+    expect(rotated[:active]).not_to eq(first[:active])
+    expect(rotated[:active].map(&:last).min).to eq(0)
+    game.key(:down)
+    dropped = game.step[:state]
+    expect(dropped[:active]).to eq(rotated[:active].map { |x, y| [x, y + 1] })
+    expect(dropped[:stack]).to eq(first[:stack])
+    events = 150.times.map do
+      game.key(:down)
+      game.step[:event]
+    end
+    expect(events).to include(:lock)
+  end
 
+  it 'turns and thrusts Asteroids only on arrows and fires only on space' do
+    game = PWN::Banner::MiniGame.new(name: :asteroids, width: 16, height: 16, seed: 73)
+    first = game.step[:state]
+    idle = game.step[:state]
+    expect(idle[:ship]).to eq(first[:ship])
+    expect(idle[:shots]).to be_empty
+    game.key(:left)
+    left = game.step[:state]
+    expect(left[:ship][2]).to be_within(0.001).of((first[:ship][2] - 0.2) % (Math::PI * 2))
+    game.key(:right)
+    expect(game.step[:state][:ship][2]).to be_within(0.001).of(first[:ship][2])
+    game.key(:up)
+    moved = game.step[:state]
+    expect(moved[:ship].take(2)).not_to eq(first[:ship].take(2))
+    expect(moved[:thrust]).to be(true)
+    game.key(:down)
+    expect(game.step[:state][:thrust]).to be(true)
+    game.key(' ')
+    expect(game.step[:state][:shots].length).to eq(1)
+  end
+end
+
+describe PWN::Banner do
   def block_colors(rows)
     rows.flat_map do |row|
       [0, 2].map do |bit|

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

@@ -258,6 +258,27 @@ 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 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    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
+        "\u0003"
+      elsif @paint.any? { |row| row.include?('Request cancelled at a safe boundary') }
+        "\u0004"
+      else
+        Thread.pass
+        nil
+      end
+    end
+    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
     entered = Queue.new
     calls = 0
@@ -1025,6 +1046,86 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     console.draw
     expect(painted.map { |row| row[2] }.join).to include('SESSION  · active')
     expect(screen).to have_received(:setpos).with(a_kind_of(Integer), 2)
+    console.handle("\u0014")
+    painted.clear
+    console.draw
+    expect(painted.map { |row| row[2] }.join).to include(' PLAY ')
+    expect(painted.map { |row| row[2] }.join).not_to include('MISSION CONTROL · active')
+    expect(screen).to have_received(:setpos).with(1, 1)
+    allow(curses).to receive_messages(lines: 24, cols: 80)
+    console.draw
+    expect(console.instance_variable_get(:@focus)).to eq(:mission)
+  end
+
+  it 'cycles mission, session and visible animation with both shortcuts without changing the draft' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    editor = console.instance_variable_get(:@editor)
+    editor.place('kept draft', 4)
+    console.instance_variable_set(:@header_pane_height, 10)
+    console.banner_frame(8, cells: true)
+    console.handle("\u0014")
+    console.handle("\u0018")
+    expect(console.instance_variable_get(:@focus)).to eq(:animation)
+    console.banner_frame(8, cells: true)
+    game = console.instance_variable_get(:@banner_game)
+    expect(game).to receive(:key).with(:up)
+    expect(game).to receive(:key).with(' ')
+    console.handle(:up)
+    console.handle(' ')
+    expect([editor.text, editor.cursor]).to eq(['kept draft', 4])
+    console.handle("\u0014")
+    expect(console.instance_variable_get(:@focus)).to eq(:mission)
+    expect([editor.text, editor.cursor]).to eq(['kept draft', 4])
+  end
+
+  it 'returns to the unchanged automatic animation when focus leaves the game' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    allow(Process).to receive(:clock_gettime).and_return(10.0)
+    automatic = console.banner_frame(8, cells: true)
+    console.instance_variable_set(:@header_pane_height, 10)
+    2.times { console.handle("\u0014") }
+    expect(console.banner_frame(8, cells: true)).not_to eq(automatic)
+    console.handle("\u0018")
+    expect(console.banner_frame(8, cells: true)).to eq(automatic)
+    console.instance_variable_set(:@header_pane_height, nil)
+    2.times { console.handle("\u0014") }
+    expect(console.instance_variable_get(:@focus)).to eq(:mission)
+  end
+
+  it 'keeps modal, search and cancellation priority above animation controls' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    console.instance_variable_set(:@focus, :animation)
+    editor = console.instance_variable_get(:@editor)
+    editor.place('draft', 2)
+    game = double(key: nil)
+    console.instance_variable_set(:@banner_game, game)
+    console.instance_variable_set(:@details, 0)
+    expect(console).to receive(:handle_details).with(:up)
+    console.handle(:up)
+    console.instance_variable_set(:@details, nil)
+    console.instance_variable_set(:@model_prompt, {})
+    expect(console).to receive(:handle_model_prompt).with(' ')
+    console.handle(' ')
+    console.instance_variable_set(:@model_prompt, nil)
+    allow(console).to receive(:busy?).and_return(true)
+    expect(console).to receive(:cancel)
+    console.handle("\u0003")
+    console.handle("\u0012")
+    expect(editor.search).not_to be_nil
+    expect(console.instance_variable_get(:@focus)).to eq(:mission)
+    expect(game).not_to have_received(:key)
+    expect([editor.text, editor.cursor]).to eq(['draft', 2])
+  end
+
+  it 'preserves bracketed paste and the mission cursor when leaving animation focus' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    editor = console.instance_variable_get(:@editor)
+    editor.place('draft', 2)
+    console.instance_variable_set(:@focus, :animation)
+    [:paste_start, ' ', "\n", 'x', :paste_end].each { |key| console.handle(key) }
+    expect(editor.text).to eq("dr \nxaft")
+    expect(editor.cursor).to eq(5)
+    expect(console.instance_variable_get(:@focus)).to eq(:mission)
   end
 
   it 'toggles the pane with Ctrl+T and opens swarm with Ctrl+S' do

data/third_party/pwn_rdoc.jsonl

@@ -487,9 +487,10 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.wrap_untrusted_tool Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.wrap_untrusted_tool`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.write_or_read_evidenced? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.write_or_read_evidenced?`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop.write_verified? Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop.write_verified?`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::ProviderWindow.model Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::ProviderWindow.model`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::ProviderWindow.request_model_cancel Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::ProviderWindow.request_model_cancel`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::Steering.new Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::Steering.new`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::Steering.checkpoint Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::Steering.checkpoint`: "}]}
-{"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::Steering.model Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::Steering.model`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::Steering.submit Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::Steering.submit`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::Steering.with_reader Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::Steering.with_reader`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::Loop::Steering::Restart.new Usage"},{"role":"assistant","content":"`PWN::AI::Agent::Loop::Steering::Restart.new`: "}]}
@@ -1734,6 +1735,7 @@
 {"messages":[{"role":"user","content":"PWN::Banner.mini_asteroids Usage"},{"role":"assistant","content":"`PWN::Banner.mini_asteroids`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_asteroids_snapshot Usage"},{"role":"assistant","content":"`PWN::Banner.mini_asteroids_snapshot`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_block_board Usage"},{"role":"assistant","content":"`PWN::Banner.mini_block_board`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner.mini_block_plan Usage"},{"role":"assistant","content":"`PWN::Banner.mini_block_plan`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_cells Usage"},{"role":"assistant","content":"`PWN::Banner.mini_cells`: Supported Method Parameters\n\nReturn rows of single-column Unicode block cells, with named terminal colors. Each fresh cell has glyph, foreground and background keys; no ANSI or IO. Square means terminal-cell dimensions, not physical pixels. Caller owns borders. Use mini_frame_seconds for cadence; 1800 frames span 90 or 180 seconds. Colored blocks fill the canvas with half-cell pieces; other games cap at 16. PWN::Banner.mini_cells(\n\nname: 'optional - falling_blocks, snake, pong, or asteroids; defaults to falling_blocks',\nframe: 'optional - integer index, defaults to zero and wraps at 1800',\nwidth: 'optional - columns clamped to 0..64 for blocks, 0..16 otherwise; defaults to 16',\nheight: 'optional - rows clamped to 0..64 for blocks, 0..16 otherwise; defaults to 16',\nseed: 'optional - integer local PRNG seed, defaults to 73; retain per session',\nbranding: 'optional - include the legacy wordmark, defaults to true; false reclaims its row'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_delta Usage"},{"role":"assistant","content":"`PWN::Banner.mini_delta`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_emit Usage"},{"role":"assistant","content":"`PWN::Banner.mini_emit`: "}]}
@@ -1745,6 +1747,7 @@
 {"messages":[{"role":"user","content":"PWN::Banner.mini_landing Usage"},{"role":"assistant","content":"`PWN::Banner.mini_landing`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_names Usage"},{"role":"assistant","content":"`PWN::Banner.mini_names`: Supported Method Parameters\n\nList animation names; callers may sample once and retain the session choice. PWN::Banner.mini_names\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_pixel Usage"},{"role":"assistant","content":"`PWN::Banner.mini_pixel`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner.mini_play_piece Usage"},{"role":"assistant","content":"`PWN::Banner.mini_play_piece`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_pong Usage"},{"role":"assistant","content":"`PWN::Banner.mini_pong`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_pong_snapshot Usage"},{"role":"assistant","content":"`PWN::Banner.mini_pong_snapshot`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_quarter_board Usage"},{"role":"assistant","content":"`PWN::Banner.mini_quarter_board`: "}]}
@@ -1786,6 +1789,13 @@
 {"messages":[{"role":"user","content":"PWN::Banner::Matrix.get Usage"},{"role":"assistant","content":"`PWN::Banner::Matrix.get`: Supported Method Parameters\n\nPWN::Banner::Matrix.get\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner::Matrix.help Usage"},{"role":"assistant","content":"`PWN::Banner::Matrix.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner::Matrix.you? Usage"},{"role":"assistant","content":"`PWN::Banner::Matrix.you?`: Supported Method Parameters\n\nPWN::Banner::Matrix.has_you\n"}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.new Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.new`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.<< Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.<<`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.cells Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.cells`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.controls Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.controls`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.key Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.key`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.length Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.length`: "}]}
+{"messages":[{"role":"user","content":"PWN::Banner::MiniGame.step Usage"},{"role":"assistant","content":"`PWN::Banner::MiniGame.step`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner::Ninja.authors Usage"},{"role":"assistant","content":"`PWN::Banner::Ninja.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner::Ninja.get Usage"},{"role":"assistant","content":"`PWN::Banner::Ninja.get`: Supported Method Parameters\n\nPWN::Banner::Ninja.get\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner::Ninja.help Usage"},{"role":"assistant","content":"`PWN::Banner::Ninja.help`: "}]}
@@ -3339,6 +3349,7 @@
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.footer_lines Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.footer_lines`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.footer_text Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.footer_text`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.handle Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.handle`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.handle_animation Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.handle_animation`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.handle_details Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.handle_details`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.handle_model_prompt Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.handle_model_prompt`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.handle_search Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.handle_search`: "}]}
@@ -3354,6 +3365,7 @@
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.open_swarm Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.open_swarm`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.open_system_role Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.open_system_role`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.operation_lines Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.operation_lines`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.playable_banner Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.playable_banner`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.prepare_swarm_mission Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.prepare_swarm_mission`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.put Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.put`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.put_spans Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.put_spans`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.759
+  version: 0.5.760
 platform: ruby
 authors:
 - 0day Inc.
@@ -505,14 +505,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.6.1
+        version: 1.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.6.1
+        version: 1.7.0
 - !ruby/object:Gem::Dependency
   name: meshtastic
   requirement: !ruby/object:Gem::Requirement