agentmon 0.1.0

data/lib/agentmon/views/visual.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# visual: gauges, areas and heat, sessions first (docs/views.md). Home is the machine's breakdown
+# over every agent session, by name when Claude Code or Codex knows one (Enter on one drills into
+# it: its CPU gauge and area beside the machine's RAM with the session's slice, network and disk
+# areas, processes beside the detail, connections; Escape returns). Its real home frame, from
+# `COLUMNS=100 LINES=50 bundle exec exe/agentmon --layout visual | cat` (one sample, so areas and
+# sparklines are still empty and network rates still settling):
+#
+# ╭─ CPU ──────────────────────────────────────────╮╭─ Memory ───────────────────────────────────────╮
+# │CPU ▕███████████████▏                    ▏ 41.8%││used     ▕████████████████▌    ▏   25G / 32G 79%│
+# │last 4 min                                 41.8%││pressure ▕██████████▏          ▏           48.0%│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││swap     ▕█████▎               ▏ 255M / 1.0G 25%│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││app                 10G  wired              3.5G│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││compressed          11G  cached             5.7G│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢠││used, last 4 min                             25G│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸│
+# │load 1m    5.5  load 5m    6.2  load 15m   6.0  ││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸│
+# ╰────────────────────────────────────────────────╯╰────────────────────────────────────────────────╯
+# ╭─ Network ──────────────────────────────────────╮╭─ Disk ─────────────────────────────────────────╮
+# │net in                                    1.7K/s││disk read                                 933K/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸│
+# │net out                                   1.8K/s││disk write                                  0B/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# ╰────────────────────────────────────────────────╯╰────────────────────────────────────────────────╯
+# ╭─ Sessions ─[Live] All ───────────────────────────────────────────────────────────────────────────╮
+# │ Session                                 CPU▼  Footprint     Read    Write   Net in        Net out│
+# │ Claude 21354                   ⠀⠀⠀⠀⢀   23.4%       3.7G     0B/s     0B/s     0B/s ⠀⠀⠀⠀⢀     0B/s│
+# │ Agentmon r2ui integration…     ⠀⠀⠀⠀⢀   14.6%       372M     0B/s     0B/s     0B/s ⠀⠀⠀⠀⢀     0B/s│
+# │ ChatGPT 2388                   ⠀⠀⠀⠀⢀   10.0%       3.3G     0B/s     0B/s     0B/s ⠀⠀⠀⠀⢀     0B/s│
+# │ Project history · claude…      ⠀⠀⠀⠀⢀    1.0%       285M     0B/s     0B/s          ⠀⠀⠀⠀⢀         │
+# │ EPK component review · claude… ⠀⠀⠀⠀⢀    0.5%       262M     0B/s     0B/s          ⠀⠀⠀⠀⢀         │
+# │ Mods in Desktop vs Code…       ⠀⠀⠀⠀⢀    0.3%       226M     0B/s     0B/s          ⠀⠀⠀⠀⢀         │
+# │ Set up a Homebrew tap for…     ⠀⠀⠀⠀⢀    0.1%       200M     0B/s     0B/s          ⠀⠀⠀⠀⢀         │
+# │ Weekly session themes review…  ⠀⠀⠀⠀⢀    0.1%       181M     0B/s     0B/s     0B/s ⠀⠀⠀⠀⢀     0B/s│
+# │ codex 3064 · Resources         ⠀⠀⠀⠀⢀    0.0%        76M     0B/s     0B/s     0B/s ⠀⠀⠀⠀⢀     0B/s│
+# │ Build Magrathea local POC +8…  ⠀⠀⠀⠀⢀    0.0%      1022M     0B/s     0B/s     0B/s ⠀⠀⠀⠀⢀     0B/s│
+# │                                                                                                  │
+#   ... 6 more empty table lines ...
+# ╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
+# ╭─ All agents ───────────────────────────────────╮╭─ Agents network ───────────────────────────────╮
+# │CPU                                         5.0%││net in                                      0B/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │footprint                                   9.6G││net out                                     0B/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# ╰────────────────────────────────────────────────╯╰────────────────────────────────────────────────╯
+#  sessions · ⏎ open a session
+#
+# Drilled into "Agentmon r2ui integration" (a pty at 100×50: `/` integration, Enter). The RAM
+# meter is the machine (25G of 32G used) with this session's footprint as the accent slice at the
+# left, the rest of used memory dim and free memory empty:
+#
+# ╭─ CPU ──────────────────────────────────────────╮╭─ Memory ───────────────────────────────────────╮
+# │CPU ▕                                     ▏ 0.1%││RAM      ▕▏█████████████▉    ▏ 323M 1% · 25G/32G│
+# │last 4 min                                  0.1%││pressure ▕█████████▏         ▏             48.0%│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││resident           439M  wired                0B│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││growth             0B/s  pageins             0/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││footprint, last 4 min                       323M│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿│
+# ╰────────────────────────────────────────────────╯╰────────────────────────────────────────────────╯
+# ╭─ Network ──────────────────────────────────────╮╭─ Disk ─────────────────────────────────────────╮
+# │net in                                    337B/s││read                                        0B/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │net out                                   647B/s││write                                       0B/s│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# │⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸││⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀│
+# ╰────────────────────────────────────────────────╯╰────────────────────────────────────────────────╯
+# ╭─ Processes ─[Agents] All  Busy  Heavy  Writing  Waiting ─╮╭─ Detail ─────────────────────────────╮
+# │ Name                          CPU▼  Footprint  Net out   ││claude  pid 22602                     │
+# │ claude               ⣀⣀⣀⣀⣀    1.0%       320M   647B/s   ││Command    /Users/ryan/Library…       │
+# │▴sleep                ⠀⠀⠀⠀⣀    0.0%       832K     0B/s   ││Directory  ~/The Source/agentmon      │
+# │▾zsh                  ⣀⣀⣀⣀⣀    0.0%       2.5M     0B/s   ││Session    Agentmon r2ui integration… │
+# │                                                          ││Footprint  320M                       │
+#   ... 16 more lines: the Detail pairs beside empty table lines ...
+# ╰──────────────────────────────────────────────────────────╯╰──────────────────────────────────────╯
+# ╭─ Connections ────────────────────────────────────────────────────────────────────────────────────╮
+# │ Process            Remote                         State             In     Out▼     Recv     Sent│
+# │▴claude 22602       160.79.104.10:443              Established   337B/s   647B/s      15K      28K│
+# │▾claude 22602       160.79.104.10:443              Established     0B/s     0B/s      39K     2.9M│
+# │▾claude 22602       160.79.104.10:443              Established     0B/s     0B/s     918K     4.5M│
+# │▾claude 22602       160.79.104.10:443              Established     0B/s     0B/s     234K     540K│
+# │▾claude 22602       ….bc.googleusercontent.com:443 Established     0B/s     0B/s      26K     8.3M│
+# ╰───────────────────────────────────────────────────────────────────────────────────────────── 2/6 ╯
+#  ▸ Agentmon r2ui integration · claude 22602 · agentmon · busy · esc back to sessions
+#
+# The Sessions table leaves Procs off so disk read and write both fit at 100 columns (its label,
+# the session's name first, is 30 wide); footprint has no sparkline (a flat footprint draws a full
+# braille column, not a baseline).
+module Agentmon
+  view :visual, title: "agentmon" do
+    # Home: the machine's breakdown, then every agent session.
+    row height: 11 do
+      panel :cpu, title: "CPU" do
+        meter "system.cpu"
+        trend "system.cpu", height: 6, label: "last 4 min"
+        stat "system.load1", "system.load5", "system.load15", columns: 3
+      end
+      panel :memory, title: "Memory" do
+        meter "memory.used"
+        meter "memory.pressure"
+        meter "memory.swap_used"
+        stat "memory.app", "memory.wired", "memory.compressed", "memory.cached", columns: 2
+        trend "memory.used", height: nil, label: "used, last 4 min"
+      end
+    end
+    row height: 8 do
+      panel :network, title: "Network" do
+        trend "system.net_in_rate", "system.net_out_rate", height: nil
+      end
+      panel :disk, title: "Disk" do
+        trend "system.disk_read_rate", "system.disk_write_rate", height: nil
+      end
+    end
+    row do
+      top :session, title: "Sessions", by: :cpu, spark: %i[cpu net_out_rate],
+                    columns: %i[label cpu footprint read_rate write_rate net_in_rate net_out_rate],
+                    widths: { label: 30 }
+    end
+    row height: 10 do
+      panel :agents, title: "All agents" do
+        trend "focus.cpu", "focus.footprint", height: nil
+      end
+      panel :agents_net, title: "Agents network" do
+        trend "focus.net_in_rate", "focus.net_out_rate", height: nil
+      end
+    end
+
+    # Drilled into one session: its CPU, memory, network and disk, processes, connections.
+    focused do
+      row height: 11 do
+        panel :s_cpu, title: "CPU" do
+          meter "focus.cpu"
+          trend "focus.cpu", height: nil, label: "last 4 min"
+          stat "focus.processes", "focus.read_rate", "focus.write_rate", columns: 3
+        end
+        panel :s_memory, title: "Memory" do
+          meter "memory.used", part: "focus.footprint", label: "RAM" # the session's slice of the machine
+          meter "memory.pressure"
+          stat "focus.resident", "focus.wired", "focus.growth_rate", "focus.pagein_rate", columns: 2
+          trend "focus.footprint", height: nil, label: "footprint, last 4 min"
+        end
+      end
+      row height: 8 do
+        panel :s_net, title: "Network" do
+          trend "focus.net_in_rate", "focus.net_out_rate", height: nil
+        end
+        panel :s_disk, title: "Disk" do
+          trend "focus.read_rate", "focus.write_rate", height: nil
+        end
+      end
+      row do
+        top :process, span: 3, by: :cpu, columns: %i[name cpu footprint net_out_rate], widths: { name: 20 }
+        detail :process, span: 2
+      end
+      row height: 8 do
+        top :connection, title: "Connections", by: :out_rate, spark: false, widths: { process: 18 },
+                         columns: %i[process remote_text state in_rate out_rate bytes_in bytes_out]
+      end
+    end
+  end
+end

data/lib/agentmon/views/widgets.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "r2ui"
+
+module Agentmon
+  module Views
+    # The drawing layer of the performance-view DSL (docs/views.md, "The DSL"): pure functions,
+    # Strings in, Strings out, no app, engine or state. Every line returned is exactly `width`
+    # visible cells (SGR escapes count zero, wide characters two), padded with spaces, never more.
+    # Colour is 24-bit SGR through R2UI's Glyphs: percents take heat, bytes the accent, unknown
+    # values show "–" in dim.
+    #
+    # The examples below are the plain text (escapes stripped).
+    #
+    #   cut("claude 74432 · agentmon", 15)              # => "claude 74432…"
+    #   cut("bare-modifier-monitor", 16)                # => "bare-modifier…"
+    #   cut("~/src/very/long/repo", 12, from: :left)    # => "…/long/repo"
+    #   meter(label: "busy", text: "42%", fraction: 0.42, width: 20)
+    #                                                   # => "busy ▕███▊     ▏ 42%"
+    #   meter(label: "busy", text: nil, fraction: nil, width: 16)
+    #                                                   # => "busy ▕       ▏ –"
+    #   stacked_meter(label: "RAM", text: "1G", part: 0.25, fraction: 0.5, width: 16)
+    #                                                   # => "RAM ▕█▊█▌   ▏ 1G" (█▊ accent, █▌ dim)
+    #   spark(label: "cpu", values: [1, 2, 3, 4], text: "4%", width: 12)
+    #                                                   # => "cpu ⠀⠀⠀⣠⣾ 4%"
+    #   trend(label: "CPU", text: "42%", values: [1, 2, 3, 4], width: 10, height: 1)
+    #                                                   # => ["CPU    42%", "⠀⠀⠀⠀⠀⠀⠀⠀⣠⣾"]
+    #   stat(pairs: [["load1", "2.1", nil], ["load5", nil, nil]], width: 24)
+    #                                                   # => ["load1   2.1  load5     –"]
+    #   tile(title: "claude 4242", body: ["cpu 12%"], width: 18, height: 3)
+    #                                                   # => ["╭─ claude 4242 ──╮",
+    #                                                   #     "│cpu 12%         │",
+    #                                                   #     "╰────────────────╯"]
+    #
+    # value_sgr picks the SGR params for a value: heat for a percent with a fraction, the accent
+    # for bytes and byte rates, nil otherwise, dim when unknown; a pulse (0..1) mixes the colour
+    # toward PULSE and turns bold above 0.3.
+    module Widgets
+      G = R2UI::Widgets::Glyphs
+      ACCENT = "#D97757"
+      DIM = "#555555"
+      TROUGH = "#303030"
+      PULSE = "#FFE0C2"
+      PLAIN = "#BCBCBC"
+      MUTED = "#8A8A8A"
+      UNKNOWN = "–"
+      ELLIPSIS = "…"
+      SEPARATORS = [" ", "·", "-", ",", ":", "/"].freeze
+      BYTE_UNITS = %i[bytes bytes_per_sec signed_bytes_per_sec].freeze
+      SGR = /\e\[[0-9;?]*[ -\/]*[@-~]/
+      TOKEN = /\e\[[0-9;?]*[ -\/]*[@-~]|\X/
+
+      module_function
+
+      # Visible cells of `str`: SGR escapes are zero-width, wide characters two.
+      def visible_width(str)
+        R2UI::Compat::Tea::ANSI.string_width(str.to_s.gsub(SGR, ""))
+      end
+
+      # `str` padded with spaces to `width` cells (right-aligned with align: :right). Never cuts.
+      def pad(str, width, align: :left)
+        str = str.to_s
+        gap = width - visible_width(str)
+        return str if gap <= 0
+
+        align == :right ? (" " * gap) + str : str + (" " * gap)
+      end
+
+      # Plain `text` cut to at most `width` cells, the ellipsis at a word boundary when one exists.
+      def cut(text, width, from: :right)
+        text = text.to_s
+        return "" if width <= 0
+        return text if visible_width(text) <= width
+        return ELLIPSIS if width == 1
+
+        from == :left ? cut_left(text, width) : cut_right(text, width)
+      end
+
+      # SGR params (or nil) for a value of `unit`; see the module comment.
+      def value_sgr(unit:, fraction: nil, pulse: 0.0, known: true)
+        return G.fg(DIM) unless known
+
+        heat = unit == :percent && !fraction.nil?
+        bytes = BYTE_UNITS.include?(unit)
+        pulse = pulse.to_f.clamp(0.0, 1.0)
+        if pulse.positive?
+          base = if heat then G.gradient(G::HEAT, fraction.to_f.clamp(0.0, 1.0))
+                 elsif bytes then ACCENT
+                 else PLAIN
+                 end
+          sgr = G.fg(R2UI::Motion.mix_hex(base, PULSE, pulse))
+          return pulse > 0.3 ? "#{sgr};1" : sgr
+        end
+        return G.heat(fraction) if heat
+        return G.fg(ACCENT) if bytes
+
+        nil
+      end
+
+      # One line: `label ▕bar▏ text`; without room for a 3-cell bar, label left and text right.
+      def meter(label:, text:, fraction:, width:, label_width: nil, text_width: nil, bar_sgr: nil, text_sgr: nil)
+        return "" if width <= 0
+
+        known = !fraction.nil? && !text.nil?
+        text, text_sgr = UNKNOWN, G.fg(DIM) unless known
+        label = label.to_s
+        text = text.to_s
+        label_w = label_width || visible_width(label)
+        text_w = text_width || visible_width(text)
+        bw = width - label_w - text_w - 4
+        return sides(label, nil, text, text_sgr, width) if bw < 3
+
+        fraction = known ? fraction.to_f.clamp(0.0, 1.0) : 0.0
+        bar_sgr ||= known ? G.heat(fraction) : G.fg(DIM)
+        meter_line(label, label_w, G.paint(G.bar(fraction, bw), "#{bar_sgr};#{G.bg(TROUGH)}"), text, text_sgr,
+                   text_w, width)
+      end
+
+      # A meter whose bar stacks a part of the whole: `label ▕PPrrr   ▏ text`, from the left `part`
+      # (0..1 of the whole) in `part_hex`, the rest of `fraction` in `rest_hex`, the trough after
+      # (stacked_bar). Unknown part, fraction or text draws as an unknown meter.
+      #
+      #   stacked_meter(label: "RAM", text: "1G 6% · 9G/16G", part: 0.25, fraction: 0.5, width: 30)
+      #                                                   # => "RAM ▕██▎█▌    ▏ 1G 6% · 9G/16G" (plain)
+      def stacked_meter(label:, text:, part:, fraction:, width:, label_width: nil, text_width: nil,
+                        part_hex: ACCENT, rest_hex: DIM, text_sgr: nil)
+        return "" if width <= 0
+        if part.nil? || fraction.nil? || text.nil?
+          return meter(label:, text: nil, fraction: nil, width:, label_width:, text_width:)
+        end
+
+        label = label.to_s
+        text = text.to_s
+        label_w = label_width || visible_width(label)
+        text_w = text_width || visible_width(text)
+        bw = width - label_w - text_w - 4
+        return sides(label, nil, text, text_sgr, width) if bw < 3
+
+        meter_line(label, label_w, stacked_bar(part, fraction, bw, part_hex:, rest_hex:), text, text_sgr, text_w,
+                   width)
+      end
+
+      # `width` cells: `part` then the rest of `fraction` (both 0..1 of the whole; part is clamped to
+      # fraction) then the trough. Eighth-block precise: a boundary cell draws a left partial block
+      # (▏..▉) in the left segment's colour over the right segment's colour as its background. A
+      # part above zero shows at least one eighth. When both boundaries fall in one cell the part
+      # keeps its eighths and the cell's background is whichever of rest or trough covers more of it.
+      def stacked_bar(part, fraction, width, part_hex: ACCENT, rest_hex: DIM)
+        return "" if width <= 0
+
+        whole = fraction.to_f.clamp(0.0, 1.0)
+        part = part.to_f.clamp(0.0, whole)
+        used_e = (whole * width * 8).round
+        part_e = (part * width * 8).round
+        part_e = 1 if part_e.zero? && part.positive?
+        used_e = part_e if used_e < part_e
+        runs = []
+        width.times do |i|
+          glyph, fg, bg = stacked_cell((part_e - (8 * i)).clamp(0, 8), (used_e - (8 * i)).clamp(0, 8),
+                                       part_hex, rest_hex)
+          sgr = [fg && G.fg(fg), G.bg(bg)].compact.join(";")
+          if runs.last && runs.last[1] == sgr
+            runs.last[0] << glyph
+          else
+            runs << [+glyph, sgr]
+          end
+        end
+        runs.map { |glyphs, sgr| G.paint(glyphs, sgr) }.join
+      end
+
+      # One stacked_bar cell with `a` eighths of part and `b` eighths of part + rest: [glyph, fg, bg].
+      def stacked_cell(a, b, part_hex, rest_hex)
+        if a == 8 then ["█", part_hex, TROUGH]
+        elsif a.positive? then [G::PARTIAL[a - 1], part_hex, b - a > 8 - b ? rest_hex : TROUGH]
+        elsif b == 8 then ["█", rest_hex, TROUGH]
+        elsif b.positive? then [G::PARTIAL[b - 1], rest_hex, TROUGH]
+        else [" ", nil, TROUGH]
+        end
+      end
+
+      # `label ▕bar▏ text` with the label and text padded to their widths, fitted to `width`.
+      def meter_line(label, label_w, bar, text, text_sgr, text_w, width)
+        line = pad(cut(label, label_w), label_w) + " " + G.paint("▕", G.fg(DIM)) + bar + G.paint("▏", G.fg(DIM)) +
+               " " + pad(G.paint(text, text_sgr), text_w, align: :right)
+        fit(line, width)
+      end
+
+      # One line: `label ⣀⣠⣴⣾ text` (braille sparkline, newest at the right).
+      def spark(label:, values:, text:, width:, max: nil, label_width: nil, text_width: nil, chart_sgr: nil, text_sgr: nil)
+        return "" if width <= 0
+
+        text, text_sgr = UNKNOWN, G.fg(DIM) if text.nil?
+        label = label.to_s
+        text = text.to_s
+        label_w = label_width || visible_width(label)
+        text_w = text_width || visible_width(text)
+        sw = width - label_w - text_w - 2
+        return sides(label, nil, text, text_sgr, width) if sw < 2
+
+        values = Array(values)
+        values = Array.new(sw * 2, 0) if values.size < 2
+        chart = G.braille_line(values, sw, max: max)
+        line = pad(cut(label, label_w), label_w) + " " + G.paint(chart, chart_sgr || G.fg(ACCENT)) +
+               " " + pad(G.paint(text, text_sgr), text_w, align: :right)
+        fit(line, width)
+      end
+
+      # height + 1 lines: a header (label left, text right) then a braille area chart.
+      def trend(label:, text:, values:, width:, height:, max: nil, chart_sgr: nil, text_sgr: nil)
+        return [] if width <= 0
+
+        text, text_sgr = UNKNOWN, G.fg(DIM) if text.nil?
+        header = sides(label.to_s, G.fg(MUTED), text.to_s, text_sgr, width)
+        return [header] if height <= 0
+
+        area = G.braille_area(Array(values), width, height, max: max)
+        [header] + area.map { |row| fit(G.paint(row, chart_sgr || G.fg(ACCENT)), width) }
+      end
+
+      # A label/value grid, `columns` cells per line; pairs are [label, text_or_nil, sgr_or_nil].
+      def stat(pairs:, width:, columns: 2, gap: 2)
+        return [] if width <= 0 || pairs.nil? || pairs.empty?
+
+        columns = [columns.to_i, 1].max
+        gap = [gap.to_i, 0].max
+        cell_w = (width - (gap * (columns - 1))) / columns
+        pairs.each_slice(columns).map do |row|
+          next " " * width if cell_w <= 0
+
+          cells = row.map do |label, text, sgr|
+            text, sgr = UNKNOWN, G.fg(DIM) if text.nil?
+            sides(label.to_s, G.fg(MUTED), text.to_s, sgr, cell_w)
+          end
+          fit(cells.join(" " * gap), width)
+        end
+      end
+
+      # Exactly `height` lines: a rounded border with `title` in the top edge around `body`.
+      def tile(title:, body:, width:, height:, border_sgr: nil, title_sgr: nil)
+        return [] if height < 2
+        return Array.new(height, " " * [width, 0].max) if width < 4
+
+        inner = width - 2
+        room = inner - 3
+        title = room.positive? ? cut(title.to_s, room) : ""
+        top = if title.empty?
+                G.paint("╭#{"─" * inner}╮", border_sgr)
+              else
+                G.paint("╭─ ", border_sgr) + G.paint(title, title_sgr) +
+                  G.paint(" #{"─" * (room - visible_width(title))}╮", border_sgr)
+              end
+        body = Array(body)
+        rows = Array.new(height - 2) do |i|
+          G.paint("│", border_sgr) + fit(body[i].to_s, inner) + G.paint("│", border_sgr)
+        end
+        [top, *rows, G.paint("╰#{"─" * inner}╯", border_sgr)]
+      end
+
+      # ANSI-aware: the first `width` visible cells of `str`, SGR runs kept, re-closed with a reset.
+      def truncate(str, width)
+        str = str.to_s
+        return str if visible_width(str) <= width
+
+        out = +""
+        used = 0
+        styled = false
+        str.scan(TOKEN) do |tok|
+          if tok.start_with?("\e[")
+            out << tok
+            styled = true
+            next
+          end
+          w = R2UI::Compat::Tea::ANSI.string_width(tok)
+          break if used + w > width
+
+          out << tok
+          used += w
+        end
+        styled ? out << "\e[0m" : out
+      end
+
+      # `str` truncated then padded to exactly `width` cells.
+      def fit(str, width)
+        return "" if width <= 0
+
+        pad(truncate(str, width), width)
+      end
+
+      # `left` and `right` on one `width`-cell line; the right side always shows (cut only when it
+      # alone is wider than the line), the left is cut by the word rule to fit beside it.
+      def sides(left, left_sgr, right, right_sgr, width)
+        return "" if width <= 0
+
+        right = cut(right, width)
+        rw = visible_width(right)
+        left = cut(left, width - rw - 1)
+        lw = visible_width(left)
+        gap = width - lw - rw
+        fit(G.paint(left, left.empty? ? nil : left_sgr) + (" " * gap) + G.paint(right, right_sgr), width)
+      end
+
+      def cut_right(text, width)
+        best = nil
+        text.each_char.with_index do |ch, i|
+          next unless SEPARATORS.include?(ch) # "bare-modifier-monitor" → "bare-modifier…"
+
+          prefix = strip_tail(text[0, i])
+          best = prefix if !prefix.empty? && visible_width(prefix) + 1 <= width
+        end
+        (best || take(text, width - 1)) + ELLIPSIS
+      end
+
+      def cut_left(text, width)
+        best = nil
+        text.each_char.with_index do |ch, i|
+          next unless ch == "/" || ch == " "
+
+          suffix = ch == "/" ? text[i..] : strip_head(text[i..])
+          next if suffix.empty? || visible_width(suffix) + 1 > width
+
+          best = suffix
+          break
+        end
+        ELLIPSIS + (best || take(text.reverse, width - 1).reverse)
+      end
+
+      def strip_tail(str)
+        str = str.chop while !str.empty? && SEPARATORS.include?(str[-1])
+        str
+      end
+
+      def strip_head(str)
+        str = str[1..] while !str.empty? && SEPARATORS.include?(str[0])
+        str
+      end
+
+      # The longest leading run of grapheme clusters of plain `str` within `width` cells.
+      def take(str, width)
+        out = +""
+        used = 0
+        str.each_grapheme_cluster do |g|
+          w = R2UI::Compat::Tea::ANSI.string_width(g)
+          break if used + w > width
+
+          out << g
+          used += w
+        end
+        out
+      end
+    end
+  end
+end