buninu-linux 0.3.0 → 0.4.0

package/initramfs/usr/share/doc/buninu-linux/bunterm.md

@@ -0,0 +1,83 @@
+# bunterm — a graphical terminal on the Linux framebuffer
+
+`bunterm` runs a program on a pseudo-terminal and draws its screen on
+`/dev/fb0` with Skia (CanvasKit), so a real Linux console gets an
+xterm-compatible terminal with anti-aliased text, CJK, colour emoji, seamless
+box drawing and kitty graphics protocol images — no X11, Wayland or GPU.
+
+```sh
+bunterm                      # run /bin/sh on the console you are on
+bunterm /dev/tty1            # use virtual console 1 for graphics and keys
+bunterm --font-size 20
+bunterm -e bun /buninu/apps/jsmdcui/src/index.js --demo
+bunterm -h
+```
+
+The program's `TERM` is `xterm-256color`, `COLORTERM=truecolor`,
+`TERM_PROGRAM=bunterm` and `JSMDCUI_KITTY_MODE=extended` (so `jsmdcui` shows
+Markdown images without `--kitty`). When it exits, the console returns to
+text mode and `bunterm` exits with its status.
+
+## Options
+
+| Option | Meaning |
+| --- | --- |
+| `/dev/ttyN` | The virtual console to use for graphics and the keyboard. If another console is on screen, the display switches to this one first and back when `bunterm` exits. Without it the process's own console and stdin are used, so run it from a VT (not a serial line or a PTY). |
+| `-e command [argument...]` | The program to run; everything after `-e` belongs to it. Default `/bin/sh`. |
+| `--font-size N` | Font size in pixels (default 16). The cell is 0.6 × N wide and 1.16 × N tall with DejaVu Sans Mono, so 1024×768 at 16 px gives 106 × 41 cells. |
+| `--line-height F` | Multiplies the cell height (default 1). |
+| `--fb /dev/fbN` | The framebuffer device (default `/dev/fb0`). |
+| `--no-blink` | A steady cursor. |
+
+## What is drawn
+
+- **Text** comes from `/usr/share/fonts`: DejaVu Sans Mono (regular and
+  bold) sets the grid; Noto Sans CJK TC, Noto Color Emoji (+ Flags) and Noto
+  Sans Symbols fill in what it lacks. A glyph is centred in the one or two
+  cells the terminal assigned it; wide characters take two.
+- **Box drawing, block elements, shades and Powerline symbols** (U+2500–259F,
+  U+E0A0–E0BF, U+1FB70–1FB97) are drawn as vectors, ported from xterm.js, so
+  they join without seams at any size.
+- **Attributes**: 16 / 256 / 24-bit colours, bold (brighter for the eight base
+  colours), italic, dim, underline, strikethrough, inverse, invisible.
+- **Grapheme clusters** such as 🇹🇼 and 👨‍👩‍👧 occupy one cell each (xterm.js's
+  unicode-graphemes addon) and are shaped by Skia's paragraph engine.
+- **Images**: the kitty graphics protocol (`ESC _ G … ESC \`) with direct
+  transmission (`t=d`), PNG (`f=100`) or raw RGB/RGBA (`f=24`/`32`), zlib
+  (`o=z`), chunking (`m=`), cropping (`x,y,w,h`), sizing in cells (`c,r`),
+  cell offsets (`X,Y`), placements (`p=`), deletion (`a=d`) and queries
+  (`a=q`). An image is anchored to its line and scrolls with the text; on the
+  alternate screen it stays at its row and is removed when the program
+  leaves that screen. Any encoding Skia decodes (PNG, JPEG, WebP, GIF) is
+  accepted under `f=100`, as with jsgotty's `U=` extension.
+
+## Keyboard
+
+The console stays in the kernel's translated keyboard mode, so
+`Ctrl-Alt-F2` and friends still switch consoles; coming back repaints the
+screen. A few console-specific
+sequences are rewritten to xterm's (`F1`–`F5`, `Home`, `End`), and arrow keys
+follow the program's application cursor mode.
+
+## Limits
+
+- Needs a framebuffer: `linux-lts` has one built in, while the default
+  `linux-virt` builds it as modules the image does not ship, so build with
+  `--linux-lts` or `--real` (efifb/simpledrm from UEFI).
+- No mouse, no selection, no scrollback viewing (the buffer keeps 1000
+  lines for programs that query it).
+- A program that prints a terminal reply while the tty echoes (that is, one
+  not in raw mode) will see the reply echoed, as on any terminal.
+- Kitty images are drawn above text; `z` ordering below text and animation
+  frames are not implemented, and file transmission (`t=f`/`t=t`) works only
+  for files under `/tmp`, `/dev/shm` or `$TMPDIR`.
+- One framebuffer, one session. For panes and tabs run `jsmdcui` inside it.
+
+## See also
+
+- `/lib/bunterm/terminal.js` — `createSession()` and `runTerminal()`, the
+  pieces `bunterm` is built from
+- `/lib/canvas.js` — CanvasKit on the framebuffer (`canvas.md`)
+- `/lib/fbdev.js` — the framebuffer itself (`fbdev.md`)
+- `/buninu/apps/jsgotty/gotty.js` — the PTY backend and kitty packet parser
+  that are reused

package/initramfs/usr/share/doc/buninu-linux/canvas.md

@@ -0,0 +1,91 @@
+# canvas — CanvasKit (Skia) on the Linux framebuffer
+
+`/lib/canvas.js` runs Skia, compiled to WebAssembly as CanvasKit, on top of
+`/lib/fbdev.js`. Skia rasterizes straight into a buffer that already has the
+framebuffer's pixel layout, so a frame reaches `/dev/fb0` with one `memcpy`
+and no per-pixel conversion in JavaScript.
+
+## Drawing with Skia
+
+```js
+import { runGraphics } from "/lib/fbdev.js";
+import { loadCanvasKit, openCanvas, loadFontSet } from "/lib/canvas.js";
+
+const CanvasKit = await loadCanvasKit();
+const fonts = loadFontSet(CanvasKit, "ui");
+
+await runGraphics(async (display, { onRestore }) => {
+  const screen = openCanvas(CanvasKit, display);
+  const paint = new CanvasKit.Paint();
+  paint.setAntiAlias(true);
+  paint.setColor(CanvasKit.Color(64, 200, 255));
+  const font = new CanvasKit.Font(fonts.regular, 32);
+
+  screen.canvas.clear(CanvasKit.BLACK);
+  screen.canvas.drawCircle(display.width / 2, display.height / 2, 120, paint);
+  screen.canvas.drawText("Buninu 你好 😀", 40, 60, paint, font);
+  screen.flush();
+
+  await new Promise((resolve) => setTimeout(resolve, 3000));
+  screen.close();
+});
+```
+
+`screen.canvas` is a Skia `Canvas` with the full CanvasKit API: paths,
+gradients, shaders, image filters, `drawImage`, `drawGlyphs`, `Paragraph`
+layout with font fallback, PNG/JPEG decoding, and so on.
+
+## Exports
+
+| Export | Purpose |
+| --- | --- |
+| `loadCanvasKit()` | Loads `/lib/canvaskit/canvaskit.wasm` once per process and resolves to the `CanvasKit` object. The wasm heap starts at 128 MiB. |
+| `openCanvas(CanvasKit, display)` | Binds a raster surface to an open `Framebuffer`. Returns `{ canvas, surface, width, height, colorType, flush(), close() }`. While open, `display.pixels` is the surface's own memory, so `drawLine()`, `fillPolygon()` and `flush()` from `fbdev.js` keep working on the same frame. `close()` hands the last frame back to the JavaScript buffer. |
+| `pickColorType(CanvasKit, display)` | The Skia `ColorType` matching the framebuffer: `BGRA_8888` for the usual 32-bit XRGB (efifb, simpledrm), `RGBA_8888`, `RGB_565`; `null` for anything else, which `openCanvas` rejects. |
+| `loadFontSet(CanvasKit, name)` | A font set from `/usr/share/fonts/fonts.json` (`"terminal"` or `"ui"`) as `{ regular, bold, fallback, typefaces, fontMgr, families, delete() }`. `fontMgr` and `families` are what `ParagraphStyle` wants; a collection such as Noto Sans CJK registers every face and yields its preferred one (TC). |
+| `fontCatalogue()`, `fontPath(name)`, `loadFontData(name)` | The parsed `fonts.json`, a font's path, and its bytes (cached). |
+
+## Formats
+
+The framebuffer reports its channels as bit offsets. Skia can rasterize
+directly into three of the layouts Linux uses:
+
+| Framebuffer | Skia |
+| --- | --- |
+| 32 bpp, red@16 green@8 blue@0 (XRGB8888) | `BGRA_8888` |
+| 32 bpp, red@0 green@8 blue@16 (XBGR8888) | `RGBA_8888` |
+| 16 bpp, 5-6-5 | `RGB_565` |
+
+For a 24 bpp or paletted framebuffer, draw with the HTML canvas emulation
+instead and copy through `blitImageData()`:
+
+```js
+const canvas = CanvasKit.MakeCanvas(display.width, display.height);
+const ctx = canvas.getContext("2d");
+ctx.fillStyle = "#40c8ff";
+ctx.fillRect(0, 0, 200, 100);
+blitImageData(display, ctx.getImageData(0, 0, display.width, display.height));
+flush(display);
+```
+
+That path converts every pixel in JavaScript and is fine for static screens.
+
+## Fonts
+
+`/usr/share/fonts/fonts.json` lists the bundled files and two sets:
+
+| Set | Regular | Fallback order |
+| --- | --- | --- |
+| `terminal` | DejaVu Sans Mono (+ Bold) | Noto Color Emoji, Noto Color Emoji Flags, Noto Sans CJK, Noto Sans Symbols, Noto Sans Symbols2 |
+| `ui` | Roboto | Noto Sans CJK, Noto Color Emoji, Noto Color Emoji Flags, Noto Sans Symbols, Noto Sans Symbols2 |
+
+Files load on first use and are copied into the wasm heap; the CJK
+collection is 32 MiB, so a program that never draws CJK text should not
+load a set containing it. Each file's license sits beside it.
+
+## See also
+
+- `/lib/canvas.js`, `/lib/canvaskit/` (CanvasKit 0.41.1, BSD-3-Clause)
+- `/lib/fbdev.js` — `fbdev.md`
+- `/lib/bunterm/` — the terminal built on this (`bunterm.md`)
+- CanvasKit API: https://skia.org/docs/user/modules/canvaskit/

package/initramfs/usr/share/doc/buninu-linux/fbdev.md

@@ -0,0 +1,113 @@
+# fbdev — draw directly on the Linux framebuffer
+
+`/lib/fbdev.js` is both an importable drawing module and a small executable
+demo. It uses `/dev/fb0`, framebuffer ioctls, a shared `mmap`, and `KDSETMODE`
+through Bun FFI; it does not require X11, Wayland, SDL, or a window manager.
+
+## Demo
+
+Run it on Buninu's physical Linux console:
+
+```sh
+bun /lib/fbdev.js
+```
+
+The demo switches the active console to graphics mode, clears the framebuffer,
+draws a cyan triangle, and waits. Press any key to restore text mode and exit.
+Ordinary failures, direct process exit, `SIGHUP`, `SIGINT`, `SIGQUIT`, and
+`SIGTERM` also restore the prior keyboard raw state and attempt to return the
+console to text mode.
+
+Each repeatable `-p`/`--points` supplies one polygon as x,y coordinate pairs:
+
+```sh
+bun /lib/fbdev.js -p '100,50 40,250 300,250'
+bun /lib/fbdev.js \
+  -p '100,50 40,250 300,250' \
+  -p '400,80 350,220 450,220'
+```
+
+Every occurrence draws a separate filled polygon. Comma and whitespace
+separators may be mixed inside its quoted value; the clearest form uses a
+comma within each `x,y` point and spaces between points. If one polygon
+contains an odd number of numeric values, its final unpaired value is ignored.
+A `-p` containing only one number is therefore ignored as a whole. Each
+non-empty polygon needs at least three complete points; more than three points
+remain one polygon rather than starting another. If no drawable `-p` remains,
+the demo draws its default triangle.
+
+## JavaScript API
+
+```js
+import {
+  openFramebuffer,
+  clear,
+  drawPoint,
+  drawLine,
+  drawLines,
+  fillPolygon,
+  flush,
+} from "/lib/fbdev.js";
+
+const display = openFramebuffer();
+try {
+  clear(display);
+  fillPolygon(display, [[100, 50], [40, 250], [300, 250]], {
+    r: 64, g: 200, b: 255, a: 255,
+  });
+  drawLine(display, 0, 0, display.width - 1, display.height - 1, {
+    r: 255, g: 255, b: 255,
+  });
+  flush(display);
+} finally {
+  display.close();
+}
+```
+
+The API uses short drawing names because it operates on a framebuffer rather
+than an X11 `Display`. Colours are `{ r, g, b, a }` objects.
+
+### Export reference
+
+| Export | Purpose |
+| --- | --- |
+| `Framebuffer`, `openFramebuffer(path?)` | Open and describe a packed-pixel framebuffer. |
+| `normalizePoints(values)` | Accept flat numbers, `[x,y]` arrays, or `{x,y}` objects. An unpaired flat value is ignored. |
+| `parsePoints(strings)` | Parse comma/whitespace-separated CLI-style coordinates. |
+| `drawPoint(display, x, y, color?)` | Draw one clipped pixel. |
+| `drawLine(display, x1, y1, x2, y2, color?)` | Draw a clipped Bresenham line. |
+| `drawLines(display, points, color?, close?)` | Join a sequence of points. |
+| `fillPolygon(display, points, color?)` | Fill a polygon with the even-odd scanline rule. |
+| `clear(display, color?)` | Fill the in-memory frame, black by default. |
+| `flush(display)` | Copy the in-memory frame to the shared `/dev/fb0` mapping and synchronize it. |
+| `blitImageData(display, imageData, x?, y?)` | Copy an RGBA `ImageData` (for example from CanvasKit's HTML canvas emulation) into the frame, converting to the framebuffer's format and clipping. |
+| `openConsole`, `setConsoleGraphics`, `setConsoleText` | Explicit Linux virtual-console control for callers that need it. |
+| `activeConsole(console)`, `activateConsole(console, n)`, `consoleNumber(path)` | `VT_GETSTATE` / `VT_ACTIVATE` + `VT_WAITACTIVE`, and the number in a `/dev/ttyN` path. |
+| `watchConsoleSwitches(console, onAcquire)` | `VT_SETMODE` with `VT_PROCESS`: answers the kernel's switch-away and switch-back signals and calls `onAcquire` when the display returns. Returns a function restoring automatic switching. |
+| `runGraphics(draw, { device, console, switchConsole }?)` | Open the framebuffer, put the console in graphics mode, run `await draw(display, { console, onRestore, onAcquire })`, and restore text mode however the call ends (return, throw, `process.exit()`, `SIGHUP`/`SIGINT`/`SIGQUIT`/`SIGTERM`). `console` lists console devices to try, such as `["/dev/tty1"]`; when the one opened is a `/dev/ttyN` other than the console on screen, the display is switched to it first and back afterwards (`switchConsole: false` disables this). Console switches with Ctrl-Alt-Fn keep working; `onAcquire(callback)` runs when the display comes back so the caller can repaint, and `onRestore(callback)` registers cleanup to run before text mode returns. |
+| `runDemo({ polygons, device }?)` | Run the CLI demo through `runGraphics()`. Each item in `polygons` is drawn separately. |
+
+The module supports 16-, 24-, and 32-bit packed-pixel framebuffers and uses
+the kernel-reported stride, offsets, and RGB bitfields. Paletted and unusual
+non-packed framebuffer formats are rejected rather than drawn incorrectly.
+
+## Operational limits
+
+- Run the demo from a real Linux virtual console. A PTY, serial console, SSH
+  session, or terminal pane cannot accept `KDSETMODE`.
+- The framebuffer device and active virtual console must be accessible to the
+  process; Buninu normally runs as root.
+- Imported drawing calls modify an in-memory frame until `flush()` is called.
+- Importing the module does not switch console mode. Only `runDemo()` or an
+  explicit `setConsoleGraphics()` call does so.
+- No userspace cleanup can run after `SIGKILL`, a kernel panic, power loss, or
+  a native runtime crash. If one leaves the virtual console in graphics mode,
+  switch to another VT or reboot to recover it.
+
+## See also
+
+- Source: `/lib/fbdev.js`
+- Shared native binding: `/lib/dlopen.js`
+- Skia on this framebuffer: `/lib/canvas.js` (`canvas.md`); the terminal
+  built on both: `bunterm`
+- Linux UAPI: `linux/fb.h` and `linux/kd.h`

package/initramfs/usr/share/doc/buninu-linux/ps.md

@@ -0,0 +1,94 @@
+# ps — list processes
+
+`/bin/ps` is a small Bun script that reads `/proc`. Its primary interface is
+the full-command-line table consumed by bunmsh's `pspa` and coloured `pspac`
+builtins.
+
+The file is also an importable module. It exports `readProcessSnapshot()`,
+`prepareProcessFormat()`, `formatProcessHeader()`, and
+`formatProcessLine()`. `/bin/top` uses these exports, so process discovery and
+single-row formatting have one implementation.
+
+## Synopsis
+
+```sh
+ps
+ps -e | -A [-o pid,args]
+ps -eo pid,args
+ps -ef | ps aux | ps ax
+ps -h | --help                       # this page
+```
+
+## Options
+
+| Option | Meaning |
+|---|---|
+| `-e`, `-A`, `--all` | List every process instead of the default same-UID/same-TTY selection. |
+| `-o FIELDS` | Select and order comma- or space-separated output fields. See below. |
+| `-ef` | Full Unix view: UID, PID/PPID, CPU, start, TTY, accumulated time, and command. |
+| `-eF` | Extra-full Unix view, adding `SZ`, `RSS`, and current processor (`PSR`). |
+| `aux`, `-aux` | BSD view with user, CPU/memory percentages, VSZ/RSS, TTY, state, start, time, and command. |
+| `ax`, `-ax` | Compact BSD view with PID, TTY, state, time, and command. |
+| `-h`, `--help` | Render this page. |
+
+`-e` and `-o` may be combined as `-eo pid,args`, which is the form bunmsh
+uses. Rows are sorted numerically by PID. A process with an empty cmdline is
+shown using its `/proc/PID/comm` name in brackets, as for a kernel thread.
+With no `-o` or extended view, the standard columns are `PID TTY TIME CMD`,
+and `CMD` is the short process name. The default selection is the caller's
+effective UID and terminal, excluding session leaders. `-e`/`-A` selects all;
+`a`, `x`, `-a`, and `-x` apply their usual BSD or Unix selection rules.
+
+Plain `ps` excludes processes carrying Linux's `PF_KTHREAD` flag. This matters
+on boot consoles where the shell and kernel threads may all be UID 0 without a
+controlling TTY. Explicit all-process forms such as `ps -e`, `ps -A`, and
+`ps -eo ...` include kernel threads.
+
+### `-o` fields
+
+Supported names are:
+
+```text
+pid ppid uid user euser comm args cmd command tty tt stat state c
+%cpu pcpu %mem pmem vsz rss sz time etime etimes
+start stime lstart ni nice pri psr
+```
+
+They may be combined and reordered, for example:
+
+```sh
+ps -eo pid,ppid,user,comm
+ps -eo pid,stat,%cpu,%mem,rss,args
+ps -o pid,tty,time,comm
+```
+
+`comm` is the kernel's short process name; `args` is the complete command
+line. The exact `pid,args` layout remains the interface consumed by bunmsh.
+
+## Examples
+
+```sh
+ps
+ps -eo pid,args
+ps -ef                         # common LLM/tutorial spelling
+ps aux
+pspac                         # bunmsh: the same table with syntax colours
+```
+
+## Limits
+
+Values come from `/proc/PID/stat`, `/proc/PID/status`, `/proc/uptime`, and
+`/proc/meminfo`; user names come from `/etc/passwd`. CPU percentages are the
+process's average since it started, and memory percentage is resident memory
+over `MemTotal`. Forest display, custom column headings, and less common
+procps fields remain outside this minimal command. `/proc` must be mounted.
+
+## Exit status
+
+`0` success, `1` bad usage or `/proc` could not be read.
+
+## See also
+
+- `ip --help`
+- Source: `initramfs/bin/ps` in
+  [buninu-linux](https://github.com/jjtseng93/buninu-linux)

package/initramfs/usr/share/doc/buninu-linux/reboot.md

@@ -0,0 +1,15 @@
+# reboot — restart Buninu Linux
+
+`reboot` flushes pending filesystem writes with `sync(2)`, then requests
+`LINUX_REBOOT_CMD_RESTART` through Linux `reboot(2)`. It shares its
+implementation with `poweroff` and does not invoke a service manager.
+
+## Usage
+
+```sh
+reboot
+reboot --help
+```
+
+The caller needs the kernel's `CAP_SYS_BOOT` capability. Buninu's root shell
+has it; otherwise the command reports `Operation not permitted` and exits.

package/initramfs/usr/share/doc/buninu-linux/tar.md

@@ -0,0 +1,73 @@
+# tar — create and extract archives
+
+`/bin/tar` is a small Bun script over `Bun.Archive`. It handles uncompressed
+tar archives plus gzip and zstd without invoking another program.
+
+## Synopsis
+
+```sh
+tar -cf ARCHIVE FILE...
+tar -czf ARCHIVE FILE...
+tar --zstd -cf ARCHIVE FILE...
+tar -xf ARCHIVE [-C DIR] [MEMBER...]
+tar -tf ARCHIVE [MEMBER...]
+tar -h | --help                         # this page
+```
+
+Use `-` as ARCHIVE to read from standard input or write to standard output.
+
+## Options
+
+| Option | Meaning |
+|---|---|
+| `-c` | Create an archive. |
+| `-x` | Extract an archive. |
+| `-t` | List archive members. |
+| `-f ARCHIVE`, `--file=ARCHIVE` | Archive file, or `-` for standard input/output. |
+| `-C DIR`, `--directory=DIR` | Read input files from DIR, or extract into DIR. |
+| `-z`, `--gzip` | Create gzip-compressed tar, or explicitly identify gzip input. |
+| `--zstd` | Create or read a zstd-compressed tar. A `.zst` or `.tzst` input is also detected by name. |
+| `-v` | Print names while creating/extracting; with `-t`, also show each regular file's size and modification time. |
+
+Short options can be combined, for example `-xzvf` or `-czf`.
+For the traditional first option word, the leading hyphen is optional, so
+`tar tf`, `tar xf`, and `tar cf` are equivalent to `tar -tf`, `tar -xf`, and
+`tar -cf`.
+
+## Examples
+
+```sh
+tar -czf source.tar.gz src README.md
+tar -xzf source.tar.gz -C /tmp/source
+tar -tf source.tar.gz
+tar --zstd -cf backup.tar.zst home
+tar --zstd -xf backup.tar.zst -C /mnt/restore
+```
+
+## Current Bun.Archive limits
+
+Creation stores regular files only. Symbolic links are rejected rather than
+silently archived as the wrong type; modes, ownership, hard links, and empty
+directories are not preserved. Bun 1.4.3 also requires file contents to be
+materialized in memory before archive creation.
+
+Extraction restores directories and symbolic links, but Bun 1.4.3 skips hard
+links. Listing and verbose extraction use `Archive.files()`, so they report
+regular files only. Verbose listing can show their size and modification time,
+but not the unavailable mode or owner. Bun provides gzip and zstd codecs but no xz or bzip2 codec,
+so this command does not accept `.tar.xz` or `.tar.bz2`.
+
+Appending with `-r`/`rvf` is not supported. `Bun.Archive` has no append API;
+rebuilding an existing archive through `Archive.files()` would silently lose
+its directories, links, ownership, and modes, so this command refuses instead.
+
+## Exit status
+
+`0` success, `2` bad usage or an archive/file operation failed.
+
+## See also
+
+- [Bun.Archive](https://bun.com/docs/runtime/archive)
+- [tar(1)](https://man7.org/linux/man-pages/man1/tar.1.html)
+- Source: `initramfs/bin/tar` in
+  [buninu-linux](https://github.com/jjtseng93/buninu-linux)

package/initramfs/usr/share/doc/buninu-linux/top.md

@@ -0,0 +1,23 @@
+# top
+
+`top` periodically reads the process snapshot exported by `/bin/ps`. Process
+discovery and row formatting are shared with `ps`; `top` only calculates CPU
+changes between refreshes, sorts rows, and redraws the screen.
+
+## Usage
+
+```sh
+top
+top -d 1
+top -b -n 1
+```
+
+- `-d SECONDS` sets the refresh interval (default: 3).
+- `-n COUNT` exits after that many snapshots.
+- `-b` uses batch output without terminal control sequences.
+- `-h`, `--help` displays this document.
+
+While running interactively, press `q` to quit, `P` to sort by CPU, `M` to
+sort by memory, or `N` to sort by PID. The first screen shows the lifetime CPU
+average available from `ps`; later screens show usage during the refresh
+interval.