pwn 0.5.759 → 0.5.761

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ef7228011e10bd0573cab148f192e8ef963608a002d4e3d833fcd2e380fd973
-  data.tar.gz: 8f238e16e7d0d521deb4b4abdad45fed2d15fb82d92bcc8448b0877bc23b8783
+  metadata.gz: 6748541ed45249f60331d0a819803c7c872527b763806edbcdd601ca30e862dc
+  data.tar.gz: e9f1ff039dafe19a3f250df08896bdf2498f6c5550d28dae4c83e2a071560c58
 SHA512:
-  metadata.gz: d6eb621a41250c5332e00f941c8b6b7444f796fcb30c009d774d7a0814f3c268809152275f2c63f7f7076450c75bbe662c0248ec6b21abb9730b44b097fdb139
-  data.tar.gz: 8ea184fdfa2018bc59f00aef8585d190907236a3d71df302c21db3eb025813111cd5a7bb289513c5a7f51a816f1c7e094f5b6c0bf420ff50d9a7a27a11ffbc65
+  metadata.gz: 4c07ed5325a0db30c3933f8157e72b65e1f1ff3428e1944fb43f5809390cc647486fd9ed36b76c3986a2c55f75fba0d49c552ab3a1cb4b6dc1dc1e7669e3615f
+  data.tar.gz: 880e597ef1c96a3cc197bdf56b317f1e0854d17ffafcf7780c6f97ca198bce7dbcda6c971bdf0fba0d2feea29de7794f6e7af1cf9d17d99471e325e19db9582a

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/documentation/pwn-ai-Agent.md

@@ -22,12 +22,46 @@ ASSISTANT and WARNING), a persistent multiline composer, and an operational
 sidebar at 100 columns or wider. Narrower screens give the timeline the full width.
 At 100 columns × 26 rows or larger, the header may carve out a bordered retro-game
 colored Unicode-block animation on the left: falling tetrominoes with line clears,
-a connected snake eating food and growing, Pong with small tracking paddles and a
-bouncing ball, or Asteroids with a rotating cyan ship, red thrust, drifting green
-rocks, yellow shots and magenta fragments. Pong's one-cell-high paddles and
-quadrant-block ball move in half-cell steps; doubling the presentation rate does
-not double gameplay speed. Asteroids wraps at the edges and shots break up rocks;
-its seeded autonomous flight is decorative, not player-controlled.
+a connected snake eating food and growing, Pac-Man with a blue maze, pellets,
+yellow mouth sprite and colored ghosts, or Asteroids with a filled cyan ship,
+red thrust, white rocks, yellow shots and expanding collision fragments.
+Ctrl+T/Ctrl+X cycles MISSION CONTROL → SESSION → the visible game pane.
+While the game is active, Ctrl+G cycles Tetris → Snake → Pac-Man → Asteroids → Galaga → Frogger;
+outside game focus Ctrl+G retains its swarm alias, and Ctrl+S opens swarm.
+Enter/Esc returns to the unchanged mission draft. Modals and cancellation retain
+priority; games never read input or render on a separate thread.
+Pac-Man starts on an arrow, moves every 0.3 seconds and buffers the latest turn
+until a corridor permits it. Walls stop movement. Eat every pellet to advance
+the level; large yellow power pellets turn ghosts blue for seven seconds.
+Ghosts chase through corridors, flee while frightened and return home when eaten.
+Contact with a normal ghost ends the round, followed by a brief flash and a fresh
+arrow-ready start. Small mazes use one ghost; larger mazes use three.
+Maze walls are generated from a seeded spanning tree with extra loops, not a
+fixed grid with shuffled pellets. Every pellet remains reachable, and each round
+consumes fresh random geometry. Pac-Man and ghosts each occupy one terminal cell,
+including in the smallest eight-cell console pane. The maze fills the available
+interior with internal walls and connected corridors instead of sacrificing routes
+for enlarged sprites. Directional mouth and ghost glyphs retain compact hints;
+individual eyes and scalloped feet cannot be resolved at this size.
+Galaga uses arrows to move and Space to shoot. Destroy formations and diving
+enemies, dodge hostile shots, and clear the formation to advance a wave. A hit
+shows an expanding explosion, then an input-ready restart. The cyan player ship is
+a filled upward-pointing delta with a nose, spine and wings on a 2x4 Braille-dot
+raster; movement and collision coordinates remain unchanged.
+Frogger uses arrows to hop: avoid moving traffic, ride moving logs across water,
+and enter each empty goal. Water, traffic, occupied goals and riding off the edge
+cause a short death/recovery animation. Filling all goals advances the level.
+Both games begin on input, fill small and large panes, and run automatic demos
+when inactive. Their footer hints appear only while the game pane is focused.
+Pac-Man, Galaga and Frogger demos advance one caller-owned simulation frame per
+UI tick rather than building a full replay on a cold resize or session change.
+The deterministic random-access `mini_cells` replay API remains available to
+other callers; its first large-canvas call can take longer than cached frames.
+Snake uses arrows; Tetris uses Left/Right, Down and Space to rotate; Asteroids
+uses Left/Right to turn, Up/Down for thrust/reverse and Space to fire. Asteroids
+wraps at the edges and shots split rocks. Inactive games run seeded automatic demos.
+Pong is no longer selectable; the explicit `name: :pong` Banner APIs remain
+compatible with existing callers.
 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.
@@ -43,14 +77,14 @@ color, holes and silhouette instead of recoloring neighbors when they touch.
 The board remains full-width; only its horizontal logical resolution changes.
 Completed rows intentionally flash white before collapsing; game-over and replay
 resets also use white holds/wipes. Ordinary locking never changes color or shape.
-Colored falling blocks support interiors up to 64 cells; the other artwork retains
+Colored falling blocks, Pac-Man, Galaga and Frogger support interiors up to 64 cells; the other artwork retains
 its 16-cell limit. Above the applicable limit, art is centered and padded rather
 than clipped or stretched.
 One `PWN::Banner.mini_names` animation is randomly
 selected for the session and retained across redraws, model changes and resize;
 changing the active session selects again. Frames advance at the banner API's
-`mini_frame_seconds(name:)` cadence (0.05 seconds for Pong/Asteroids, 0.1 for
-blocks/snake) using monotonic time in the existing render loop—no extra animation
+`mini_frame_seconds(name:)` cadence (0.05 seconds for Asteroids/Galaga, 0.1 for
+blocks/Snake/Pac-Man/Frogger) 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(branding: false)` with dedicated foreground/background curses pairs,
@@ -60,7 +94,7 @@ halves become a full block, not a half-block with its background lost). The `min
 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
+1800 frames (90 seconds for Asteroids, 180 for blocks/snake/Pac-Man), 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,
 nonrecursive layout pass grows the header and square together. If the terminal

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). 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
+Static banners and pure, PWN-branded retro ASCII/color loops: falling_blocks, snake, pacman, asteroids, galaga and frogger. 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/Pac-Man/Galaga/Frogger: 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 Asteroids/Galaga, 0.1 otherwise). mini_cells replays 1800 seeded gameplay frames (MINI_FRAME_COUNT); mini_frame retains its legacy 60-frame ASCII loop. Inactive panes use seeded demos; MiniGame supplies caller-owned playable state. 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; Pac-Man eats pellets in connected mazes with chasing ghosts, energizers, recovery and new levels. Blocks use horizontal half-cells with independent foreground/background colors, filling the pane below PWN (up to 64 cells). Other games retain quadrant pixels; decorative snake stays centered with food/head color priority. White line-clear flashes and game-over/reset wipes are intentional. Pac-Man and ghosts occupy one cell each so even eight-cell panes retain internal walls and corridors. Directional mouths and compact ghost glyphs trade eye detail for maze geometry; spanning-tree mazes vary each round. Galaga has formations, dives, hostile fire, explosions and advancing waves; arrows move and Space fires. Frogger arrows hop through moving traffic and onto carrying logs to fill goals, recover from deaths and advance levels. Both start on input, run automatic demos when inactive and retain the UI owner. Legacy name: :pong remains accepted by direct APIs but is not selectable. Asteroids uses filled cyan ships on a 2x4 Braille raster, 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/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