pwn 0.5.751 → 0.5.754

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 370b89e2788788896b95041a37ef33082bf4e32f753deae04778b27262660d37
-  data.tar.gz: 397bc93f10ee8a9b9f891c447b47b268b6d6526005762b97fd8cc94102c62053
+  metadata.gz: e01b8e88574a241d780acc3e2c4d70a7e5c07fb1e9e17fa709363a4bfcbc7898
+  data.tar.gz: f50a1f5f35d25f300c396678edb5daa8119f4fca9e1567d71652c7f45bcc1dcb
 SHA512:
-  metadata.gz: 9c92bca139bd4a6b8c6e8ce32a0ce79505ecc495586f9aa36e89a829c1007508f380e1c84603dfd19ddbba7b7c2dffececdedc3232efd93dc87affc3270119db
-  data.tar.gz: 1ab472b60a58d992e9513d9e8a5d668ce6b543bc83109c8c04a6ac563d71baae399ea47184e5cc145bd5aa01a750d00f2ec273456cc40077f205c996726e513f
+  metadata.gz: c34deaa7b6835b37cacb76a2863cb0759b4dc727301692014702468aa3d4a04ddc1c76fda3893005f58071b9060768ade05401dbbae1cac2fc3dbfc99bcfa9f0
+  data.tar.gz: de481a34a2b3776fa8003094618af168f6a33341fd236e14daa3247694e8e703e0eddb15ea74556e9bd4814a14a3187d48f51c18be90094f1bd4c83ddcd364b8

data/Gemfile

@@ -20,7 +20,7 @@ gem 'base32', '0.3.4'
 gem 'bitcoin-ruby', '0.0.20'
 gem 'brakeman', '8.0.6'
 gem 'bson', '5.2.0'
-gem 'bundler', '>=4.0.21'
+gem 'bundler', '>=4.0.22'
 gem 'bundler-audit', '>=0.9.3'
 gem 'bunny', '3.4.0'
 gem 'colorize', '1.1.0'
@@ -57,7 +57,7 @@ gem 'msfrpc-client', '1.1.2'
 gem 'netaddr', '2.0.6'
 gem 'net-ldap', '0.20.0'
 gem 'net-openvpn', '0.8.7'
-gem 'net-smtp', '0.5.1'
+gem 'net-smtp', '0.5.2'
 gem 'nexpose', '7.3.0'
 gem 'nokogiri', '1.19.4'
 gem 'nokogiri-diff', '0.3.0'

data/documentation/pwn-ai-Agent.md

@@ -31,7 +31,9 @@ its seeded autonomous flight is decorative, not player-controlled.
 Its framed width in terminal cells equals the complete header's height in rows;
 the interior canvas is `(header height - 2)` cells on each side. This is a
 cell-square, not a pixel-square—terminal glyph cells are usually taller than wide.
-Falling blocks fill the entire interior below the PWN wordmark, including the
+The animation pane has no wordmark; its former label row belongs to gameplay.
+The main `pwn-ai` header title and full-screen static banners are unchanged.
+Falling blocks fill the entire interior, including the
 bottom two quadrants. Each logical block occupies one horizontal half-cell from
 spawn through landing and locking. This deliberately replaces independent
 quarter-cell blocks: a terminal cell has only a foreground and background, so
@@ -51,11 +53,13 @@ changing the active session selects again. Frames advance at the banner API's
 blocks/snake) using monotonic time in the existing render loop—no extra animation
 thread, input reader or provider call. This is decoration, not progress or
 telemetry. The frame keeps the existing border/title theme roles. Artwork comes
-from `PWN::Banner.mini_cells` with dedicated foreground/background curses pairs,
+from `PWN::Banner.mini_cells(branding: false)` with dedicated foreground/background curses pairs,
 not ANSI output or theme overrides. `NO_COLOR` and terminals with too few color
 pairs retain occupied geometry in monochrome (two differently colored occupied
 halves become a full block, not a half-block with its background lost). The `mini_frame` ASCII API
-retains its 60-frame, 0.1-second loops for other callers. Colored replays contain
+retains its 60-frame, 0.1-second loops for other callers. Both miniature APIs
+default to their legacy branding; `branding: false` reclaims the label row and
+leaves undersized fallback panes blank. Colored replays contain
 1800 frames (90 seconds for Pong/Asteroids, 180 for blocks/snake), use a local
 per-session seed, and share a bounded six-replay cache. Settings
 wrap in the right-hand region without losing their label colors. A bounded,

data/etc/default_skills/pwn/banner/SKILL.md

@@ -12,7 +12,7 @@ metadata:
 
 # PWN::Banner
 
-Static banners and pure, PWN-branded retro ASCII/color loops: falling_blocks, snake, pong, and asteroids. mini_frame returns fresh rows on a borderless canvas; use equal width and height (5..16) for complete square artwork. Dimensions clamp to 0..16 (colored blocks: 0..64), with tiny panes showing a wordmark. The caller samples mini_names once per session and advances the explicit frame index every mini_frame_seconds(name:) (0.05 for Pong/Asteroids, 0.1 otherwise). mini_cells replays 1800 seeded gameplay frames (MINI_FRAME_COUNT); mini_frame retains its legacy 60-frame ASCII loop. These are decorative game simulations, not interactive games or telemetry. mini_cells uses local Random.new with seed 73 by default; callers may keep a different integer seed per session. Six immutable replays are cached. Tetrominoes stack and clear; snake pursues food and grows; Pong rallies include imperfect paddle tracking, misses and score pips between serves. Blocks use horizontal half-cells with independent foreground/background colors, filling the pane below PWN (up to 64 cells). Other games retain quadrant pixels; snake stays centered with food/head color priority. White line-clear flashes and game-over/reset wipes are intentional. Pong uses half-cell motion and one-cell-high paddles without speeding up play. Asteroids uses five-pixel cyan arrowheads on a half-cell grid, sparse small white rocks, yellow shots and red thrust; wrapped collisions split real rocks. Static Banner modules autoload only when needed. For more information, see: http://www.rubyinside.com/ruby-techniques-revealed-autoload-1652.html
+Static banners and pure, PWN-branded retro ASCII/color loops: falling_blocks, snake, pong, and asteroids. mini_frame returns fresh rows on a borderless canvas; use equal width and height (5..16) for complete square artwork. Dimensions clamp to 0..16 (colored blocks: 0..64). Set branding: false for an unbranded pane with the wordmark row reclaimed for play; tiny panes then stay blank. The caller samples mini_names once per session and advances the explicit frame index every mini_frame_seconds(name:) (0.05 for Pong/Asteroids, 0.1 otherwise). mini_cells replays 1800 seeded gameplay frames (MINI_FRAME_COUNT); mini_frame retains its legacy 60-frame ASCII loop. These are decorative game simulations, not interactive games or telemetry. mini_cells uses local Random.new with seed 73 by default; callers may keep a different integer seed per session. Six immutable replays are cached. Tetrominoes stack and clear; snake pursues food and grows; Pong rallies include imperfect paddle tracking, misses and score pips between serves. Blocks use horizontal half-cells with independent foreground/background colors, filling the pane below PWN (up to 64 cells). Other games retain quadrant pixels; snake stays centered with food/head color priority. White line-clear flashes and game-over/reset wipes are intentional. Pong uses half-cell motion and one-cell-high paddles without speeding up play. Asteroids uses five-pixel cyan arrowheads on a half-cell grid, sparse small white rocks, yellow shots and red thrust; wrapped collisions split real rocks. Static Banner modules autoload only when needed. For more information, see: http://www.rubyinside.com/ruby-techniques-revealed-autoload-1652.html
 
 ## When to use
 

data/lib/pwn/ai/anthropic.rb

@@ -575,7 +575,7 @@ module PWN
             {
               name: fn[:name] || fn['name'],
               description: fn[:description] || fn['description'],
-              input_schema: fn[:parameters] || fn['parameters'] || { type: 'object', properties: {} }
+              input_schema: anthropic_input_schema(schema: fn[:parameters] || fn['parameters'])
             }
           end
           http_body[:tool_choice] = anth_tool_choice(choice: opts[:tool_choice]) if opts[:tool_choice]
@@ -598,6 +598,78 @@ module PWN
         raise e
       end
 
+      # Anthropic rejects oneOf, allOf, and anyOf at the root of input_schema.
+      # Return a deep copy with those root keys removed and branch properties merged.
+      # Nested combinators and the caller's schema stay unchanged.
+      private_class_method def self.anthropic_input_schema(opts = {})
+        schema = opts[:schema]
+        return { type: 'object', properties: {} } unless schema.is_a?(Hash)
+
+        copy = json_copy(value: schema)
+        notes = []
+        %w[anyOf oneOf allOf].each do |name|
+          key = anthropic_schema_key(schema: copy, name: name)
+          next unless key
+
+          Array(copy.delete(key)).each do |branch|
+            next unless branch.is_a?(Hash)
+
+            anthropic_schema_notes(branch: branch, notes: notes)
+            props = branch[:properties] || branch['properties']
+            next unless props.is_a?(Hash)
+
+            dest = copy.key?('properties') ? 'properties' : :properties
+            copy[dest] = {} unless copy[dest].is_a?(Hash)
+            props.each { |prop, spec| copy[dest][prop] = spec unless copy[dest].key?(prop) }
+          end
+        end
+        copy[:type] = 'object' unless copy.key?(:type) || copy.key?('type')
+        copy[:properties] = {} unless copy.key?(:properties) || copy.key?('properties')
+        unless notes.empty?
+          note = "One of these field sets is required: #{notes.uniq.join('; ')}."
+          copy[:description] = [copy[:description] || copy['description'], note].compact.reject { |part| part.to_s.empty? }.join(' ')
+          copy.delete('description')
+        end
+        copy
+      end
+
+      private_class_method def self.anthropic_schema_notes(opts = {})
+        branch = opts[:branch]
+        notes = opts[:notes]
+        return notes unless branch.is_a?(Hash) && notes.is_a?(Array)
+
+        required = branch[:required] || branch['required']
+        notes << required.join('+') if required.is_a?(Array) && required.any?
+        %w[anyOf oneOf allOf].each do |name|
+          key = anthropic_schema_key(schema: branch, name: name)
+          next unless key
+
+          Array(branch[key]).each { |child| anthropic_schema_notes(branch: child, notes: notes) }
+        end
+        notes
+      end
+
+      private_class_method def self.anthropic_schema_key(opts = {})
+        schema = opts[:schema]
+        name = opts[:name]
+        return name if schema.is_a?(Hash) && schema.key?(name)
+        return name.to_sym if schema.is_a?(Hash) && schema.key?(name.to_sym)
+
+        nil
+      end
+
+      private_class_method def self.json_copy(opts = {})
+        value = opts[:value]
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, item), out| out[key] = json_copy(value: item) }
+        when Array
+          value.map { |item| json_copy(value: item) }
+        else
+          value.is_a?(String) ? value.dup : value
+        end
+      end
+
       # OpenAI messages[] -> [system_string, anthropic messages[]]
       private_class_method def self.oa_messages_to_anthropic(opts = {})
         messages = opts[:messages] ||= []

data/lib/pwn/banner.rb

@@ -4,7 +4,8 @@ module PWN
   # Static banners and pure, PWN-branded retro ASCII/color loops: falling_blocks,
   # snake, pong, and asteroids. mini_frame returns fresh rows on a borderless canvas;
   # use equal width and height (5..16) for complete square artwork. Dimensions
-  # clamp to 0..16 (colored blocks: 0..64), with tiny panes showing a wordmark. The caller
+  # clamp to 0..16 (colored blocks: 0..64). Set branding: false for an unbranded
+  # pane with the wordmark row reclaimed for play; tiny panes then stay blank. The caller
   # samples mini_names once per session and advances the explicit frame index
   # every mini_frame_seconds(name:) (0.05 for Pong/Asteroids, 0.1 otherwise).
   # mini_cells replays 1800 seeded gameplay
@@ -98,7 +99,8 @@ module PWN
     #   name: 'optional - falling_blocks, snake, pong, or asteroids; defaults to falling_blocks',
     #   frame: 'optional - integer frame index, defaults to zero and wraps at 60',
     #   width: 'optional - output columns clamped to zero through 16, defaults to 16',
-    #   height: 'optional - output rows clamped to zero through 16, defaults to 16'
+    #   height: 'optional - output rows clamped to zero through 16, defaults to 16',
+    #   branding: 'optional - include the legacy wordmark, defaults to true; false reclaims its row'
     # )
 
     public_class_method def self.mini_frame(opts = {})
@@ -110,12 +112,16 @@ module PWN
       height = (opts[:height] || MINI_HEIGHT).to_i.clamp(0, MINI_HEIGHT)
       return [] if width.zero? || height.zero?
 
+      branding = opts[:branding] != false
+      return Array.new(height) { ' ' * width } if !branding && (width < 5 || height < 5)
+
+      height += 1 unless branding
       rows = Array.new(height) { ' ' * width }
       rows[0] = 'PWN'[0, width].center(width)
       return rows if width < 5 || height < 5
 
       send("mini_#{name}", rows: rows, phase: phase, width: width, height: height)
-      rows
+      branding ? rows : rows.drop(1)
     end
 
     # Supported Method Parameters::
@@ -150,7 +156,8 @@ module PWN
     #   frame: 'optional - integer index, defaults to zero and wraps at 1800',
     #   width: 'optional - columns clamped to 0..64 for blocks, 0..16 otherwise; defaults to 16',
     #   height: 'optional - rows clamped to 0..64 for blocks, 0..16 otherwise; defaults to 16',
-    #   seed: 'optional - integer local PRNG seed, defaults to 73; retain per session'
+    #   seed: 'optional - integer local PRNG seed, defaults to 73; retain per session',
+    #   branding: 'optional - include the legacy wordmark, defaults to true; false reclaims its row'
     # )
 
     public_class_method def self.mini_cells(opts = {})
@@ -163,10 +170,14 @@ module PWN
       height = (opts[:height] || MINI_HEIGHT).to_i.clamp(0, limit)
       return [] if width.zero? || height.zero?
 
+      branding = opts[:branding] != false
+      # Simulate one extra row before removing the legacy label, so every output
+      # row belongs to gameplay without changing the public dimension limits.
       rows = if width < 5 || height < 5
-               ['PWN'[0, width].center(width)] + Array.new(height - 1) { ' ' * width }
+               [branding ? 'PWN'[0, width].center(width) : ' ' * width] + Array.new(height - 1) { ' ' * width }
              else
-               mini_replay(name: name, width: width, height: height, seed: (opts[:seed] || MINI_SEED).to_i)[phase][:rows]
+               replay = mini_replay(name: name, width: width, height: height + (branding ? 0 : 1), seed: (opts[:seed] || MINI_SEED).to_i)
+               branding ? replay[phase][:rows] : replay[phase][:rows].drop(1)
              end
       rows.map do |row|
         row.chars.map do |pixel|
@@ -823,7 +834,8 @@ module PWN
           name: 'optional - falling_blocks, snake, pong, or asteroids; defaults to falling_blocks',
           frame: 'optional - integer frame index, defaults to zero and wraps at 60',
           width: 'optional - columns clamped to zero through 16; defaults to 16',
-          height: 'optional - rows clamped to zero through 16; defaults to 16'
+          height: 'optional - rows clamped to zero through 16; defaults to 16',
+          branding: 'optional - include the legacy wordmark, defaults to true; false reclaims its row'
         )
 
         # Return fresh Unicode block cells: { glyph:, foreground:, background: }.
@@ -838,7 +850,8 @@ module PWN
           frame: 'optional - integer frame index, defaults to zero and wraps at 1800',
           width: 'optional - columns clamped to 0..64 for blocks, 0..16 otherwise; defaults to 16',
           height: 'optional - rows clamped to 0..64 for blocks, 0..16 otherwise; defaults to 16',
-          seed: 'optional - integer local PRNG seed, defaults to 73; retain per session'
+          seed: 'optional - integer local PRNG seed, defaults to 73; retain per session',
+          branding: 'optional - include the legacy wordmark, defaults to true; false reclaims its row'
         )
 
         # Run welcome and return its result

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

@@ -1042,7 +1042,7 @@ module PWN
               put(top + row, left + box_width - 1, '│', color)
             end
             put(top + height - 1, left, "╰#{'─' * (box_width - 2)}╯", color)
-            put(top, left + 2, fit(" #{title} ", box_width - 4), tone(:title))
+            put(top, left + 2, fit(" #{title} ", box_width - 4), tone(:title)) unless title.empty?
           end
 
           def seed_request_history
@@ -1070,10 +1070,10 @@ module PWN
             role = cfg[:system_role_content].to_s.gsub(/\s+/, ' ').strip
             parts = []
             parts << "SYSTEM ROLE CONTENT: #{role}" unless role.empty?
-            parts << "\nTEMP: #{cfg[:temp]}" unless cfg[:temp].nil?
-            parts << " MAX TOKENS: #{cfg[:max_tokens]}" unless cfg[:max_tokens].nil?
+            parts << "\nMAX TOKENS: #{cfg[:max_tokens]}" unless cfg[:max_tokens].nil?
             parts << " MAX PROMPT LENGTH: #{cfg[:max_prompt_length]}" unless cfg[:max_prompt_length].nil?
-            parts << "\nREASONING EFFORT: #{cfg[:reasoning_effort]}" unless cfg[:reasoning_effort].to_s.empty?
+            parts << " REASONING EFFORT: #{cfg[:reasoning_effort]}" unless cfg[:reasoning_effort].to_s.empty?
+            parts << " TEMP: #{cfg[:temp]}" unless cfg[:temp].nil?
             parts.join(' · ')
           rescue StandardError
             ''
@@ -1138,9 +1138,9 @@ 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 PWN::Banner.mini_cells(name: @banner_name, frame: frame, width: size, height: size, seed: @banner_seed) if cells
+            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)
+            art = PWN::Banner.mini_frame(name: @banner_name, frame: frame, width: size, height: size, branding: false)
             canvas = Array.new(size) { ' ' * size }
             top = (size - art.length) / 2
             art.each_with_index { |row, index| canvas[top + index] = row.center(size) }
@@ -1208,7 +1208,7 @@ module PWN
             put(1, @header_text_column, fit("#{state} · #{elapsed} · #{scroll_status}", @header_text_width), tone(:status))
             visible.each_with_index { |spans, index| put_spans(2 + index, @header_text_column, spans) }
             if @header_pane_height
-              box(0, 0, height, height, 'PWN')
+              box(0, 0, height, height, '')
               draw_banner(height - 2)
             end
             height

data/lib/pwn/version.rb

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

data/spec/lib/pwn/ai/anthropic_spec.rb

@@ -58,4 +58,52 @@ describe PWN::AI::Anthropic do
       expect(src).to include('PromptCache.enabled?')
     end
   end
+
+  it 'drops root combinators from Anthropic input_schema without mutating registry schemas' do
+    allow(PWN::Env).to receive(:[]).with(:ai).and_return(
+      anthropic: { key: 'test-key', model: 'claude-test', temp: 1, max_tokens: 100 }
+    )
+    allow(PWN::AI::Agent::PromptCache).to receive(:enabled?).and_return(false) if defined?(PWN::AI::Agent::PromptCache)
+    tools = PWN::AI::Agent::Registry.definitions(core_only: true)
+    artifact = tools.find { |tool| tool.dig(:function, :name) == 'artifact_read' }
+    original = artifact[:function][:parameters]
+    nested = {
+      type: 'object',
+      properties: {
+        item: { anyOf: [{ type: 'string' }, { type: 'object', properties: { handle: { type: 'string' } } }] }
+      }
+    }
+    union = {
+      'anyOf' => [
+        { 'type' => 'object', 'properties' => { 'handle' => { 'type' => 'string' } }, 'required' => ['handle'] },
+        { 'type' => 'object', 'properties' => { 'path' => { 'type' => 'string' } }, 'required' => ['path'] }
+      ]
+    }
+    sent = tools + [
+      { type: 'function', function: { name: 'nested_union', description: 'keep nested', parameters: nested } },
+      { type: 'function', function: { name: 'root_union', description: 'flatten', parameters: union } }
+    ]
+    captured = nil
+    allow(described_class).to receive(:anthropic_rest_call) do |opts|
+      captured = opts[:http_body]
+      '{"id":"msg_schema","type":"message","role":"assistant","content":[{"type":"text","text":"ok"}],"stop_reason":"end_turn"}'
+    end
+
+    described_class.chat_with_tools(messages: [{ role: 'user', content: 'hello' }], tools: sent, model: 'claude-test')
+
+    expect(original).to have_key(:anyOf)
+    wire = captured[:tools]
+    expect(wire.map { |tool| tool[:name] }[10]).to eq('artifact_read')
+    wire.each do |tool|
+      schema = tool[:input_schema]
+      expect(schema.keys.map(&:to_s)).not_to include('anyOf', 'oneOf', 'allOf')
+    end
+    read_schema = wire[10][:input_schema]
+    expect(read_schema[:properties].keys.map(&:to_s)).to include('handle', 'path', 'ref')
+    expect(read_schema[:description]).to include('handle', 'path', 'ref')
+    expect(wire.find { |tool| tool[:name] == 'nested_union' }[:input_schema][:properties][:item]).to have_key(:anyOf)
+    flat = wire.find { |tool| tool[:name] == 'root_union' }[:input_schema]
+    expect(flat[:properties].keys.map(&:to_s)).to include('handle', 'path')
+    expect(flat[:description]).to include('handle', 'path')
+  end
 end

data/spec/lib/pwn/banner_spec.rb

@@ -3,6 +3,29 @@
 require 'spec_helper'
 
 describe PWN::Banner do
+  it 'reclaims the wordmark row for unbranded games and leaves tiny panes blank' do
+    described_class.mini_names.product([1, 3, 5, 8, 16]).each do |name, size|
+      [0, 6, 100, 1799].each do |frame|
+        args = { name: name, width: size, height: size, frame: frame, branding: false }
+        cells = described_class.mini_cells(**args)
+        ascii = described_class.mini_frame(**args)
+        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(ascii.length).to eq(size)
+        expect(ascii.map(&:length)).to all(eq(size))
+        expect(ascii.join).not_to match(/[PWN]/)
+        next if size < 5
+
+        replay = described_class.send(:mini_replay, name: name, width: size, height: size + 1, seed: 73)
+        expected = replay[frame][:rows].drop(1).map do |row|
+          row.chars.map { |pixel| described_class::MINI_PIXELS.fetch(pixel).first }.join
+        end
+        expect(cells.map { |row| row.map { |cell| cell[:glyph] }.join }).to eq(expected)
+      end
+    end
+  end
+
   def block_colors(rows)
     rows.flat_map do |row|
       [0, 2].map do |bit|
@@ -31,9 +54,9 @@ describe PWN::Banner do
 
   it 'keeps every active tetromino color beside the stack throughout its fall and lock' do
     rotations = Hash.new { |hash, key| hash[key] = [] }
-    [5, 8, 16, 20].product([1, 73, 74]).each do |size, seed|
-      args = { name: :falling_blocks, width: size, height: size, seed: seed }
-      frames = described_class.send(:mini_replay, **args)
+    [5, 8, 16, 20].product([1, 73, 74], [true, false]).each do |size, seed, branding|
+      args = { name: :falling_blocks, width: size, height: size, seed: seed, branding: branding }
+      frames = described_class.send(:mini_replay, **args, height: size + (branding ? 0 : 1))
       frames.each_with_index do |frame, index|
         next unless frame[:state][:active]
 
@@ -45,13 +68,17 @@ describe PWN::Banner do
         points.each { |x, y| expected[y][x] = color }
         expect(block_colors(frame[:rows].drop(1))).to eq(expected)
         points.each do |x, y|
-          cell = cells[1 + (y / 2)][x]
+          expect(x).to be_between(0, size - 1)
+          expect(y).to be_between(0, ((size - (branding ? 1 : 0)) * 2) - 1)
+          cell = cells[(branding ? 1 : 0) + (y / 2)][x]
           mask = ' ▘▝▀▖▌▞▛▗▚▐▜▄▙▟█'.index(cell[:glyph])
           actual = mask[(y % 2) * 2] == 1 ? cell[:foreground] : cell[:background]
           expect(actual).to eq(color)
         end
         next unless frames[index + 1][:event] == :lock
 
+        stack = frame[:state][:stack]
+        expect(points.any? { |x, y| y == stack.length - 1 || stack[y + 1][x] != ' ' }).to be(true)
         expect(frames[index + 1][:rows]).to eq(frame[:rows])
         expect(described_class.mini_cells(**args, frame: index + 1)).to eq(cells)
         rotations[type] << points.map { |x, y| [x - points.map(&:first).min, y - points.map(&:last).min] }.sort

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

@@ -425,6 +425,25 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     PWN::Env[:ai] = previous
   end
 
+  it 'draws every game without wordmark glyphs in color, monochrome and tiny panes' do
+    PWN::Banner.mini_names.product([1, 3, 5, 8, 16, 20], [true, false]).each do |name, size, colors|
+      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([name])
+      now = 100.0
+      allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC) { now }
+      console.instance_variable_set(:@banner_colors, colors)
+      console.instance_variable_set(:@banner_two_colors, colors)
+      calls = []
+      allow(console).to receive(:put) { |*args| calls << args }
+      console.draw_banner(size)
+      now += 10.0
+      console.draw_banner(size)
+      expect(calls.map { |_, _, text| text }.join).not_to match(/[PWN]/)
+      expect(calls).to all(satisfy { |y, x, text| y.between?(1, size) && x >= 1 && x + text.length <= size + 1 })
+      expect(console.banner_frame(size).join).not_to match(/[PWN]/)
+    end
+  end
+
   it 'selects one mini-banner per session and advances only from monotonic elapsed time' do
     pry = Pry.new
     pry.config.pwn_ai_session_id = 'banner-one'
@@ -435,16 +454,16 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     now = 100.0
     allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC) { now }
     first = console.banner_frame(8)
-    expect(first).to eq(PWN::Banner.mini_frame(name: choices.first, frame: 0, width: 8, height: 8))
+    expect(first).to eq(PWN::Banner.mini_frame(name: choices.first, frame: 0, width: 8, height: 8, branding: false))
     now += PWN::Banner::MINI_FRAME_SECONDS / 2
     expect(console.banner_frame(8)).to eq(first)
     now += PWN::Banner::MINI_FRAME_SECONDS * 0.75
-    expect(console.banner_frame(8)).to eq(PWN::Banner.mini_frame(name: choices.first, frame: 1, width: 8, height: 8))
+    expect(console.banner_frame(8)).to eq(PWN::Banner.mini_frame(name: choices.first, frame: 1, width: 8, height: 8, branding: false))
     now += PWN::Banner::MINI_FRAME_SECONDS * PWN::Banner::MINI_FRAME_COUNT
-    expect(console.banner_frame(12)).to eq(PWN::Banner.mini_frame(name: choices.first, frame: 1, width: 12, height: 12))
+    expect(console.banner_frame(12)).to eq(PWN::Banner.mini_frame(name: choices.first, frame: 1, width: 12, height: 12, branding: false))
     expect(choices).to have_received(:sample).once
     pry.config.pwn_ai_session_id = 'banner-two'
-    expect(console.banner_frame(8)).to eq(PWN::Banner.mini_frame(name: choices.last, frame: 0, width: 8, height: 8))
+    expect(console.banner_frame(8)).to eq(PWN::Banner.mini_frame(name: choices.last, frame: 0, width: 8, height: 8, branding: false))
     expect(choices).to have_received(:sample).twice
   end
 
@@ -454,7 +473,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC).and_return(100.0)
     size = 24
     canvas = console.banner_frame(size)
-    art = PWN::Banner.mini_frame(name: :pong, frame: 0, width: size, height: size)
+    art = PWN::Banner.mini_frame(name: :pong, frame: 0, width: size, height: size, branding: false)
     expect(canvas.length).to eq(size)
     expect(canvas.map(&:length)).to all(eq(size))
     top = (size - art.length) / 2
@@ -470,14 +489,14 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     allow(Process).to receive(:clock_gettime).with(Process::CLOCK_MONOTONIC) { now }
     console.banner_frame(20, cells: true)
     seed = console.instance_variable_get(:@banner_seed)
-    frames = PWN::Banner.send(:mini_replay, name: :falling_blocks, width: 20, height: 20, seed: seed)
+    frames = PWN::Banner.send(:mini_replay, name: :falling_blocks, width: 20, height: 21, seed: seed)
     tick = frames.index { |frame| frame[:event] == :lock }
     now += (tick + 0.1) * PWN::Banner::MINI_FRAME_SECONDS
     calls = []
     allow(console).to receive(:put) { |*args| calls << args }
     console.draw_banner(20)
     expect(calls.select { |y, _x, text| y == 20 && text.strip != '' }).not_to be_empty
-    expect(calls).to include([1, 9, 'P', nil], [1, 10, 'W', nil], [1, 11, 'N', nil])
+    expect(calls.map { |_, _, text| text }.join).not_to match(/[PWN]/)
     expect(calls).to all(satisfy { |y, x, text| y.between?(1, 20) && x >= 1 && x + text.length <= 21 })
   end
 
@@ -498,12 +517,13 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     end
     allow(PWN::Banner).to receive(:mini_cells).and_call_original
     console.draw
-    expect(rectangles).to include([0, 0, 10, 10, 'PWN'])
+    expect(rectangles).to include([0, 0, 10, 10, ''])
     expect(rectangles).to include([0, 10, 10, 109, "pwn-ai v#{PWN::VERSION}"])
     expect(console.instance_variable_get(:@header_text_column)).to eq(12)
     expect(painted).to include([2, 12, 'PROVIDER (ENGINE):', console.tone(:category)])
     expect(painted.any? { |y, x, text, color| y == 0 && x == 0 && text.include?('╭') && color == console.tone(:border) }).to be(true)
-    expect(painted.any? { |y, x, text, color| y == 0 && x == 2 && text.include?('PWN') && color == console.tone(:title) }).to be(true)
+    expect(painted.any? { |y, x, _text, _color| y == 0 && x == 2 }).to be(false)
+    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
@@ -511,14 +531,14 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
       allow(curses).to receive_messages(cols: columns, lines: rows)
       rectangles.clear
       console.draw
-      expect(rectangles.map(&:last)).not_to include('PWN')
+      expect(rectangles.map(&:last)).not_to include('')
       expect(console.instance_variable_get(:@header_text_column)).to eq(2)
     end
     allow(curses).to receive_messages(cols: 120, lines: 26)
-    PWN::Env[:ai][:ollama][:system_role_content] = 'operator ' * 110
+    PWN::Env[:ai][:ollama][:system_role_content] = 'operator ' * 200
     console.draw
     expect(console.instance_variable_get(:@header_text_column)).to eq(2)
-    expect(console.header_lines('ollama', 'fixture', 115).length).to be <= 13
+    expect(console.header_lines('ollama', 'fixture', 115).length).to be > 16
     expect(PWN::Banner).to have_received(:mini_cells).once
     expect([console.instance_variable_get(:@editor).text, console.instance_variable_get(:@editor).cursor]).to eq(['retained draft', 4])
   end
@@ -533,7 +553,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     allow(PWN::Banner).to receive(:mini_cells).and_call_original
     height = console.draw_header('ollama', 'fixture')
     expect(height).to be > 10
-    expect(console).to have_received(:box).with(0, 0, height, height, 'PWN')
+    expect(console).to have_received(:box).with(0, 0, height, height, '')
     expect(PWN::Banner).to have_received(:mini_cells).with(hash_including(width: height - 2, height: height - 2))
     expect(console.instance_variable_get(:@header_spans).length + 3).to be <= height
     expect(console.header_lines('ollama', 'fixture', console.instance_variable_get(:@header_text_width)).join).to include('REASONING EFFORT: high')
@@ -605,10 +625,10 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     console.banner_frame(8, cells: true)
     seed = console.instance_variable_get(:@banner_seed)
     expect(seed).to be_a(Integer)
-    expect(console.banner_frame(8, cells: true)).to eq(PWN::Banner.mini_cells(name: :snake, frame: 0, width: 8, height: 8, seed: seed))
+    expect(console.banner_frame(8, cells: true)).to eq(PWN::Banner.mini_cells(name: :snake, frame: 0, width: 8, height: 8, seed: seed, branding: false))
     now += 0.21
-    expect(console.banner_frame(8, cells: true)).to eq(PWN::Banner.mini_cells(name: :snake, frame: 2, width: 8, height: 8, seed: seed))
-    expect(console.banner_frame(12, cells: true)).to eq(PWN::Banner.mini_cells(name: :snake, frame: 2, width: 12, height: 12, seed: seed))
+    expect(console.banner_frame(8, cells: true)).to eq(PWN::Banner.mini_cells(name: :snake, frame: 2, width: 8, height: 8, seed: seed, branding: false))
+    expect(console.banner_frame(12, cells: true)).to eq(PWN::Banner.mini_cells(name: :snake, frame: 2, width: 12, height: 12, seed: seed, branding: false))
     expect(console.instance_variable_get(:@banner_seed)).to eq(seed)
     pry.config.pwn_ai_session_id = 'another-colored-session'
     console.banner_frame(8, cells: true)
@@ -630,7 +650,7 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
       console.banner_frame(8, cells: true)
       seed = console.instance_variable_get(:@banner_seed)
       now += 1.21
-      expect(PWN::Banner).to receive(:mini_cells).with(name: name, frame: 24, width: 8, height: 8, seed: seed).twice.and_call_original
+      expect(PWN::Banner).to receive(:mini_cells).with(name: name, frame: 24, width: 8, height: 8, seed: seed, branding: false).twice.and_call_original
       2.times { console.banner_frame(8, cells: true) }
     end
   end
@@ -699,13 +719,15 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
       expect(actual).to eq(lines)
       expect(header.select { |entry| entry[3] == console.tone(:category) }.map { |entry| entry[2] }.join).to include('SYSTEM ROLE CONTENT:', 'MAX PROMPT LENGTH:', 'REASONING EFFORT:')
       expect(header.select { |entry| entry[3] == console.tone(:header) }.map { |entry| entry[2] }.join).to include('operator', '1024', 'high')
-      if columns == 48
-        labels = header.select { |entry| entry[3] == console.tone(:category) }.map { |entry| entry[2] }
-        expect(labels.join).to include('MAX PROMPT LENGTH:')
-        expect(labels).not_to include(a_string_including('MAX PROMPT LENGTH:'))
-      end
       expect(console.instance_variable_get(:@page_size)).to be >= 1
     end
+    console.header_lines('ollama', 'fixture', 35)
+    labels = []
+    console.instance_variable_get(:@header_spans).each do |row|
+      row.each { |role, text| labels << text if role == :category }
+    end
+    expect(labels.join).to include('MAX PROMPT LENGTH:')
+    expect(labels).not_to include(a_string_including('MAX PROMPT LENGTH:'))
     console.handle("\u000f")
     console.draw
     console.handle(:end)
@@ -1218,7 +1240,9 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
       if rendered_header.include?('worker-effort')
         expect(rendered_header).to include('worker settings role', '0.42', '4321', '8765')
         expect(painted).to include([a_kind_of(Integer), a_kind_of(Integer), 'MODEL:', 7])
-        expect(painted).to include([a_kind_of(Integer), a_kind_of(Integer), ' worker-effort', 6])
+        value = painted.find { |_y, _x, text, color| color == 6 && text.to_s.include?('worker-effort') }
+        expect(value).not_to be_nil
+        expect(value[2]).not_to include('REASONING EFFORT:')
         "\u0004"
       else
         Thread.pass

data/third_party/pwn_rdoc.jsonl

@@ -1058,13 +1058,17 @@
 {"messages":[{"role":"user","content":"PWN::AI::Agent::VulnGen.authors Usage"},{"role":"assistant","content":"`PWN::AI::Agent::VulnGen.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Agent::VulnGen.help Usage"},{"role":"assistant","content":"`PWN::AI::Agent::VulnGen.help`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.anth_tool_choice Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.anth_tool_choice`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Anthropic.anthropic_input_schema Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.anthropic_input_schema`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.anthropic_resp_to_oa Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.anthropic_resp_to_oa`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.anthropic_rest_call Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.anthropic_rest_call`: Supported Method Parameters\n\nanthropic_rest_call(\n\ntoken: 'required - anthropic api key',\nhttp_method: 'optional HTTP method (defaults to GET)',\nbase_uri: 'optional base anthropic api URI (defaults to https://api.anthropic.com/v1)',\nrest_call: 'required rest call to make per the schema',\nparams: 'optional params passed in the URI or HTTP Headers',\nhttp_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST',\ntimeout: 'optional timeout in seconds (defaults to 900)',\nspinner: 'optional - display spinner (defaults to false)'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::AI::Anthropic.anthropic_schema_key Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.anthropic_schema_key`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Anthropic.anthropic_schema_notes Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.anthropic_schema_notes`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.authors Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.authors`: Author(s)\n\n0day Inc. <support@0dayinc.com>\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.chat Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.chat`: Supported Method Parameters\n\nresponse = PWN::AI::Anthropic.chat(\n\nrequest: 'required - message to Anthropic',\nmodel: 'optional - model to use for text generation (defaults to PWN::Env[:ai][:anthropic][:model])',\ntemp: 'optional - creative response float (defaults to PWN::Env[:ai][:anthropic][:temp])',\nsystem_role_content: 'optional - context to set up the model behavior for conversation (Default: PWN::Env[:ai][:anthropic][:system_role_content])',\nresponse_history: 'optional - pass response back in to have a conversation',\nspeak_answer: 'optional speak answer using PWN::Plugins::Voice.text_to_speech (Default: nil)',\ntimeout: 'optional timeout in seconds (defaults to 900)',\nspinner: 'optional - display spinner (defaults to false)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.chat_with_tools Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.chat_with_tools`: Supported Method Parameters\n\nresponse = PWN::AI::Anthropic.chat_with_tools(\n\nmessages: 'required - OpenAI-format messages array (system/user/assistant/tool)',\ntools: 'optional - OpenAI tools array [{type:\"function\", function:{...}}]',\ntool_choice: 'optional - \"auto\" | \"none\" | \"required\" | {type:\"function\", function:{name:..}}',\nmodel: 'optional - overrides PWN::Env[:ai][:anthropic][:model]',\ntemp: 'optional - temperature (defaults to PWN::Env[:ai][:anthropic][:temp] || 1)',\nmax_tokens: 'optional - defaults to PWN::Env[:ai][:anthropic][:max_tokens] || 128_000',\ntimeout: 'optional - seconds (default 900)',\nspinner: 'optional - display spinner (default false)'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.get_models Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.get_models`: Supported Method Parameters\n\nmodels = PWN::AI::Anthropic.get_models\n"}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.help Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.help`: "}]}
+{"messages":[{"role":"user","content":"PWN::AI::Anthropic.json_copy Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.json_copy`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.jwt_exp Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.jwt_exp`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.oa_messages_to_anthropic Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.oa_messages_to_anthropic`: "}]}
 {"messages":[{"role":"user","content":"PWN::AI::Anthropic.oauth_token_expiring? Usage"},{"role":"assistant","content":"`PWN::AI::Anthropic.oauth_token_expiring?`: "}]}
@@ -1708,12 +1712,13 @@
 {"messages":[{"role":"user","content":"PWN::Banner.help Usage"},{"role":"assistant","content":"`PWN::Banner.help`: "}]}
 {"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_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 quarter-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'\n\n)\n"}]}
+{"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_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`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_falling_blocks Usage"},{"role":"assistant","content":"`PWN::Banner.mini_falling_blocks`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_fits? Usage"},{"role":"assistant","content":"`PWN::Banner.mini_fits?`: "}]}
-{"messages":[{"role":"user","content":"PWN::Banner.mini_frame Usage"},{"role":"assistant","content":"`PWN::Banner.mini_frame`: Supported Method Parameters\n\nReturn fresh ASCII rows for decorative retro loops, not interactive games. Use equal width and height for a square; 5..16 retains the complete artwork. Smaller panes degrade to a wordmark. Caller owns randomness, clock and IO. PWN::Banner.mini_frame(\n\nname: 'optional - falling_blocks, snake, pong, or asteroids; defaults to falling_blocks',\nframe: 'optional - integer frame index, defaults to zero and wraps at 60',\nwidth: 'optional - output columns clamped to zero through 16, defaults to 16',\nheight: 'optional - output rows clamped to zero through 16, defaults to 16'\n\n)\n"}]}
+{"messages":[{"role":"user","content":"PWN::Banner.mini_frame Usage"},{"role":"assistant","content":"`PWN::Banner.mini_frame`: Supported Method Parameters\n\nReturn fresh ASCII rows for decorative retro loops, not interactive games. Use equal width and height for a square; 5..16 retains the complete artwork. Smaller panes degrade to a wordmark. Caller owns randomness, clock and IO. PWN::Banner.mini_frame(\n\nname: 'optional - falling_blocks, snake, pong, or asteroids; defaults to falling_blocks',\nframe: 'optional - integer frame index, defaults to zero and wraps at 60',\nwidth: 'optional - output columns clamped to zero through 16, defaults to 16',\nheight: 'optional - output rows clamped to zero through 16, defaults to 16',\nbranding: 'optional - include the legacy wordmark, defaults to true; false reclaims its row'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_frame_seconds Usage"},{"role":"assistant","content":"`PWN::Banner.mini_frame_seconds`: Supported Method Parameters\n\nReturn the presentation interval; simulations preserve their gameplay speed. PWN::Banner.mini_frame_seconds(\n\nname: 'optional - animation name, defaults to falling_blocks'\n\n)\n"}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_freeze Usage"},{"role":"assistant","content":"`PWN::Banner.mini_freeze`: "}]}
 {"messages":[{"role":"user","content":"PWN::Banner.mini_landing Usage"},{"role":"assistant","content":"`PWN::Banner.mini_landing`: "}]}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.751
+  version: 0.5.754
 platform: ruby
 authors:
 - 0day Inc.
@@ -141,14 +141,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.21
+        version: 4.0.22
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.21
+        version: 4.0.22
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement
@@ -617,14 +617,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 0.5.2
 - !ruby/object:Gem::Dependency
   name: nexpose
   requirement: !ruby/object:Gem::Requirement
@@ -7228,7 +7228,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.21
+rubygems_version: 4.0.22
 specification_version: 4
 summary: Automated Security Testing for CI/CD Pipelines & Beyond
 test_files: []