pwn 0.5.762 → 0.5.763

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 20f94659af48e0dba30534ed36cfaf8942497dcc5851e346a44ef40c51abb130
-  data.tar.gz: 8f91abcce730d25f6721d89aa6389090aa572b40ffe7449cd419a874d15d1932
+  metadata.gz: fec3b367c44874a819aa4892a5b3c507cf858ed4649eb31d295b0509e8747c83
+  data.tar.gz: d8a004b8eee5f7bd996ae8c9208f895d93354b09f9149050cb3e93d8632fda8c
 SHA512:
-  metadata.gz: 8174ba5855b3cb25e41eabe9c34a57add502f6b1d52caef2809bd603e66eab5dd1a169e01e1e06feb5c745ffddaa817fbaae9748458933c35c727a5a9c18b736
-  data.tar.gz: 111e5b05d8ad0c54f82ba0ae1836fb9ab1f8f3c1845c992d2dbacf7a241286e6ea139c9714d91e58ee80a246a119bdadf59e71d6a0f65e30fc224b96a9de2b7a
+  metadata.gz: 7490168d3e50c940ff771fe6788f7373e89b15f96541a8d0cec29bd13b1cccdce7c377799a415628fcd899a0e912928bf3aeb5fef68c0cf0fda2217871f60d95
+  data.tar.gz: eb50e5646ee60e9394f92139b61c38901303fc6167b06f95cf559a413d88a09dbfa21eadeb1e46e8e9418295d348e53f81a62d4d4f25956ebb0284f7e9c2e572

data/Gemfile

@@ -77,7 +77,7 @@ gem 'rbvmomi2', '3.10.0'
 gem 'rdoc', '7.0.4'
 gem 'rest-client', '2.1.0'
 gem 'rex', '2.0.13'
-gem 'rmagick', '7.1.6'
+gem 'rmagick', '7.1.7'
 gem 'rqrcode', '3.2.0'
 gem 'rspec', '3.13.2'
 gem 'rtesseract', '3.1.4'

data/documentation/Banner.md

@@ -14,4 +14,22 @@ welcome-banner          # REPL command: redraw a random one
 
 Add your own: drop a module in `lib/pwn/banner/` implementing `self.get`.
 
+## pwn-ai startup pane
+
+The curses console starts with a white miniature derived directly from
+`PWN::Banner::WhiteRabbit.get`, without its dedication or wordmark. The full
+banner remains unchanged. The rabbit is centered and aspect-contained in the
+current pane: small panes use area-filtered 3×6 character strokes packed into
+ordinary 2×4 Braille text dots; when the original ASCII fits, it is displayed
+verbatim, centered without enlargement. This assumes typical 1:2 terminal cells.
+Small panes lose punctuation detail, and Braille dot spacing depends on the font;
+physically tiny panes cannot retain a recognizable rabbit. No image protocol,
+image file, graphics probe or runtime image library is used.
+
+No games or replays are computed until the animation pane first receives focus
+via Ctrl+T/Ctrl+X. That enables games for the console lifetime. Ctrl+G cycles
+games while focused; leaving the pane keeps the existing automatic animation,
+not the startup rabbit. Resizing, modal input priority and the mission draft
+retain their existing behavior. Monochrome terminals keep the same geometry.
+
 [← Home](Home.md)

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

@@ -720,6 +720,7 @@ module PWN
               @menu = nil
               panes = @header_pane_height ? %i[mission session animation] : %i[mission session]
               @focus = panes[(panes.index(@focus).to_i + 1) % panes.length]
+              @banner_activated = true if @focus == :animation
               @banner_game&.controls
               @banner_game_tick = nil
               return
@@ -1227,6 +1228,9 @@ module PWN
           # Artwork has no worker, IO, or request-progress meaning. The existing
           # event-loop repaint supplies its clock, including while requests run.
           def banner_frame(size, cells: false)
+            # Startup is artwork only. Once focused, retain the existing seeded
+            # automatic behavior on leaving the game; never return to the splash.
+            @banner_activated ||= @focus == :animation
             now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             session = @pry.config.pwn_ai_session_id.to_s
             if @banner_session != session
@@ -1236,6 +1240,11 @@ module PWN
               @banner_seed = session.bytes.reduce(PWN::Banner::MINI_SEED) { |seed, byte| ((seed * 33) ^ byte) & 0xffffffff }
               @banner_started = now
             end
+            unless @banner_activated
+              art = rabbit_cells(size)
+              return cells ? art : art.map { |row| row.map { |cell| cell[:glyph] }.join }
+            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
@@ -1249,6 +1258,97 @@ module PWN
             canvas
           end
 
+          # Rasterize the actual banner's punctuation, not a replacement rabbit.
+          # These 3x6 character strokes retain the usual 1:2 terminal-cell aspect.
+          # Only the dedication and wordmark are omitted; the full banner API is
+          # unchanged. At native size use its original characters verbatim.
+          RABBIT_STROKES = {
+            ' ' => [0, 0, 0, 0, 0, 0], '_' => [0, 0, 0, 0, 0, 7],
+            '/' => [1, 1, 2, 2, 4, 4], '\\' => [4, 4, 2, 2, 1, 1],
+            '{' => [1, 2, 2, 4, 2, 1], '}' => [4, 2, 2, 1, 2, 4],
+            'Y' => [5, 5, 2, 2, 2, 2], '.' => [0, 0, 0, 0, 0, 2],
+            '-' => [0, 0, 0, 7, 0, 0], '"' => [5, 5, 0, 0, 0, 0],
+            '`' => [4, 2, 0, 0, 0, 0], ',' => [0, 0, 0, 0, 2, 4],
+            ';' => [0, 2, 0, 0, 2, 4], '|' => [2, 2, 2, 2, 2, 2]
+          }.transform_values(&:freeze).freeze
+          RABBIT_DOTS = [[0, 0, 1], [0, 1, 2], [0, 2, 4], [1, 0, 8], [1, 1, 16], [1, 2, 32], [0, 3, 64], [1, 3, 128]].map(&:freeze).freeze
+
+          def rabbit_source
+            @rabbit_source ||= begin
+              rows = PWN::Banner::WhiteRabbit.get.uncolorize.lines.map { |line| line.sub('R.I.P. Houdini', '').sub('pwn', '').rstrip }
+              rows.shift while rows.first&.strip == ''
+              rows.pop while rows.last&.strip == ''
+              left = rows.reject { |row| row.strip.empty? }.map { |row| row.index(/\S/) }.min
+              rows.map { |row| row[left..].to_s.freeze }.freeze
+            end
+          end
+
+          def rabbit_cells(size)
+            size = [size.to_i, 0].max
+            return [] if size.zero?
+            return @rabbit_cells if @rabbit_size == size
+
+            @rabbit_size = size
+            rows = rabbit_source
+            columns = rows.map(&:length).max
+            if size >= [columns, rows.length].max
+              left = (size - columns) / 2
+              top = (size - rows.length) / 2
+              return @rabbit_cells = Array.new(size) do |y|
+                Array.new(size) do |x|
+                  glyph = y.between?(top, top + rows.length - 1) && x.between?(left, left + columns - 1) ? rows[y - top][x - left] : nil
+                  { glyph: glyph || ' ', foreground: :white, background: :black }.freeze
+                end.freeze
+              end.freeze
+            end
+
+            source_width = columns * 3
+            source = rows.flat_map do |row|
+              6.times.map do |y|
+                row.ljust(columns).chars.reduce(0) { |bits, char| (bits << 3) | RABBIT_STROKES.fetch(char)[y] }
+              end
+            end
+            # Square Braille dots contain the same physical aspect as the ASCII
+            # source. Fractional area sampling keeps thin punctuation on shrink.
+            scale = [size * 2.0 / source_width, size * 4.0 / source.length].min
+            width = [(source_width * scale).round, 1].max
+            height = [(source.length * scale).round, 1].max
+            left = ((size * 2) - width) / 2
+            top = ((size * 4) - height) / 2
+            threshold = size < 5 ? 0.02 : 0.12
+            @rabbit_cells = Array.new(size) do |y|
+              Array.new(size) do |x|
+                mask = RABBIT_DOTS.sum do |dx, dy, bit|
+                  px = (x * 2) + dx - left
+                  py = (y * 4) + dy - top
+                  next 0 unless px.between?(0, width - 1) && py.between?(0, height - 1)
+
+                  coverage = rabbit_coverage(source, source_width, [px.fdiv(width), py.fdiv(height), (px + 1).fdiv(width), (py + 1).fdiv(height)])
+                  coverage >= threshold ? bit : 0
+                end
+                { glyph: mask.zero? ? ' ' : (0x2800 + mask).chr(Encoding::UTF_8), foreground: :white, background: :black }.freeze
+              end.freeze
+            end.freeze
+          end
+
+          # Fractional box-area coverage avoids nearest-neighbour holes.
+          def rabbit_coverage(source, source_width, bounds)
+            left, top, right, bottom = bounds
+            left *= source_width
+            right *= source_width
+            top *= source.length
+            bottom *= source.length
+            ink = (top.floor...bottom.ceil).sum do |y|
+              overlap_y = [y + 1, bottom].min - [y, top].max
+              (left.floor...right.ceil).sum do |x|
+                next 0 unless source[y][source_width - 1 - x] == 1
+
+                ([x + 1, right].min - [x, left].max) * overlap_y
+              end
+            end
+            ink.fdiv((right - left) * (bottom - top))
+          end
+
           def automatic_banner(size, now)
             key = [@banner_session, @banner_name, size, @banner_seed]
             if @banner_demo_key != key
@@ -1296,7 +1396,7 @@ module PWN
               row.first(size).each_with_index do |cell, x|
                 index = PALETTE.index(cell[:foreground].to_s)
                 background = PALETTE.index(cell[:background].to_s)
-                colors = @banner_colors && (@banner_name != :falling_blocks || @banner_two_colors)
+                colors = @banner_colors && (!@banner_activated || @banner_name != :falling_blocks || @banner_two_colors)
                 pair = if colors && index && background && (background == 7 || @banner_two_colors)
                          background == 7 ? 9 + index : 17 + (background * 8) + index
                        end

data/lib/pwn/version.rb

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

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

@@ -515,6 +515,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     pry = Pry.new
     pry.config.pwn_ai_session_id = 'banner-one'
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: pry, input: StringIO.new, curses: nil, getch: nil)
+    console.instance_variable_set(:@banner_activated, true)
     choices = PWN::Banner.mini_names.first(2)
     allow(PWN::Banner).to receive(:mini_names).and_return(choices)
     allow(choices).to receive(:sample).and_return(*choices)
@@ -536,6 +537,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
 
   it 'centers capped retro artwork inside a larger cell-square canvas' do
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    console.instance_variable_set(:@banner_activated, true)
     allow(PWN::Banner).to receive(:mini_names).and_return([:pacman])
     allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0)
     size = 24
@@ -551,6 +553,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
 
   it 'paints falling blocks against the actual pane floor even beyond sixteen cells' do
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    console.instance_variable_set(:@banner_activated, true)
     allow(PWN::Banner).to receive(:mini_names).and_return([:falling_blocks])
     now = 100.0
     allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC) { now }
@@ -594,7 +597,8 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     expect(painted.select { |y, x, _text, _color| y < 10 && x < 10 }.map { |_, _, text| text }.join).not_to match(/[PWN]/)
     expect(painted.select { |y, x, text, _color| y.between?(1, 8) && x == 1 && text == ' ' * 8 }.length).to eq(8)
     expect(painted.select { |y, _x, _text, _color| y < 10 }).to all(satisfy { |y, x, text, _color| y >= 0 && x >= 0 && x + console.width(text) <= 120 })
-    expect(PWN::Banner).to have_received(:mini_cells).with(hash_including(width: 8, height: 8)).once
+    expect(PWN::Banner).not_to have_received(:mini_cells)
+    expect(console.banner_frame(8, cells: true).flatten.map { |cell| cell[:foreground] }.uniq).to eq([:white])
     [[80, 36], [120, 24]].each do |columns, rows|
       allow(curses).to receive_messages(cols: columns, lines: rows)
       rectangles.clear
@@ -607,7 +611,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     console.draw
     expect(console.instance_variable_get(:@header_text_column)).to eq(2)
     expect(console.header_lines('ollama', 'fixture', 115).length).to be > 16
-    expect(PWN::Banner).to have_received(:mini_cells).once
+    expect(PWN::Banner).not_to have_received(:mini_cells)
     expect([console.instance_variable_get(:@editor).text, console.instance_variable_get(:@editor).cursor]).to eq(['retained draft', 4])
   end
 
@@ -641,6 +645,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
     console.instance_variable_set(:@width, 120)
     console.instance_variable_set(:@height, 40)
+    console.instance_variable_set(:@banner_activated, true)
     allow(console).to receive(:put)
     allow(console).to receive(:box)
     allow(PWN::Banner).to receive(:mini_cells).and_call_original
@@ -710,6 +715,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     pry = Pry.new
     pry.config.pwn_ai_session_id = 'colored-session'
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: pry, input: StringIO.new, curses: nil, getch: nil)
+    console.instance_variable_set(:@banner_activated, true)
     names = [:snake]
     allow(PWN::Banner).to receive(:mini_names).and_return(names)
     expect(names).to receive(:sample).twice.and_return(:snake)
@@ -734,6 +740,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
       pry = Pry.new
       pry.config.pwn_ai_session_id = 'fast-colored-session'
       console = PWN::Plugins::REPL::AIConsole::Console.new(pry: pry, input: StringIO.new, curses: nil, getch: nil)
+      console.instance_variable_set(:@banner_activated, true)
       names = PWN::Banner.mini_names
       allow(PWN::Banner).to receive(:mini_names).and_return(names)
       expect(names).to receive(:sample).once.and_return(name)
@@ -1120,6 +1127,144 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     expect(console.instance_variable_get(:@focus)).to eq(:mission)
   end
 
+  it 'shows only the white rabbit before the first animation focus without computing games' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    expect(PWN::Banner).not_to receive(:mini_cells)
+    expect(PWN::Banner).not_to receive(:mini_frame)
+    expect(PWN::Banner::MiniGame).not_to receive(:new)
+    first = console.banner_frame(8, cells: true)
+    expect(first.flatten.map { |cell| cell[:foreground] }.uniq).to eq([:white])
+    expect(first.flatten.count { |cell| cell[:glyph] != ' ' }).to be > 16
+    console.instance_variable_set(:@header_pane_height, 10)
+    console.handle("\u0014")
+    expect(console.banner_frame(8, cells: true)).to eq(first)
+    expect(console.banner_frame(8).join).not_to match(/[PWN]/)
+  end
+
+  it 'uses fine two by four text dots without terminal image output' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    [8, 12, 16, 18].each do |size|
+      glyphs = console.banner_frame(size, cells: true).flatten.map { |cell| cell[:glyph] }
+      expect(glyphs).to all(match(/\A[ \u2801-\u28ff]\z/))
+      expect(glyphs.uniq.length).to be > 4
+    end
+    source = File.read(File.expand_path('../../../../../lib/pwn/plugins/repl/ai_console.rb', __dir__))
+    expect(source).not_to include('graphics_response?', '\\e_G')
+  end
+
+  it 'area-filters fractional source pixels instead of losing a bend to point sampling' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    expect(console.rabbit_coverage([0b10, 0b01], 2, [0, 0, 1, 1])).to eq(0.5)
+    expect(console.rabbit_coverage([0b10, 0b01], 2, [0.25, 0, 0.75, 0.5])).to eq(0.5)
+    expect(console.rabbit_coverage([0b10, 0b01], 2, [0, 0, 0.5, 0.5])).to eq(1.0)
+    expect(console.rabbit_coverage([0b10, 0b01], 2, [0.5, 0, 1, 0.5])).to eq(0.0)
+  end
+
+  it 'derives every source row from WhiteRabbit.get and preserves the native art without labels' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    source = PWN::Banner::WhiteRabbit.get.uncolorize
+    expect(PWN::Banner::WhiteRabbit).to receive(:get).once.and_return(source)
+    rows = source.lines.map { |row| row.sub('R.I.P. Houdini', '').sub('pwn', '').rstrip }.reject(&:empty?).map { |row| row[8..] }
+    expect(console.rabbit_source).to eq(rows)
+    expect(rows.join.chars.uniq - PWN::Plugins::REPL::AIConsole::Console::RABBIT_STROKES.keys).to be_empty
+    [22, 34, 64].each do |size|
+      art = console.banner_frame(size)
+      top = (size - rows.length) / 2
+      left = (size - rows.map(&:length).max) / 2
+      rows.each_with_index { |row, y| expect(art[top + y][left, row.length]).to eq(row) }
+      expect(art.join).not_to match(/pwn|Houdini|\e/)
+    end
+  end
+
+  it 'contains the rabbit with centered aspect-correct padding across tiny resizes' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    expect(PWN::Banner::MiniGame).not_to receive(:new)
+    expect(console.banner_frame(0, cells: true)).to eq([])
+    [1, 2, 3, 5, 8, 12, 13, 14, 16, 18, 8].each do |size|
+      cells = console.banner_frame(size, cells: true)
+      expect(cells.length).to eq(size)
+      expect(cells.map(&:length)).to all(eq(size))
+      expect(cells.flatten.map { |cell| [cell[:foreground], cell[:background]] }.uniq).to eq([%i[white black]])
+      points = []
+      cells.each_with_index do |row, y|
+        row.each_with_index do |cell, x|
+          next if cell[:glyph] == ' '
+
+          mask = cell[:glyph] == ' ' ? 0 : cell[:glyph].ord - 0x2800
+          expect(mask).not_to be_nil
+          [[0, 0, 1], [0, 1, 2], [0, 2, 4], [0, 3, 64], [1, 0, 8], [1, 1, 16], [1, 2, 32], [1, 3, 128]].each do |dx, dy, bit|
+            points << [(x * 2) + dx, (y * 4) + dy] if mask.anybits?(bit)
+          end
+        end
+      end
+      expect(points).not_to be_empty
+      next if size < 8
+
+      xs, ys = points.transpose
+      ratio = console.rabbit_source.map(&:length).max.fdiv(console.rabbit_source.length * 2)
+      expect((xs.max - xs.min + 1).fdiv(ys.max - ys.min + 1)).to be_within(0.1).of(ratio)
+      expect((xs.min - ((size * 2) - 1 - xs.max)).abs).to be <= 2
+      expect((ys.min - ((size * 4) - 1 - ys.max)).abs).to be <= 2
+      expect(points.length).to be > size * 3
+      expect(cells.flatten.map { |cell| cell[:glyph] }.uniq.length).to be > 4
+      expect(console.banner_frame(size, cells: true)).to equal(cells)
+    end
+  end
+
+  it 'paints only white with a 64-pair palette and keeps rabbit geometry in monochrome' do
+    [false, true].each do |no_color|
+      curses = double(has_colors?: true, start_color: nil, use_default_colors: nil, init_pair: nil, color_pairs: 64)
+      console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: curses, getch: nil)
+      allow(ENV).to receive(:key?).with('NO_COLOR').and_return(no_color)
+      allow(PWN::Banner).to receive(:mini_names).and_return([:falling_blocks])
+      console.setup_colors
+      painted = []
+      allow(console).to receive(:put) { |*args| painted << args }
+      console.draw_banner(8)
+      ink = painted.reject { |_, _, glyph, _| glyph.strip.empty? }
+      expect(ink).not_to be_empty
+      white = 9 + PWN::Plugins::REPL::AIConsole::Console::PALETTE.index('white')
+      expect(ink.map(&:last).uniq).to eq([no_color ? nil : white])
+      expect(ink.map { |_, _, glyph, _| glyph }).to all(match(/[\u2801-\u28ff]/))
+    end
+  end
+
+  it 'activates once on actual focus, cycles games and never restores the splash on return' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    allow(PWN::Banner).to receive(:mini_names).and_return(%i[snake pacman])
+    allow(Process).to receive(:clock_gettime).and_return(10.0)
+    splash = console.banner_frame(8, cells: true)
+    console.instance_variable_set(:@header_pane_height, 10)
+    2.times { console.handle("\u0014") }
+    console.banner_frame(8, cells: true)
+    game = console.instance_variable_get(:@banner_game)
+    expect(game).to be_a(PWN::Banner::MiniGame)
+    console.handle("\e")
+    expect(console.banner_frame(8, cells: true)).not_to eq(splash)
+    2.times { console.handle("\u0018") }
+    console.banner_frame(8, cells: true)
+    expect(console.instance_variable_get(:@banner_game)).to equal(game)
+    name = console.instance_variable_get(:@banner_name)
+    console.handle("\u0007")
+    console.banner_frame(8, cells: true)
+    expect(console.instance_variable_get(:@banner_name)).not_to eq(name)
+    expect(console.instance_variable_get(:@banner_game)).not_to equal(game)
+    console.handle("\e")
+    expect(console.banner_frame(12, cells: true)).not_to eq(console.rabbit_cells(12))
+  end
+
+  it 'does not activate games when the pane is hidden or focus keys belong to a modal' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    expect(PWN::Banner::MiniGame).not_to receive(:new)
+    4.times { console.handle("\u0014") }
+    expect(console.instance_variable_get(:@banner_activated)).to be_nil
+    console.instance_variable_set(:@header_pane_height, 10)
+    console.instance_variable_set(:@details, 0)
+    expect(console).to receive(:handle_details).with("\u0018")
+    console.handle("\u0018")
+    expect(console.banner_frame(8, cells: true)).to eq(console.rabbit_cells(8))
+  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)
@@ -1249,6 +1394,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
   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)
+    console.instance_variable_set(:@banner_activated, true)
     automatic = console.banner_frame(8, cells: true)
     console.instance_variable_set(:@header_pane_height, 10)
     2.times { console.handle("\u0014") }
@@ -1263,6 +1409,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
   it 'streams the new arcade demos on the UI owner without a synchronous full replay build' do
     %i[pacman galaga frogger].each do |name|
       console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+      console.instance_variable_set(:@banner_activated, true)
       allow(PWN::Banner).to receive(:mini_names).and_return([name])
       allow(Process).to receive(:clock_gettime).and_return(10.0)
       expect(PWN::Banner).not_to receive(:mini_cells)

data/third_party/pwn_rdoc.jsonl

@@ -3405,6 +3405,9 @@
 {"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`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.rabbit_cells Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.rabbit_cells`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.rabbit_coverage Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.rabbit_coverage`: "}]}
+{"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.rabbit_source Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.rabbit_source`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.refresh_completion Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.refresh_completion`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.refresh_swarm Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.refresh_swarm`: "}]}
 {"messages":[{"role":"user","content":"PWN::Plugins::REPL::AIConsole::Console.restore_streams Usage"},{"role":"assistant","content":"`PWN::Plugins::REPL::AIConsole::Console.restore_streams`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.762
+  version: 0.5.763
 platform: ruby
 authors:
 - 0day Inc.
@@ -897,14 +897,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.6
+        version: 7.1.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.6
+        version: 7.1.7
 - !ruby/object:Gem::Dependency
   name: rqrcode
   requirement: !ruby/object:Gem::Requirement