agentmon 0.1.0

data/lib/agentmon/recorders/sessions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Session history: store kind `sessions`. While agentmon records (the dashboard, `agentmon
+# record`), every 10 s it appends one line per alive agent session, and one final line for each
+# session the first time it is seen ended. Each line is `Session#to_record` plus `t` (the sample's
+# time) and `run` (the engine's run id), in the model's units (bytes, seconds, epoch seconds):
+#
+#   ~/.local/state/agentmon/sessions/2026-10-01.jsonl
+#   {"t":1790711098.2,"id":"claude-4242-1790711088","kind":"cli","name":"claude","root_pid":4242,
+#    "label":"claude 4242 · repo","cwd":"/Users/me/src/repo","started_at":1790711088.4,...,
+#    "ended_at":null,"cpu_seconds":12.6,"bytes_read":0,"bytes_written":5244880,"run":"812-1790711090"}
+#
+# Readers merge lines by `id`, taking each total's maximum (docs/design.md, "Store records").
+# Nothing is written while the session ledger is unavailable.
+module Agentmon
+  module Recorders
+    module SessionHistory
+      module_function
+
+      # Records for this reading. `state[:ended]` holds the ids this engine already wrote a final
+      # line for, kept only while the ledger still lists them (it drops ended sessions after
+      # SessionLedger::KEEP_ENDED), so it stays small.
+      def call(reading, state)
+        ledger = reading[:session_ledger] or return []
+
+        written = state[:ended] ||= {}
+        ended_now = ledger.reject(&:alive?).to_h { |s| [s.id, true] }
+        written.keep_if { |id, _| ended_now.key?(id) }
+        ledger.filter_map do |session|
+          next if !session.alive? && written.key?(session.id)
+
+          written[session.id] = true unless session.alive?
+          session.to_record.merge(t: reading.at)
+        end
+      end
+    end
+  end
+
+  recorder(:sessions, every: 10) { |reading, state| Recorders::SessionHistory.call(reading, state) }
+end

data/lib/agentmon/registry.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Agentmon
+  class Error < StandardError; end
+
+  # A probe reads the machine. Its block gets a private state Hash (kept between samples) and
+  # returns one value, stored as `sample[name]`. With `every:`, the previous value is reused until
+  # that many seconds have passed (slow probes such as lsof).
+  Probe = Data.define(:name, :every, :block)
+  # A metric derives a value from samples. Its block gets the Reading and a private state Hash
+  # (kept between samples, so it can accumulate) and returns `reading[name]`. Every metric runs on
+  # every sample, so stateful ones see each one. A metric that raises is nil for that sample (its
+  # error shows in Engine#errors), and `reading[:other]` is nil while no story registers `other`.
+  Metric = Data.define(:name, :block)
+  # A recorder turns a Reading into store records (a Hash or an Array of them) appended under its
+  # name, at most once every `every` seconds, while the engine records (the dashboard,
+  # `agentmon record`). Its block gets the Reading and a private state Hash kept for the engine's
+  # life (e.g. the ids it already wrote a final line for): `{ |reading, state| ... }`.
+  Recorder = Data.define(:name, :every, :block)
+  # A dashboard row. Panels name the row they go in; rows without panels are left out.
+  Row = Data.define(:name, :order, :height)
+  # A dashboard panel: r2ui's `panel` arguments plus where it goes. `block` holds r2ui panel items
+  # (table, gauge, stat, sparkline, view, ...); nil shows the resource's full index.
+  Panel = Data.define(:name, :row, :order, :resource, :span, :title, :options, :block)
+  # A CLI command: the block is an r2ui CLI command body (summary, option, run, ...).
+  Command = Data.define(:name, :block)
+  # Lines a story adds to the Detail panel (ui/process_detail.rb) under the selected process's
+  # own: the block gets the ProcessRow and the Engine's current Reading and returns
+  # `[[label, value], ...]` (value a String; nil shows "unknown"), or [] to add nothing.
+  DetailSection = Data.define(:name, :order, :block)
+
+  # Everything the extension files registered. One per process (Agentmon.registry); tests build
+  # their own to try a registration in isolation.
+  class Registry
+    KINDS = %i[probe metric recorder row panel command detail_section view].freeze
+
+    def initialize
+      @items = KINDS.to_h { |k| [k, {}] }
+      @resources = {}
+      @resource_extensions = Hash.new { |h, k| h[k] = [] }
+      @dashboard_blocks = []
+      @cli_blocks = []
+    end
+
+    attr_reader :resource_extensions, :dashboard_blocks, :cli_blocks
+
+    # Adds a named item; a name already taken in its kind raises, so two stories can't silently
+    # register the same probe, metric, panel or command.
+    def add(kind, item)
+      items = @items.fetch(kind) { raise Error, "unknown kind #{kind.inspect}" }
+      raise Error, "#{kind} #{item.name} is already registered" if items.key?(item.name)
+
+      items[item.name] = item
+    end
+
+    def all(kind) = @items.fetch(kind).values
+
+    def [](kind, name) = @items.fetch(kind)[name.to_sym]
+
+    def probes = all(:probe)
+    def metrics = all(:metric)
+    def recorders = all(:recorder)
+    def commands = all(:command)
+
+    # Detail panel sections in order (then by name).
+    def detail_sections = all(:detail_section).sort_by { |s| [s.order, s.name.to_s] }
+
+    # Rows in order, each with its panels in order; empty rows left out.
+    def layout
+      panels = all(:panel).group_by(&:row)
+      unknown = panels.keys - @items[:row].keys
+      raise Error, "panel #{panels[unknown.first].first.name} names unknown row #{unknown.first}" if unknown.any?
+
+      all(:row).sort_by(&:order).filter_map do |row|
+        members = panels[row.name]
+        members && [row, members.sort_by { |p| [p.order, p.name.to_s] }]
+      end
+    end
+
+    def define_resource(name, block)
+      raise Error, "resource #{name} is already defined" if @resources.key?(name)
+
+      @resources[name] = block
+    end
+
+    # name => [definition block, *extension blocks in load order]
+    def resources
+      extra = @resource_extensions.keys - @resources.keys
+      raise Error, "extend_resource #{extra.first}: no resource defines it" if extra.any?
+
+      @resources.to_h { |name, block| [name, [block, *@resource_extensions[name]]] }
+    end
+  end
+
+  class << self
+    def registry = @registry ||= Registry.new
+
+    # --- the extension points (docs/design.md); each story's file calls these at load ---
+
+    def probe(name, every: nil, &block) = registry.add(:probe, Probe.new(name: name.to_sym, every:, block: need(block)))
+
+    def metric(name, &block) = registry.add(:metric, Metric.new(name: name.to_sym, block: need(block)))
+
+    def recorder(name, every: 10, &block)
+      registry.add(:recorder, Recorder.new(name: name.to_sym, every:, block: need(block)))
+    end
+
+    def row(name, order:, height: nil) = registry.add(:row, Row.new(name: name.to_sym, order:, height:))
+
+    # `resource:` defaults to the panel's name, as in r2ui; `resource: nil` for extension items only.
+    def panel(name, row:, order: 100, resource: name, span: 1, title: nil, **options, &block)
+      registry.add(:panel, Panel.new(name: name.to_sym, row: row.to_sym, order:, resource:, span:, title:, options:, block:))
+    end
+
+    # An r2ui resource (R2UI.resource's DSL). The block runs on r2ui's resource builder and gets
+    # the Engine: `source { engine.current[:process_rows] }`. Defined once; see extend_resource.
+    def resource(name, &block) = registry.define_resource(name.to_sym, need(block))
+
+    # More DSL for a resource another file defines: columns, scopes, actions. Runs after the
+    # definition, in load order.
+    def extend_resource(name, &block) = registry.resource_extensions[name.to_sym] << need(block)
+
+    # Dashboard-level r2ui DSL (keys, mouse, theme, title, ...), run on r2ui's dashboard builder
+    # with the Engine, before the rows.
+    def dashboard(&block) = registry.dashboard_blocks << need(block)
+
+    # An `agentmon <name>` command; the block is an r2ui CLI command body.
+    def command(name, &block) = registry.add(:command, Command.new(name: name.to_sym, block: need(block)))
+
+    # More lines in the Detail panel for the selected process: `{ |row, reading| [[label, value]] }`.
+    def detail_section(name, order: 100, &block)
+      registry.add(:detail_section, DetailSection.new(name: name.to_sym, order:, block: need(block)))
+    end
+
+    # A performance view (docs/views.md): rows of panels of view words, run with
+    # `agentmon --layout NAME`. The block runs on Views::ViewBuilder (lib/agentmon/views.rb).
+    def view(name, title: "agentmon", &block)
+      registry.add(:view, Views.build(name, title:, &need(block)))
+    end
+
+    # Root-level r2ui CLI DSL (version, completion, global flags), run on the root builder.
+    def cli(&block) = registry.cli_blocks << need(block)
+
+    # Loads every extension file, kind by kind, each directory in name order.
+    def load_extensions(root = __dir__)
+      %w[probes metrics recorders ui commands].each do |dir|
+        Dir[File.join(root, dir, "*.rb")].sort.each { |file| require file }
+      end
+    end
+
+    private
+
+    def need(block) = block || raise(ArgumentError, "a block is required")
+  end
+end

data/lib/agentmon/sampler.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Agentmon
+  # Runs every registered probe once and returns a Sample. A probe with `every:` keeps its last
+  # value until it is due again; a probe that raises keeps its last value and its error goes in
+  # `sample.errors`, so one broken probe never stops the others.
+  #
+  # Tests don't use this: they hand an Engine a FixtureSampler (anything with `#sample`).
+  class Sampler
+    def initialize(registry: Agentmon.registry, clock: Clock)
+      @registry = registry
+      @clock = clock
+      @states = Hash.new { |h, k| h[k] = {} }
+      @last = {} # probe name => [value, mono when taken]
+    end
+
+    def sample
+      mono = @clock.mono
+      at = @clock.now
+      errors = {}
+      parts = @registry.probes.to_h do |probe|
+        [probe.name, run(probe, mono, errors)]
+      end
+      Sample.new(at:, mono:, parts:, errors:)
+    end
+
+    private
+
+    def run(probe, mono, errors)
+      last = @last[probe.name]
+      return last[0] if last && probe.every && mono - last[1] < probe.every
+
+      value = probe.block.call(@states[probe.name])
+      @last[probe.name] = [value, mono]
+      value
+    rescue StandardError => e
+      errors[probe.name] = "#{e.class}: #{e.message}"
+      last&.first
+    end
+  end
+
+  # The two clocks: wall time for instants people read, monotonic time for intervals and rates.
+  module Clock
+    module_function
+
+    def now = Time.now.to_f
+
+    def mono = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/agentmon/store.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Agentmon
+  # Append-only history in plain files: one JSON object per line, one file per kind per local day.
+  #
+  #   ~/.local/state/agentmon/sessions/2026-10-01.jsonl
+  #   ~/.local/state/agentmon/memory/2026-10-01.jsonl
+  #
+  # The directory is $AGENTMON_STATE_DIR, else $XDG_STATE_HOME/agentmon, else
+  # ~/.local/state/agentmon. Every record gets `t` (epoch seconds) when it has none. Reading
+  # tolerates a torn last line (a crash mid-write) by skipping lines that don't parse.
+  class Store
+    def self.default_dir(env = ENV)
+      return File.expand_path(env["AGENTMON_STATE_DIR"]) if env["AGENTMON_STATE_DIR"].to_s != ""
+
+      base = env["XDG_STATE_HOME"].to_s == "" ? File.join(Dir.home, ".local", "state") : env["XDG_STATE_HOME"]
+      File.join(File.expand_path(base), "agentmon")
+    end
+
+    attr_reader :dir
+
+    def initialize(dir: Store.default_dir, clock: Clock)
+      @dir = dir
+      @clock = clock
+      @lock = Mutex.new
+    end
+
+    # Appends one record (a Hash) under `kind`. Returns the record as written.
+    def append(kind, record)
+      record = { t: @clock.now }.merge(record)
+      path = file_for(kind, record[:t] || record["t"])
+      line = "#{JSON.generate(record)}\n"
+      @lock.synchronize do
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "a") { |f| f.write(line) }
+      end
+      record
+    end
+
+    # Records of `kind` with `since <= t < till` (epoch seconds or Time), oldest first, keys as
+    # Symbols. Without a block, an Enumerator.
+    def each(kind, since: nil, till: nil, &block)
+      return enum_for(:each, kind, since:, till:) unless block
+
+      since = since&.to_f
+      till = till&.to_f
+      files(kind, since).each do |path|
+        File.foreach(path) do |line|
+          record = parse(line) or next
+          t = record[:t].to_f
+          next if (since && t < since) || (till && t >= till)
+
+          yield record
+        end
+      end
+    end
+
+    # Deletes day files older than `days` days. Returns the paths removed.
+    def prune(days:)
+      cutoff = day(@clock.now - (days * 86_400))
+      old = Dir[File.join(dir, "*", "*.jsonl")].select { |p| File.basename(p, ".jsonl") < cutoff }
+      old.each { |p| File.delete(p) }
+    end
+
+    private
+
+    def file_for(kind, t) = File.join(dir, kind.to_s, "#{day(t)}.jsonl")
+
+    def day(t) = Time.at(t.to_f).strftime("%Y-%m-%d")
+
+    def files(kind, since)
+      all = Dir[File.join(dir, kind.to_s, "*.jsonl")].sort
+      # A record at `since` lives in that local day's file or a later one.
+      since ? all.select { |p| File.basename(p, ".jsonl") >= day(since) } : all
+    end
+
+    def parse(line)
+      JSON.parse(line, symbolize_names: true)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/agentmon/ui/connections.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# The :connection resource: the network flows of agent-session processes that have a concrete
+# remote end, one line each, busiest upload first. No panel of its own: layouts place it with
+# `top :connection`. Follows session focus (the reading is already narrowed).
+#
+#   Process          Proto  Remote                         State         In     Out   Recv   Sent
+#   claude 4242      tcp4   api.anthropic.com:443          ESTABLISHED  2.0K/s 12K/s   1.5M   9.0M
+#   node 4310        tcp6   …ample-long-host.internal:8443 ESTABLISHED  0B/s    0B/s   10K    2K
+#
+# Remote is the host and port as the probe printed them, cut from the left when long (the port and
+# domain matter more than a subdomain). Search with / (`remote~anthropic`, `state~CLOSE`).
+module Agentmon
+  module UI
+    module ConnectionsPanel
+      REMOTE_WIDTH = 30
+
+      module_function
+
+      # reading[:connections] as rows; none while network data is unavailable.
+      def rows(reading)
+        (reading[:connections] || []).map { |c| row(c) }
+      end
+
+      def row(conn)
+        {
+          id: key(conn),
+          pid: conn.pid,
+          name: conn.name,
+          process: "#{conn.name} #{conn.pid}",
+          session_id: conn.session_id,
+          session: conn.session,
+          protocol: conn.protocol,
+          local: conn.local,
+          remote: conn.remote,
+          remote_text: cut_left(conn.remote.to_s, REMOTE_WIDTH),
+          interface: conn.interface,
+          state: conn.state,
+          in_rate: conn.in_rate,
+          out_rate: conn.out_rate,
+          bytes_in: conn.bytes_in,
+          bytes_out: conn.bytes_out
+        }
+      end
+
+      # Stable across samples while the flow lives: "pid|protocol|local|remote".
+      def key(conn) = [conn.pid, conn.protocol, conn.local, conn.remote].join("|")
+
+      # `text` fitted to `width` columns, dropping its start ("…" marks the cut).
+      def cut_left(text, width)
+        text.length > width ? "…#{text[-(width - 1)..]}" : text
+      end
+    end
+  end
+
+  resource :connection do |engine|
+    title "Connections"
+    source { UI::ConnectionsPanel.rows(engine.current) }
+    refresh every: engine.interval
+    key :id
+
+    index do
+      column :process, label: "Process"
+      column :protocol, label: "Proto", width: 5
+      column :remote_text, label: "Remote", width: UI::ConnectionsPanel::REMOTE_WIDTH
+      column :state, label: "State", width: 11
+      column :in_rate, label: "In", format: :bytes_per_sec
+      column :out_rate, label: "Out", format: :bytes_per_sec, sort: :desc
+      column :bytes_in, label: "Recv", format: :bytes
+      column :bytes_out, label: "Sent", format: :bytes
+    end
+
+    filter :name, :remote, :state
+  end
+end

data/lib/agentmon/ui/interaction.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Mouse and help. A left click focuses the panel under the pointer and selects the table row
+# there; the wheel moves the selection of the table under the pointer. `?` opens a full-screen
+# help listing every key (r2ui's, those other stories bind, and agentmon's own) and what each
+# panel shows; any key closes it.
+#
+#   ?   help                        click  focus a panel, select a row
+#   K   terminate the selection     wheel  move the selection
+#
+# The overlay is the r2ui extension `agentmon_help` (a `view_override`); it draws only for the
+# agentmon dashboard, since r2ui's hooks are process-wide.
+module Agentmon
+  module UI
+    # Not `Help` or `Interaction` alone: named after the story so it can't hide a core constant.
+    module MouseAndHelp
+      STORE = :agentmon_help
+
+      # agentmon's own keys, shown even before the stories that bind them have merged.
+      KEYS = [
+        ["K", "terminate the selected process (TERM, asks y/n)"],
+        ["X", "kill the selected process (KILL, asks y/n)"],
+        ["?", "this help (any key closes it)"]
+      ].freeze
+
+      # r2ui's selection keys, which its status bar doesn't list.
+      MOVE = [["↑ ↓ j k", "move the selection"]].freeze
+
+      MOUSE = [
+        ["click", "focus the panel, select the row under the pointer"],
+        ["wheel", "move the selection of the table under the pointer"]
+      ].freeze
+
+      # What each panel shows, by panel name; panels not listed show their title only.
+      PANELS = {
+        memory: "RAM: used/total, app, wired, compressed, cached, swap, pressure and its drivers",
+        session: "agent sessions: CPU, footprint, peak, CPU seconds, disk written, age",
+        process: "every process with its session, directory, CPU, footprint, resident size, disk rates",
+        detail: "the selected process: command line, cwd, memory, CPU time, files, start time"
+      }.freeze
+
+      module_function
+
+      def open?(store) = store[:open] == true
+
+      def toggle(store) = store[:open] = !open?(store)
+
+      # The overlay text, at most `width` x `height`. `hints` are app.hint_pairs ([key, label]);
+      # agentmon's own labels win for the keys it describes itself.
+      def render(app, hints, width, height)
+        ours = KEYS.map(&:first)
+        keys = hints.map { |k, l| [k.to_s, l.to_s] }.reject { |k, _| ours.include?(k) } + MOVE + KEYS
+        pad = (keys + MOUSE).map { |k, _| k.length }.max
+        lines = ["agentmon help", "", "Keys"]
+        lines += keys.map { |k, l| "  #{k.ljust(pad)}  #{l}" }
+        lines += ["", "Mouse"] + MOUSE.map { |k, l| "  #{k.ljust(pad)}  #{l}" }
+        lines += ["", "Panels"]
+        lines += app.dashboard.panels.map do |p|
+          "  #{panel_title(app, p)}#{"  #{PANELS[p.name]}" if PANELS[p.name]}"
+        end
+        lines += ["", "Press any key to close."]
+        lines.first([height, 1].max).map { |line| line[0, [width, 0].max] }.join("\n")
+      end
+
+      # The title the panel's border shows: its own, else its resource's, else its name.
+      def panel_title(app, panel)
+        resource = panel.resource && app.registry.resource(panel.resource)
+        (panel.title || resource&.title || panel.name.to_s.capitalize).to_s
+      end
+    end
+  end
+
+  dashboard do
+    mouse :cell
+    on_key("?", help: "help") { UI::MouseAndHelp.toggle(store(UI::MouseAndHelp::STORE)) }
+  end
+
+  R2UI.extension :agentmon_help do
+    # While the help is open it takes every key (closing it) and every mouse message.
+    on(->(m) { m.is_a?(Bubbletea::KeyMessage) || m.is_a?(Bubbletea::MouseMessage) }, priority: 100) do |message|
+      help = store(UI::MouseAndHelp::STORE)
+      pass unless UI::MouseAndHelp.open?(help)
+
+      help[:open] = false if message.is_a?(Bubbletea::KeyMessage)
+      nil
+    end
+
+    view_override do
+      if dashboard.name == UI::DASHBOARD && UI::MouseAndHelp.open?(store(UI::MouseAndHelp::STORE))
+        UI::MouseAndHelp.render(app, app.hint_pairs(self), width, height)
+      end
+    end
+  end
+end

data/lib/agentmon/ui/memory.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# The :memory resource and the Memory panel (top row, left): the RAM deep dive Activity Monitor
+# shows, plus which agent sessions push memory pressure.
+#
+#   ╭ Memory ──────────────────────────────────────╮
+#   │Used      ▕██████████████░░░░▏ 12G / 16G 75%  │
+#   │App               8.0G Wired             2.0G │
+#   │Compressed        2.0G Ratio             3.1x │
+#   │Cached            3.0G Swap used         512M │
+#   │Swap in         1.0M/s Swap out        256K/s │
+#   │Compress        4.0M/s Decompress      3.0M/s │
+#   │Pressure ▁▂▂▃▃▄▅▅▆▆▅▄▃▃▂▂▃▄▅▆▇▇█        42.0% │
+#   │claude 4242 · repo     1.5G  12.5%   +2.0M/s  │
+#   │Claude 59334           1.0G   8.3%   -512K/s  │
+#   ╰──────────────────────────────────────────────╯
+#
+# Used = app + wired + compressed (Activity Monitor's "Memory Used"); Ratio is how much the
+# compressor squeezes (stored bytes / bytes it occupies); the rates are bytes per second between
+# samples. Pressure is 100 − kern.memorystatus_level, its line the last 60 samples (2 minutes).
+# The last lines are the three sessions with the largest footprint: footprint, share of used
+# memory, and how fast their footprint grew over the last minute.
+#
+# The numbers come from the `memory` metric (a MemoryView) and the `pressure_drivers` metric
+# (PressureDrivers). While `memory` is unavailable the panel says so and shows no numbers.
+module Agentmon
+  module UI
+    module MemoryPanel
+      # What the resource returns: one record per frame, so the gauge, stats and lines agree.
+      Record = Data.define(:view, :drivers)
+
+      # [attribute, label, r2ui format] of the MemoryView fields the resource exposes.
+      ATTRIBUTES = [
+        [:total, "Total", :bytes], [:used, "Used", :bytes], [:app, "App", :bytes], [:wired, "Wired", :bytes],
+        [:compressed, "Compressed", :bytes], [:compression_ratio, "Ratio", :ratio], [:cached, "Cached", :bytes],
+        [:free, "Free", :bytes], [:swap_used, "Swap used", :bytes], [:swap_total, "Swap total", :bytes],
+        [:swapin_rate, "Swap in", :bytes_per_sec], [:swapout_rate, "Swap out", :bytes_per_sec],
+        [:compression_rate, "Compress", :bytes_per_sec], [:decompression_rate, "Decompress", :bytes_per_sec],
+        [:pressure, "Pressure", :percent]
+      ].freeze
+
+      # The stats grid, two per line, in this order.
+      STATS = %i[app wired compressed compression_ratio cached swap_used swapin_rate swapout_rate compression_rate
+                 decompression_rate].freeze
+
+      DRIVERS = 3
+
+      module_function
+
+      def record(reading)
+        view = reading[:memory] or return []
+        [Record.new(view:, drivers: reading[:pressure_drivers] || [])]
+      end
+
+      def format(key, value)
+        _, _, fmt = ATTRIBUTES.find { |a| a.first == key }
+        R2UI::Format.call(fmt, value)
+      end
+
+      def label(key) = ATTRIBUTES.find { |a| a.first == key }[1]
+
+      # "App        8.0G Wired      2.0G", two cells per line (one when narrower than 40).
+      def stats(view, width)
+        cols = width >= 40 ? 2 : 1
+        cell = (width - (cols - 1)) / cols
+        STATS.map { |key| cell_text(label(key), format(key, view.public_send(key)), cell) }
+             .each_slice(cols).map { |cells| cells.join(" ") }.join("\n")
+      end
+
+      # "Pressure    ▁▂▃▅▆ 42.0%": the trend scaled to 100%, newest next to the current value.
+      def pressure(view, width)
+        now = format(:pressure, view.pressure)
+        room = width - "Pressure ".length - now.length - 1
+        spark = room.positive? ? R2UI::Widgets::Sparkline.line(view.pressure_trend || [], room, max: 100) : ""
+        "Pressure #{spark.rjust([room, 0].max)} #{now}"
+      end
+
+      # "claude 4242 · repo   1.5G  12.5%  +2.0M/s" for the largest three; a nil share is blank.
+      def drivers(drivers, width)
+        drivers.first(DRIVERS).map do |d|
+          right = Kernel.format("%6s  %6s  %8s", R2UI::Format.bytes(d.footprint.to_i),
+                                d.share ? Kernel.format("%.1f%%", d.share) : "", growth(d.growth_rate))
+          name = d.label.to_s
+          room = width - right.length - 1
+          name = room > 1 && name.length > room ? "#{name[0, room - 1]}…" : name
+          "#{name.ljust([room, 0].max)} #{right}"
+        end.join("\n")
+      end
+
+      def growth(rate)
+        return "" if rate.nil?
+
+        "#{rate.negative? ? "-" : "+"}#{R2UI::Format.bytes(rate.abs)}/s"
+      end
+
+      def cell_text(label, value, width) = "#{label.ljust([width - value.length, label.length + 1].max)}#{value}"
+    end
+  end
+
+  resource :memory do |engine|
+    title "Memory"
+    source { UI::MemoryPanel.record(engine.current) }
+    refresh every: engine.interval
+
+    UI::MemoryPanel::ATTRIBUTES.each do |key, label, fmt|
+      attribute(key, label:, format: fmt) { |r| r.view.public_send(key) }
+    end
+  end
+
+  panel :memory, row: :top, order: 10, span: 1 do |_engine|
+    gauge :used, of: :total, label: "Used"
+    view do
+      record = app.feeds[:memory]&.rows&.first
+      record ? UI::MemoryPanel.stats(record.view, width) : "memory: not available"
+    end
+    view do
+      record = app.feeds[:memory]&.rows&.first
+      record ? UI::MemoryPanel.pressure(record.view, width) : ""
+    end
+    view do
+      record = app.feeds[:memory]&.rows&.first
+      record ? UI::MemoryPanel.drivers(record.drivers, width) : ""
+    end
+  end
+end

data/lib/agentmon/ui/process_actions.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Terminate or kill processes from the Processes panel.
+#
+#   K  terminate: sends TERM (the process may clean up and exit)
+#   X  kill: sends KILL (immediate, can't be caught)
+#
+# Each asks first ("terminate 1 row? y/n"; y sends, any other key cancels). On a group line
+# (g: Session, Directory, Name, tree) it signals every process in the group: K on
+# "claude 200 · repo" terminates the whole session. pid 0, pid 1 (launchd) and agentmon itself are
+# refused ("kill failed: refusing to signal pid 1 (launchd)"); a process that is another user's
+# or already gone shows "terminate failed: pid 200 (claude): Operation not permitted" on the
+# status bar instead of stopping the dashboard.
+module Agentmon
+  module UI
+    module ProcessActions
+      # pid 0 is the kernel, pid 1 launchd: signalling either is never what you meant.
+      PROTECTED = [0, 1].freeze
+
+      class << self
+        # Delivers a signal: `(signal_name, pid)`. Tests swap it to record instead of signalling.
+        attr_accessor :sender
+
+        # Sends `signal` ("TERM", "KILL") to the row's process, or raises Agentmon::Error with the
+        # reason (shown as "<action> failed: <reason>").
+        def signal(signal, row)
+          pid = row.pid
+          raise Error, "refusing to signal agentmon itself (pid #{pid})" if pid == Process.pid
+          raise Error, "refusing to signal pid #{pid.inspect} (#{row.name})" if pid.nil? || PROTECTED.include?(pid)
+
+          sender.call(signal, pid)
+        rescue Errno::EPERM, Errno::ESRCH => e
+          raise Error, "pid #{pid} (#{row.name}): #{e.message.sub(/ - .*\z/, "")}"
+        end
+      end
+
+      self.sender = ->(signal, pid) { Process.kill(signal, pid) }
+    end
+  end
+
+  extend_resource :process do |_engine|
+    action :terminate, key: "K", label: "terminate", confirm: true do |row|
+      UI::ProcessActions.signal("TERM", row)
+    end
+    action :kill, key: "X", label: "kill", confirm: true do |row|
+      UI::ProcessActions.signal("KILL", row)
+    end
+  end
+end