agentmon 0.1.0

data/lib/agentmon/ui/process_detail.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+# The Detail panel (beside Processes, a quarter of the main row): everything about the process
+# selected in the Processes table, whichever panel has focus.
+#
+#   claude  pid 4242
+#   Command    claude --resume --model opus
+#   Directory  ~/src/repo
+#   Session    claude 4242 · repo
+#   Footprint  512M
+#   Resident   600M
+#   Peak       700M
+#   CPU time   12m 3s
+#   Written    1.2G
+#   Started    2h 5m ago
+#   Open files 42
+#
+# The full command line comes from one `ps -o args= -p PID` when the selection changes (cached
+# while it stays). The open file count is `proc_pidinfo(PROC_PIDLISTFDS)` through Fiddle. Root's
+# processes can't be read without root: their footprint, CPU time, disk, start and open files say
+# "not readable without root"; resident size is ps's. A group line (g) shows its process count.
+#
+# Other stories add lines below these with `Agentmon.detail_section` (lib/agentmon/registry.rb)
+# instead of editing this file.
+module Agentmon
+  module UI
+    module ProcessDetail
+      PROC_PIDLISTFDS = 1
+      FDINFO_SIZE = 8 # struct proc_fdinfo: int32 fd + uint32 type
+      UNREADABLE = "not readable without root"
+      LABEL_WIDTH = 11
+      COMMAND_LINES = 3
+
+      class << self
+        # Injection points for tests: pid -> command line String (nil if gone), pid -> Integer or nil.
+        attr_writer :command_reader, :file_counter
+
+        def command_reader = @command_reader ||= method(:read_command)
+        def file_counter = @file_counter ||= method(:open_files)
+
+        # The panel's text for the app's current selection in the :process panel.
+        def render(app, engine, width)
+          panel = app.dashboard.panels.find { |p| p.name == :process }
+          state = panel && app.panel_state(panel)
+          line = state && app.panel_lines(panel)[state.selected]
+          return "No process selected" unless line
+
+          row = line.rows.find { |r| r.pid == line.id } || (line.rows.first if line.rows.size == 1)
+          return "#{line.label}\n#{line.rows.size} processes: ungroup (g) to pick one" unless row
+
+          reading = engine.current
+          lines(row, command(app, row), now: reading.at, width:, reading:).join("\n")
+        end
+
+        # The process's own lines, then each registered `Agentmon.detail_section`'s.
+        def lines(row, command, now:, width:, reading: nil, sections: Agentmon.registry.detail_sections)
+          [*own_lines(row, command, now:, width:), *sections.flat_map { |s| section_lines(s, row, reading) }]
+        end
+
+        # A section that raises shows its error instead of breaking the panel.
+        def section_lines(section, row, reading)
+          section.block.call(row, reading).map { |label, value| pair(label.to_s, value || "unknown") }
+        rescue StandardError => e
+          [pair(section.name.to_s, "#{e.class}: #{e.message}")]
+        end
+
+        def own_lines(row, command, now:, width:)
+          readable = row.readable
+          rusage = ->(value) { readable ? value : UNREADABLE }
+          files = file_counter.call(row.pid)
+          [
+            "#{row.name}  pid #{row.pid}",
+            *wrap("Command", command || row.path, width),
+            pair("Directory", row.cwd ? R2UI::Format.short_path(row.cwd) : "unknown"),
+            pair("Session", row.session || "none"),
+            pair("Footprint", rusage[bytes(row.footprint)]),
+            pair("Resident", bytes(row.resident)),
+            pair("Peak", rusage[bytes(row.peak_footprint)]),
+            pair("CPU time", rusage[row.cpu_time && R2UI::CLI::Ext::HumanFormat.duration(row.cpu_time)]),
+            pair("Written", rusage[bytes(row.disk_written)]),
+            pair("Started", rusage[row.started_at && "#{R2UI::CLI::Ext::HumanFormat.duration([now - row.started_at, 0].max)} ago"]),
+            pair("Open files", files ? files.to_s : (readable ? "unknown" : UNREADABLE))
+          ]
+        end
+
+        # The full command line of `pid` (one ps), or nil when it has exited.
+        def read_command(pid)
+          text = IO.popen(["ps", "-o", "args=", "-p", pid.to_s], err: File::NULL, &:read).strip
+          text.empty? ? nil : text
+        rescue SystemCallError
+          nil
+        end
+
+        # How many file descriptors `pid` has open, or nil when unreadable (EPERM, exited).
+        def open_files(pid)
+          return nil unless Darwin.available?
+
+          estimate = pidinfo.call(pid, PROC_PIDLISTFDS, 0, nil, 0)
+          return nil unless estimate.positive?
+
+          buffer = Fiddle::Pointer.malloc(estimate, Fiddle::RUBY_FREE)
+          used = pidinfo.call(pid, PROC_PIDLISTFDS, 0, buffer, estimate)
+          used.positive? ? used / FDINFO_SIZE : nil
+        end
+
+        private
+
+        # The selected process's command line, read once per selection (pid and start time).
+        def command(app, row)
+          cache = app.store(:agentmon_process_detail)
+          key = [row.pid, row.started_at]
+          unless cache[:key] == key
+            cache[:key] = key
+            cache[:command] = command_reader.call(row.pid)
+          end
+          cache[:command]
+        end
+
+        def bytes(value) = value && R2UI::Format.bytes(value)
+
+        def pair(label, value) = "#{label.ljust(LABEL_WIDTH)}#{value}"
+
+        # The command line over up to COMMAND_LINES lines, indented under its value column.
+        def wrap(label, text, width)
+          room = [width - LABEL_WIDTH, 10].max
+          chunks = text.to_s.scan(/.{1,#{room}}/).first(COMMAND_LINES)
+          chunks = [""] if chunks.empty?
+          chunks.each_with_index.map { |chunk, i| pair(i.zero? ? label : "", chunk) }
+        end
+
+        # proc_pidinfo, bound here: Darwin's binding is private to the core.
+        def pidinfo
+          @pidinfo ||= Fiddle::Function.new(
+            Fiddle.dlopen(nil)["proc_pidinfo"],
+            [Fiddle::TYPE_INT, Fiddle::TYPE_INT, -Fiddle::TYPE_LONG_LONG, Fiddle::TYPE_VOIDP, Fiddle::TYPE_INT],
+            Fiddle::TYPE_INT
+          )
+        end
+      end
+    end
+  end
+
+  panel :detail, row: :main, order: 200, span: 1, resource: nil do |engine|
+    view { UI::ProcessDetail.render(app, engine, width) }
+  end
+end

data/lib/agentmon/ui/process_network.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Network columns on the :process resource ("Net in", "Net out": each process's bytes per second
+# received and sent, blank while unknown), on performance views only (--layout): the default
+# dashboard keeps its columns.
+module Agentmon
+  extend_resource :process do |_engine|
+    next unless Agentmon::Views.installing
+
+    column :net_in_rate, label: "Net in", format: :bytes_per_sec
+    column :net_out_rate, label: "Net out", format: :bytes_per_sec
+  end
+end

data/lib/agentmon/ui/process_scopes.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Quick filters on the Processes table, after Agents and All (cycle with `]`, back with `[`):
+#
+#   Busy     CPU above 5% of one core
+#   Heavy    footprint above 500 MiB
+#   Writing  writing to disk now (write rate above 0 B/s)
+#
+# They look at every process, not just agent ones, and `/` search still narrows inside them
+# (Busy, then `/node`: the busy node processes). A process whose value is unknown (unreadable
+# without root, or not yet sampled twice) is left out of that scope.
+module Agentmon
+  module UI
+    # The thresholds, in the units of ProcessRow: percent of one core, bytes.
+    module ProcessScopes
+      BUSY_CPU = 5.0
+      HEAVY_FOOTPRINT = 500 * 1024 * 1024
+
+      module_function
+
+      def busy?(row) = !row.cpu.nil? && row.cpu > BUSY_CPU
+      def heavy?(row) = !row.footprint.nil? && row.footprint > HEAVY_FOOTPRINT
+      def writing?(row) = !row.write_rate.nil? && row.write_rate.positive?
+    end
+  end
+
+  extend_resource :process do |_engine|
+    scope(:busy) { |row| UI::ProcessScopes.busy?(row) }
+    scope(:heavy) { |row| UI::ProcessScopes.heavy?(row) }
+    scope(:writing) { |row| UI::ProcessScopes.writing?(row) }
+  end
+end

data/lib/agentmon/ui/process_waits.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+# What the selected process waits on: memory and scheduling detail in the Detail panel, two compact
+# columns in the Processes table, and a Waiting scope.
+#
+# Detail panel lines, under the process's own (Detail follows the Processes selection):
+#
+#   Threads    12 (1 running)
+#   CPU wait   25.0% now, 3m 2s total    runnable but waiting for a CPU (% of one core)
+#   Page-ins   10/s, 20 total            each one waited for the disk
+#   Faults     1000/s (COW 100/s)
+#   Switches   500/s                     context switches
+#   Wired      1.0M
+#   Read       512B/s, 1.2G total        from disk
+#
+# A value that isn't known yet (rates need two samples) is left out of its line, and a line with
+# nothing known says "unknown". Root's processes say "not readable without root".
+#
+# Processes table: Wait (`run_wait`, percent of one core spent waiting for a CPU) and Pgin/s
+# (page-ins per second); blank when unknown. Scope Waiting (after Busy, Heavy, Writing): processes
+# waiting for a CPU more than 10% of a core, or paging in at all. macOS has no per-process I/O wait
+# without root; page-ins and disk rates are the closest signals.
+module Agentmon
+  module UI
+    module ProcessWaits
+      UNREADABLE = "not readable without root"
+      # Scope Waiting: percent of one core spent runnable but not running.
+      WAITING_RUN_WAIT = 10.0
+      # Fixed widths for the two table columns (r2ui has no optional columns, so keep them narrow).
+      WAIT_WIDTH = 6
+      PAGEIN_WIDTH = 6
+
+      module_function
+
+      def waiting?(row)
+        (!row.run_wait.nil? && row.run_wait > WAITING_RUN_WAIT) || (!row.pagein_rate.nil? && row.pagein_rate.positive?)
+      end
+
+      # The Detail panel lines for `row`: [[label, value or nil], ...].
+      def lines(row)
+        labels = ["Threads", "CPU wait", "Page-ins", "Faults", "Switches", "Wired", "Read"]
+        return labels.map { |l| [l, UNREADABLE] } unless row.readable
+
+        labels.zip([threads(row), cpu_wait(row), pageins(row), faults(row), rate(row.context_switch_rate),
+                    row.wired && R2UI::Format.bytes(row.wired), read(row)])
+      end
+
+      def threads(row)
+        return nil unless row.threads
+
+        row.running_threads ? "#{row.threads} (#{row.running_threads} running)" : row.threads.to_s
+      end
+
+      # "25.0% now, 3m 2s total": total is runnable time minus time on a CPU.
+      def cpu_wait(row)
+        total = row.runnable_time && row.cpu_time && [row.runnable_time - row.cpu_time, 0.0].max
+        join(row.run_wait && "#{format('%.1f%%', row.run_wait)} now",
+             total && "#{R2UI::CLI::Ext::HumanFormat.duration(total)} total")
+      end
+
+      def pageins(row) = join(rate(row.pagein_rate), row.pageins && "#{row.pageins} total")
+
+      def faults(row)
+        cow = rate(row.cow_fault_rate)
+        base = rate(row.fault_rate)
+        return base && "#{base} (COW #{cow})" if cow
+
+        base
+      end
+
+      def read(row)
+        join(row.read_rate && "#{R2UI::Format.bytes(row.read_rate)}/s",
+             row.disk_read && "#{R2UI::Format.bytes(row.disk_read)} total")
+      end
+
+      # Events per second: whole numbers from 10/s up, one decimal below.
+      def rate(value)
+        return nil unless value
+
+        value >= 10 || value.zero? ? "#{value.round}/s" : format("%.1f/s", value)
+      end
+
+      def join(*parts)
+        known = parts.compact
+        known.empty? ? nil : known.join(", ")
+      end
+    end
+  end
+
+  detail_section :waits, order: 10 do |row, _reading|
+    UI::ProcessWaits.lines(row)
+  end
+
+  extend_resource :process do |_engine|
+    column :run_wait, label: "Wait", format: :percent, width: UI::ProcessWaits::WAIT_WIDTH
+    column :pagein_rate, label: "Pgin/s", format: :number, width: UI::ProcessWaits::PAGEIN_WIDTH
+    scope(:waiting) { |row| UI::ProcessWaits.waiting?(row) }
+  end
+end

data/lib/agentmon/ui/processes.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# The :process resource and the Processes panel (the main row): every process with its session,
+# directory, CPU %, footprint (what Activity Monitor calls Memory), resident size and disk rates.
+# Scope "Agents" (default) shows processes in agent sessions; "All" shows everything. Group by
+# session, directory, name, or as a tree (g); search with / (`footprint>500M`, `session~repo`).
+#
+# Other stories add to the resource with `Agentmon.extend_resource(:process) { ... }` (actions,
+# scopes, columns) instead of editing this file.
+module Agentmon
+  resource :process do |engine|
+    title "Processes"
+    source { engine.current[:process_rows] || [] }
+    refresh every: engine.interval
+    key :pid, parent: :ppid
+
+    scope :agents, default: true, &:session
+    scope :all
+
+    group_by :session, label: "Session"
+    group_by :cwd, label: "Directory"
+    group_by :name
+    group_by :parent, tree: true
+
+    index do
+      column :pid, format: :id
+      column :name
+      column :session, label: "Session"
+      column :cwd, label: "Directory", format: :short_path
+      column :cpu, label: "CPU", format: :percent, sparkline: true, sort: :desc
+      column :footprint, label: "Footprint", format: :bytes
+      column :resident, label: "Resident", format: :bytes
+      column :read_rate, label: "Read", format: :bytes_per_sec
+      column :write_rate, label: "Write", format: :bytes_per_sec
+    end
+
+    filter :name, :cwd, :session, :path
+  end
+
+  # span 3: a detail pane beside it (span 1) takes a quarter of the row.
+  panel :process, row: :main, order: 100, span: 3
+end

data/lib/agentmon/ui/session_focus.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# Drill into one agent session: every panel narrows to it.
+#
+#   enter   on a Sessions row: focus that session (anywhere else enter still toggles a group)
+#   F       focus the session of the row selected in Processes ("not in an agent session" if none)
+#   escape  back to every session
+#
+# Focus lives in the core (`engine.focus=`, lib/agentmon/focus.rb): panels keep reading
+# `engine.current[...]`, which narrows itself, so Processes, Sessions and the pressure drivers show
+# only the focused session once their feeds refresh. Each change refreshes every feed at once, so
+# the next frame is already narrowed. While focused the status bar says
+#
+#   focus: claude 4242 · repo (esc: all)
+#
+# and a focused session that has left the ledger clears itself (and refreshes) on the next frame.
+module Agentmon
+  module UI
+    module SessionFocus
+      SESSIONS = :session
+      PROCESSES = :process
+      NO_SESSION = "not in an agent session"
+      SEVERAL = "rows span several sessions: ungroup (g) to pick one"
+
+      module_function
+
+      # Sets the engine's focus (nil clears it) and refreshes every feed, so the next frame shows it.
+      def focus!(app, engine, session_id)
+        engine.focus = session_id
+        app.feeds.each_value(&:refresh!)
+      end
+
+      # The session id of the line selected in the Sessions panel; nil on a group line or none.
+      def selected_session(app)
+        line = selected_line(app, SESSIONS)
+        return nil if line.nil? || line.id.is_a?(Array) # [:group, by, key]: enter toggles it
+
+        line.id
+      end
+
+      # The session of the line selected in Processes: [session_id, nil] or [nil, message to flash].
+      # A group line focuses its session when every process in it is in that one session.
+      def process_session(app)
+        line = selected_line(app, PROCESSES) or return [nil, nil]
+
+        row = line.rows.find { |r| r.pid == line.id }
+        ids = (row ? [row] : line.rows).map(&:session_id).uniq
+        return [ids.first, nil] if ids.size == 1 && ids.first
+        return [nil, NO_SESSION] if ids.compact.empty?
+
+        [nil, SEVERAL]
+      end
+
+      # The status bar text while focused; nil when unfocused.
+      def status(engine)
+        session = engine.focused_session
+        session && "focus: #{session.label} (esc: all)"
+      end
+
+      # Clears a focus whose session has left the ledger (and refreshes). True when it did. A
+      # reading without a ledger (that metric failed this sample) keeps the focus.
+      def clear_if_gone(app, engine)
+        id = engine.focus or return false
+        ledger = engine.current(focused: false)[:session_ledger]
+        return false if ledger.nil? || ledger.any? { |s| s.id == id }
+
+        focus!(app, engine, nil)
+        true
+      end
+
+      def selected_line(app, name)
+        panel = app.dashboard.panels.find { |p| p.name == name }
+        state = panel && app.panel_state(panel)
+        state && app.panel_lines(panel)[state.selected]
+      end
+    end
+  end
+
+  # Hands the engine to the extension below through the dashboard, so only a dashboard built by
+  # UI.install (with its own engine) gets these keys.
+  R2UI.extension :agentmon_session_focus do
+    dsl :dashboard do
+      def agentmon_session_focus(engine) = declare(:agentmon_session_focus, engine)
+    end
+
+    helpers do
+      # The engine of the dashboard drawing, nil on dashboards that aren't agentmon's.
+      def session_focus_engine = dashboard.declared(:agentmon_session_focus).first
+    end
+
+    on(->(m) { m.is_a?(Bubbletea::KeyMessage) && [:enter, "F", :escape].include?(R2UI::Keys.name(m)) }) do |message|
+      engine = session_focus_engine or pass
+      focus = UI::SessionFocus
+      case R2UI::Keys.name(message)
+      when :enter
+        pass unless app.focus&.name == focus::SESSIONS
+        id = focus.selected_session(app) or pass
+        focus.focus!(app, engine, id)
+      when "F"
+        id, problem = focus.process_session(app)
+        id ? focus.focus!(app, engine, id) : (problem && flash(problem))
+      when :escape
+        pass unless engine.focus
+        focus.focus!(app, engine, nil)
+      end
+      nil
+    end
+
+    # Feeds' own refreshes arrive as updates too: a session that left the ledger clears here even
+    # while a flash hides the status bar.
+    after_update do
+      engine = session_focus_engine
+      UI::SessionFocus.clear_if_gone(app, engine) if engine
+    end
+
+    status do
+      engine = session_focus_engine
+      next nil unless engine
+
+      UI::SessionFocus.clear_if_gone(app, engine)
+      UI::SessionFocus.status(engine)
+    end
+  end
+
+  dashboard { |engine| agentmon_session_focus(engine) }
+end

data/lib/agentmon/ui/session_memory.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# The :session_memory resource and the "Memory by session" panel (top row, right): how much real
+# memory each alive agent session holds, largest first, and whether it is growing or paging.
+#
+#   ╭─ Memory by session ──────────────────────────────────────────────────╮
+#   │compressed 2.0G · swap 512M (per-process compressed/swap needs root)  │
+#   │Session              Footprint▼       Share  Resident    Growth Pgin/s│
+#   │claude 4242 · repo   ▂▃▅▇      2.1G   26.3%      2.4G   +1.5M/s   10.0│
+#   │Claude 59334         ▅▅▅▅      900M   11.0%      1.1G    -12K/s    0.0│
+#   ╰──────────────────────────────────────────────────────────────────────╯
+#
+# Footprint is what Activity Monitor calls Memory (it includes the session's compressed pages),
+# summed over the session's processes, each once; Share is its percent of used memory; Growth is
+# its footprint change per second over the last minute; Pgin/s counts page-ins per second (each
+# one waited for the disk). The first line is the machine's compressed memory and swap used:
+# macOS splits those out per process only for root. It is blank while memory is unavailable.
+# A narrow panel drops columns from the right (150 columns show Session and Footprint;
+# 220 add Share and Resident).
+# Follows session focus (enter on a session): then only the focused session is listed.
+module Agentmon
+  module UI
+    module SessionMemoryPanel
+      NOTE = "(per-process compressed/swap needs root)"
+
+      module_function
+
+      # reading[:session_memory] as rows; none while it is unavailable.
+      def rows(reading)
+        (reading[:session_memory] || []).map do |m|
+          { id: m.session_id, label: m.label, footprint: m.footprint, share: m.share, resident: m.resident,
+            growth_rate: m.growth_rate, growth: growth(m.growth_rate), pagein_rate: m.pagein_rate }
+        end
+      end
+
+      # "+1.5M/s", "-12K/s"; "" when unknown. (r2ui's :bytes_per_sec has no sign.)
+      def growth(rate)
+        return "" if rate.nil?
+
+        "#{rate.negative? ? "-" : "+"}#{R2UI::Format.bytes(rate.abs)}/s"
+      end
+
+      # "compressed 2.0G · swap 512M (per-process compressed/swap needs root)", cut to `width`;
+      # "" without a MemoryView.
+      def machine_line(memory, width)
+        return "" unless memory
+
+        f = R2UI::Format
+        text = "compressed #{f.bytes(memory.compressed.to_i)} · swap #{f.bytes(memory.swap_used.to_i)} #{NOTE}"
+        text.length > width ? "#{text[0, [width - 1, 0].max]}…" : text
+      end
+    end
+  end
+
+  resource :session_memory do |engine|
+    title "Memory by session"
+    source { UI::SessionMemoryPanel.rows(engine.current) }
+    refresh every: engine.interval
+    key :id
+
+    index do
+      column :label, label: "Session"
+      column :footprint, label: "Footprint", format: :bytes, sparkline: true, sort: :desc
+      column :share, label: "Share", format: :percent
+      column :resident, label: "Resident", format: :bytes
+      column :growth, label: "Growth", width: 8, align: :right
+      column :pagein_rate, label: "Pgin/s", format: :number, width: 6
+    end
+
+    filter :label
+  end
+
+  panel :session_memory, row: :top, order: 30, span: 1, title: "Memory by session" do |engine|
+    # Above the table: r2ui's table takes all the height left, so nothing after it is drawn.
+    view { UI::SessionMemoryPanel.machine_line(engine.current(max_age: Float::INFINITY)[:memory], width) }
+    table
+  end
+end

data/lib/agentmon/ui/sessions.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+# The :session resource and the Sessions panel (top row, beside the memory panel): one line per
+# agent session with its process count, CPU % and footprint now (with sparklines), peak footprint,
+# CPU seconds and bytes written over its life, disk rates now and its age. Sorted by CPU.
+# Scope "Live" (default) shows running sessions; "All" (]) adds the ones that ended in the last
+# 15 minutes, labelled with when:
+#
+#   Session                       Procs     CPU  Footprint    Peak  CPU s  Written   Read     Write  Age
+#   claude 4242 · repo                4  150.0%       628M    700M   15.6     5.0M  0B/s  1000B/s  56m
+#   claude 4310 · web · ended 3m ago  0    0.0%         0B    150M    5.0       0B  0B/s     0B/s  1h 2m
+#
+# Age is how long a session has run: since its root process started, until it ended.
+# Search with / (`label~repo`, `footprint>1G`).
+module Agentmon
+  module UI
+    # Turns the ledger's Session records into the panel's rows.
+    module SessionsPanel
+      module_function
+
+      NO_NETWORK = { net_in_rate: nil, net_out_rate: nil, bytes_in: nil, bytes_out: nil, connections: nil,
+                     remote_hosts: nil, net_flags: [].freeze }.freeze
+
+      # reading[:session_ledger] as rows; none while no ledger is available. Each row also carries
+      # its session's network (reading[:session_network], matched by session id): nil values and
+      # no flags while network data is unknown or the session has no entry.
+      def rows(reading)
+        now = reading.at
+        network = (reading[:session_network] || []).to_h { |n| [n.session_id, n] }
+        (reading[:session_ledger] || []).map { |s| row(s, now, network[s.id]) }
+      end
+
+      def row(session, now, network = nil)
+        ended = session.ended_at
+        {
+          id: session.id,
+          alive: session.alive?,
+          label: ended ? "#{session.label} · ended #{age(now - ended)} ago" : session.label,
+          cwd: session.cwd,
+          search: session.label,  # uncut, for `/` (not a column)
+          title: session.title,   # human name (also at the front of label); nil when unknown
+          status: session.status, # Claude Code's "busy"/"idle"; nil when unknown
+          processes: session.processes,
+          cpu: session.cpu,
+          footprint: session.footprint,
+          peak_footprint: session.peak_footprint,
+          cpu_seconds: session.cpu_seconds,
+          bytes_written: session.bytes_written,
+          read_rate: session.read_rate,
+          write_rate: session.write_rate,
+          age: age((ended || now) - (session.started_at || session.first_seen_at)),
+          **network_values(network)
+        }
+      end
+
+      # A SessionNetwork as row values (NO_NETWORK for nil).
+      def network_values(n)
+        return NO_NETWORK unless n
+
+        { net_in_rate: n.in_rate, net_out_rate: n.out_rate, bytes_in: n.bytes_in, bytes_out: n.bytes_out,
+          connections: n.connections, remote_hosts: n.remote_hosts, net_flags: Array(n.flags) }
+      end
+
+      # "45s", "12m", "3h 5m", "2d 4h"; "" when unknown.
+      def age(seconds)
+        return "" if seconds.nil?
+
+        s = [seconds.to_i, 0].max
+        if s < 60 then "#{s}s"
+        elsif s < 3600 then "#{s / 60}m"
+        elsif s < 86_400 then "#{s / 3600}h #{s % 3600 / 60}m"
+        else "#{s / 86_400}d #{s % 86_400 / 3600}h"
+        end
+      end
+    end
+  end
+
+  resource :session do |engine|
+    title "Sessions"
+    source { UI::SessionsPanel.rows(engine.current) }
+    refresh every: engine.interval
+    key :id
+
+    scope :live, default: true do |row|
+      row[:alive]
+    end
+    scope :all
+
+    index do
+      column :label, label: "Session"
+      column :processes, label: "Procs", format: :integer
+      column :cpu, label: "CPU", format: :percent, sparkline: true, sort: :desc
+      column :footprint, label: "Footprint", format: :bytes, sparkline: true
+      column :peak_footprint, label: "Peak", format: :bytes
+      column :cpu_seconds, label: "CPU s", format: :number
+      column :bytes_written, label: "Written", format: :bytes
+      column :read_rate, label: "Read", format: :bytes_per_sec
+      column :write_rate, label: "Write", format: :bytes_per_sec
+      column :age, label: "Age", width: 7, align: :right # fixed, so the label takes the spare width
+    end
+
+    # `/` matches the whole label (name included), not the Session column's text: r2ui's search
+    # reads a column through its reader (search.rb:31), and a view cuts that one to its width.
+    filter :search, :cwd
+  end
+
+  # Network columns, on performance views only (--layout): the default dashboard keeps its columns.
+  extend_resource :session do |_engine|
+    next unless Agentmon::Views.installing
+
+    column :net_in_rate, label: "Net in", format: :bytes_per_sec
+    column :net_out_rate, label: "Net out", format: :bytes_per_sec
+    column :bytes_in, label: "Recv", format: :bytes
+    column :bytes_out, label: "Sent", format: :bytes
+    column :connections, label: "Conns", format: :integer
+    column :remote_hosts, label: "Hosts", format: :integer
+  end
+
+  panel :session, row: :top, order: 20, span: 2
+
+  # r2ui focuses the first table panel, which is now Sessions (top row). Keys and the first
+  # frame belong to Processes, so give it focus when the agentmon dashboard starts. Stopgap
+  # until the core focuses :process itself.
+  R2UI.extension :agentmon_sessions_focus do
+    setup do
+      process = dashboard.name == UI::DASHBOARD && dashboard.panels.find { |p| p.name == :process }
+      app.focus = process if process
+    end
+  end
+end