docs(installer): use a durable ref in the usage example

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

.github/workflows/build-deb.yml

@@ -18,15 +18,7 @@ env:
 jobs:
   build-deb:
     name: Build .deb for ${{ matrix.target }}
-    # PINNED, not ubuntu-latest: the binaries link against this runner's
-    # (multiarch) glibc, so the runner sets the MINIMUM glibc the .debs demand
-    # at install time. ubuntu-latest moved to 24.04/glibc 2.39 and the packages
-    # stopped installing on Debian 12/RPi OS bookworm (glibc 2.36). 22.04 links
-    # 2.35, which bookworm satisfies. The "enforce glibc floor" step below
-    # turns any future violation into a red build instead of a fleet-wide apt
-    # failure — if this pin ever has to move past bookworm's glibc, that step
-    # is the contract to renegotiate first.
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     strategy:
       matrix:
         include:
@@ -167,22 +159,6 @@ jobs:
           mkdir -p debs
           cp target/${{ matrix.target }}/debian/*.deb debs/
 
-      - name: Enforce glibc floor (Debian 12 / RPi OS bookworm fleet)
-        run: |
-          # The fleet's oldest supported glibc. A .deb that demands newer libc6
-          # than this will not install on the Pis — fail HERE, not at apt time.
-          FLOOR="2.36"
-          fail=0
-          for deb in debs/*.deb; do
-            req=$(dpkg-deb -f "$deb" Depends | sed -n 's/.*libc6 (>= \([0-9.]*\)).*/\1/p' | head -1)
-            echo "$deb -> libc6 >= ${req:-none}"
-            if [ -n "$req" ] && [ "$(printf '%s\n' "$req" "$FLOOR" | sort -V | tail -1)" != "$FLOOR" ]; then
-              echo "::error::$deb requires libc6 >= $req, exceeding the fleet floor $FLOOR (bookworm). The build runner's glibc is too new — see the runs-on pin comment."
-              fail=1
-            fi
-          done
-          exit $fail
-
       - name: List generated packages
         run: ls -lh debs/
 

CHANGELOG.md

@@ -1,26 +1,8 @@
 # Changelog
 
-## Unreleased
+## 1.60.0 — unreleased
 
-### TUI
-
-- **`--no-kill` flag and `SOCKTOP_NO_KILL` env var** disable the local
-  process-kill feature regardless of agent locality, for shared terminals and
-  public demos (e.g. the socktop.io webterm). Either one forces the feature
-  off and suppresses the `t` kill hints; the env var covers every socktop
-  invocation under a deployment without touching command lines. `App`'s
-  builder renamed `with_local` → `with_kill_enabled` to match what it now
-  means (locality fact AND policy).
-
-## 1.60.1 — unreleased
-
-Identical to 1.60.0 plus rebuilt Debian packages: the 1.60.0 debs were linked
-against glibc 2.39 (a GitHub runner migration) and would not install on
-Debian 12 / Raspberry Pi OS bookworm. CI now pins the build environment and
-gates every package against the fleet's glibc floor. 1.60.0 was never
-published to crates.io.
-
-Everything since `v1.50.0`. Applies to all three crates (`socktop`, `socktop_agent`, `socktop_connector`), which move to 1.60.1 together.
+Everything since `v1.50.0`. Applies to all three crates (`socktop`, `socktop_agent`, `socktop_connector`), which move to 1.60.0 together.
 
 ### Security
 
@@ -69,13 +51,6 @@ Everything since `v1.50.0`. Applies to all three crates (`socktop`, `socktop_age
 - `socktop` consumes `socktop_connector` via a path+version dep — connector changes are testable in-repo before publishing.
 - wasm examples build against the in-repo connector; note `zellij_socktop_plugin` has pre-existing compile errors and needs its own rework.
 
-### Process kill (PR #40)
-
-- **Kill a local process from the TUI** (`t` on a selected process, or inside Process Details): btop-style Terminate/Force-kill confirmation. Local agents only — the signal is sent by socktop itself with its own privileges, never over the wire; remote agents never show the option. PID-reuse guarded (the confirmed name must still own the PID at signal time).
-- **Agent no longer reports dead processes**: a long-lived sysinfo `System` accumulated every process ever seen (21k+ entries on a 289-process host), inflating memory, per-poll work, and the process count — and keeping killed processes on screen forever. Update agent and client together on machines where the kill feature will be used.
-- Killed rows leave the list when the process actually exits and cannot be resurrected by cached agent snapshots; details views for dead processes close themselves, including through parent-navigation chains.
-- Selection hint no longer vanishes for long process names; confirmation/info dialogs size to their content.
-
 ### Upgrade notes
 
 - **Release/publish order**: `socktop_connector` → `socktop` → agent packages.

Cargo.lock

@@ -2412,7 +2412,7 @@ dependencies = [
 
 [[package]]
 name = "socktop"
-version = "1.60.2"
+version = "1.60.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2423,7 +2423,6 @@ dependencies = [
  "serde",
  "serde_json",
  "socktop_connector",
- "sysinfo",
  "tempfile",
  "tokio",
  "unicode-width",
@@ -2432,7 +2431,7 @@ dependencies = [
 
 [[package]]
 name = "socktop_agent"
-version = "1.60.2"
+version = "1.60.0"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -2464,7 +2463,7 @@ dependencies = [
 
 [[package]]
 name = "socktop_connector"
-version = "1.60.2"
+version = "1.60.0"
 dependencies = [
  "flate2",
  "futures-util",

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Witty One Off
+Copyright (c) 2025 Witty One Off
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,36 +1,548 @@
 # socktop
 
-_socktop_ is a remote system monitor with a rich TUI, talking to an ultra lightweight agent over WebSockets.
+socktop is a remote system monitor with a rich TUI, inspired by top/btop, talking to a lightweight agent over WebSockets.
 
-<img src="./docs/socktop_demo_1_60.apng" width="100%">
+- Linux agent: near-zero CPU when idle (request-driven, no always-on sampler)
+- TUI: smooth graphs, sortable process table, scrollbars, readable colors
 
-## Resources
+[socktop.io](https://www.socktop.io) 
 
-| Resource | Location |
-| -------- | -------- |
-| Website and online demo (yes it's real) | [socktop.io](https://www.socktop.io) |
-| Quick Start guide   | [https://socktop.io/assets/docs/installation/quick-start.html](https://socktop.io/assets/docs/installation/quick-start.html)  |
-| Prereqs | [https://socktop.io/assets/docs/installation/prerequisites.html](https://socktop.io/assets/docs/installation/prerequisites.html) |
-| APT Install | [https://socktop.io/assets/docs/installation/apt.html](https://socktop.io/assets/docs/installation/apt.html) |
-| Cargo Install | [https://socktop.io/assets/docs/installation/cargo.html](https://socktop.io/assets/docs/installation/cargo.html)
-| Usage | [https://socktop.io/assets/docs/usage/general.html](https://socktop.io/assets/docs/usage/general.html)
-| Auth Setup | [https://socktop.io/assets/docs/security/token.html](https://socktop.io/assets/docs/security/token.html) |
-| TLS Setup | [https://socktop.io/assets/docs/security/tls.html](https://socktop.io/assets/docs/security/tls.html) |
-| Monitoring Multiple Hosts | [tmux](https://socktop.io/assets/docs/advanced/tmux.html) / [zellij](https://socktop.io/assets/docs/advanced/zellij.html) |
+<img src="./docs/socktop_demo.apng" width="100%">
 
 ---
 
-## Platform Support
+## Features
 
-Linux (all flavors), ARM/Raspberry Pi (32b/64b), MacOS, Windows, RISC-V (experimental)
+- Remote monitoring via WebSocket (JSON over WS)
+- Optional WSS (TLS): agent auto‑generates a self‑signed cert on first run; client pins the cert via --tls-ca/-t 
+- TUI built with ratatui
+- CPU
+  - Overall sparkline + per-core mini bars
+  - Accurate per-process CPU% (Linux /proc deltas), normalized to 0–100%
+- Memory/Swap gauges with human units
+- Disks: per-device usage
+- Network: per-interface throughput with sparklines and peak markers
+- Temperatures: CPU (optional)
+- Top processes (top 50)
+  - PID, name, CPU%, memory, and memory%
+  - Click-to-sort by CPU% or Mem (descending)
+  - Scrollbar and mouse/keyboard scrolling
+  - Total process count shown in the header
+  - Only top-level processes listed (threads hidden) — matches btop/top
+- Optional GPU metrics (can be disabled)
+- Optional auth token for the agent
+- Compact layout for small windows: automatically drops the panes that no longer fit so
+  the CPU graph and per-core bars stay visible (see [Compact mode](#compact-mode))
 
 ---
 
-## Contributing
+## Prerequisites: Install Rust (rustup)
 
-Contributions are welcome and you have the freedom to use whatever development tools you would like, as long as there is a human in the loop and all the clippy and unit tests pass you are good to submit a PR. Defects / Bugs just go ahead and fix and file a PR. New features, please create a issue in advance and let me know you are offering to build it. I don't want to be in a position where you worked for a couple of weeks on something and I don't want to merge it.
+Rust is fast, safe, and cross‑platform. Installing it will make your machine better. Consider yourself privileged.
 
-### Development
+Linux/macOS:
+```bash
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+# load cargo for this shell
+source "$HOME/.cargo/env"
+# ensure stable is up to date
+rustup update stable
+rustc --version
+cargo --version
+# after install you may need to reload your shell, e.g.:
+exec bash   # or: exec zsh / exec fish
+```
+
+Windows (for the brave): install from https://rustup.rs with the MSVC toolchain. Yes, you’ll need Visual Studio Build Tools. You chose Windows — enjoy the ride.
+
+### Raspberry Pi / Ubuntu / PopOS (required for GPU support)
+
+**Note:** GPU monitoring is only supported on x86_64 and aarch64 (64-bit ARM) platforms. ARMv7 (32-bit) and RISC-V builds do not include GPU support.
+
+For 64-bit systems with GPU support:
+
+```bash
+sudo apt-get update
+sudo apt-get install libdrm-dev libdrm-amdgpu1
+```
+
+For ARMv7 (32-bit Raspberry Pi), build with `--no-default-features` to disable GPU support:
+
+```bash
+cargo build --release -p socktop_agent --no-default-features
+```
+
+_Additional note for Raspberry Pi users. Please update your system to use the newest kernel available through app, kernel version 6.6+ will use considerably less overall CPU to run the agent. For example on a rpi4 the kernel < 6.6 the agent will consume .8 cpu but on the same hardware on > 6.6 the agent will consume only .2 cpu. (these numbers indicate continuous polling at web socket endpoints, when not in use the usage is 0)_
+
+---
+
+## Architecture
+
+Two components:
+
+1) Agent (remote): small Rust WS server using sysinfo + /proc. It collects metrics only when the client requests them over the WebSocket (request-driven). No background sampling loop.
+
+2) Client (local): TUI that connects to ws://HOST:PORT/ws (or wss://HOST:PORT/ws when TLS is enabled) and renders updates.
+
+---
+
+## Quick start
+
+- Build both binaries:
+
+```bash
+git clone https://github.com/jasonwitty/socktop.git
+cd socktop
+cargo build --release
+```
+
+- Start the agent on the target machine (default port 3000):
+
+```bash
+./target/release/socktop_agent --port 3000
+```
+
+- Connect with the TUI from your local machine:
+
+```bash
+./target/release/socktop ws://REMOTE_HOST:3000/ws
+```
+
+### Cross-compiling for Raspberry Pi
+
+For Raspberry Pi and other ARM devices, you can cross-compile the agent from a more powerful machine:
+
+- [Cross-compilation guide](./docs/cross-compiling.md) - Instructions for cross-compiling from Linux, macOS, or Windows hosts
+
+### Quick demo (no agent setup)
+
+Spin up a temporary local agent on port 3231 and connect automatically:
+
+```bash
+socktop --demo
+```
+
+Or just run `socktop` with no arguments and pick the built‑in `demo` entry from the interactive profile list (if you have saved profiles, `demo` is appended). The demo agent:
+
+- Runs locally (`ws://127.0.0.1:3231/ws`)
+- Stops automatically (you'll see "Stopped demo agent on port 3231") when you quit the TUI or press Ctrl-C
+
+---
+
+## Install (from crates.io)
+
+You don’t need to clone this repo to use socktop. Install the published binaries with cargo:
+
+```bash
+# TUI (client)
+cargo install socktop
+# Agent (server)
+cargo install socktop_agent
+```
+
+This drops socktop and socktop_agent into ~/.cargo/bin (add it to PATH).
+
+Notes:
+- After installing Rust via rustup, reload your shell (e.g., exec bash) so cargo is on PATH.
+- Windows: you can also grab prebuilt EXEs from GitHub Actions artifacts if rustup scares you. It shouldn’t. Be brave.
+
+System-wide agent (Linux)
+
+```bash
+# If you installed with cargo, binaries are in ~/.cargo/bin
+sudo install -o root -g root -m 0755 "$HOME/.cargo/bin/socktop_agent" /usr/local/bin/socktop_agent
+
+# Install and enable the systemd service (example unit in docs/)
+sudo install -o root -g root -m 0644 docs/socktop-agent.service /etc/systemd/system/socktop-agent.service
+sudo systemctl daemon-reload
+sudo systemctl enable --now socktop-agent
+```
+
+```bash
+
+# Enable SSL
+
+# Stop service
+sudo systemctl stop socktop-agent
+
+# Edit service to append SSL option and port
+sudo micro /etc/systemd/system/socktop-agent.service
+
+--
+ExecStart=/usr/local/bin/socktop_agent --enableSSL --port 8443
+--
+
+# Reload
+sudo systemctl daemon-reload
+
+# Restart
+sudo systemctl start socktop-agent
+
+# check logs for certificate location
+sudo journalctl -u socktop-agent -f
+
+--
+Aug 22 22:25:26 rpi-master socktop_agent[2913998]: socktop_agent: generated self-signed TLS certificate at /var/lib/socktop/.config/socktop_agent/tls/cert.pem
+--
+
+```
+
+
+---
+
+## Usage
+
+Agent (server):
+
+```bash
+socktop_agent --port 3000
+# or env: SOCKTOP_PORT=3000 socktop_agent
+# optional auth: SOCKTOP_TOKEN=changeme socktop_agent
+# enable TLS (self‑signed cert, default port 8443; you can also use -p):
+socktop_agent --enableSSL --port 8443
+```
+
+Client (TUI):
+
+```bash
+socktop ws://HOST:3000/ws
+# with token:
+socktop "ws://HOST:3000/ws?token=changeme"
+# TLS with pinned server certificate (recommended over the internet):
+socktop --tls-ca /path/to/cert.pem wss://HOST:8443/ws
+# (By default hostname/SAN verification is skipped for ease on home networks. To enforce it add --verify-hostname)
+socktop --verify-hostname --tls-ca /path/to/cert.pem wss://HOST:8443/ws
+# shorthand:
+socktop -t /path/to/cert.pem wss://HOST:8443/ws
+# Note: providing --tls-ca/-t automatically upgrades ws:// to wss:// if you forget
+# force the small-window layout at any terminal size (normally automatic):
+socktop --compact ws://HOST:3000/ws
+```
+
+Intervals (client-driven):
+- Fast metrics: ~500 ms
+- Processes: ~2 s 
+- Disks: ~5 s
+
+The agent stays idle unless queried. When queried, it collects just what’s needed.
+
+---
+
+## Compact mode
+
+In a short terminal the fixed layout runs out of rows and the CPU graph and per-core bars
+are the first things to collapse — exactly the panes you are most likely watching. Once
+the window is too short for the Disks pane to show even one disk, socktop switches to a
+compact layout:
+
+- **Disks is dropped.** It is the pane that degrades worst when partially drawn.
+- **Memory and Swap move side by side** into the row Disks vacated.
+- **GPU shrinks to a single line** — utilisation and VRAM only, no device name. On a host
+  with no GPU the pane disappears entirely.
+- **Everything reclaimed goes to the CPU graph and per-core bars**, which stay usable well
+  below the size where they used to vanish.
+
+The switch is automatic and needs no configuration. Pass `--compact` to pin the compact
+layout at any window size:
+
+```bash
+socktop --compact ws://HOST:3000/ws
+```
+
+---
+
+## Connection Profiles (Named)
+
+You can save frequently used connection settings (URL + optional TLS CA path) under a short name and reuse them later.
+
+Config file location:
+
+- Linux (XDG): `$XDG_CONFIG_HOME/socktop/profiles.json`
+- Fallback (when XDG not set): `~/.config/socktop/profiles.json`
+
+### Creating a profile
+
+First time you specify a new `--profile/-P` name together with a URL (and optional `--tls-ca`), it is saved automatically:
+
+```bash
+socktop --profile prod ws://prod-host:3000/ws
+# With TLS pinning:
+socktop --profile prod-tls --tls-ca /path/to/cert.pem wss://prod-host:8443/ws
+
+You can also set custom intervals (milliseconds):
+
+```bash
+socktop --profile prod --metrics-interval-ms 750 --processes-interval-ms 3000 ws://prod-host:3000/ws
+```
+```
+
+If a profile already exists you will be prompted before overwriting:
+
+```
+$ socktop --profile prod ws://new-host:3000/ws
+Overwrite existing profile 'prod'? [y/N]: y
+```
+
+To overwrite without an interactive prompt pass `--save`:
+
+```bash
+socktop --profile prod --save ws://new-host:3000/ws
+```
+
+### Using a saved profile
+
+Just pass the profile name (no URL needed):
+
+```bash
+socktop --profile prod
+socktop -P prod-tls      # short flag
+```
+
+The stored URL (and TLS CA path, if any) plus any saved intervals will be used. TLS auto-upgrade still applies if a CA path is stored alongside a ws:// URL.
+
+### Interactive selection (no args)
+
+If you run `socktop` with no arguments and at least one profile exists, you will be shown a numbered list to pick from:
+
+```
+$ socktop
+Select profile:
+  1. prod
+  2. prod-tls
+Enter number (or blank to abort): 2
+```
+
+Choosing a number starts the TUI with that profile. A built‑in `demo` option is always appended; selecting it launches a local agent on port 3231 (no TLS) and connects to `ws://127.0.0.1:3231/ws`. Pressing Enter on blank aborts without connecting.
+
+### JSON format
+
+An example `profiles.json` (pretty‑printed):
+
+```json
+{
+  "profiles": {
+    "prod": { "url": "ws://prod-host:3000/ws" },
+    "prod-tls": {
+      "url": "wss://prod-host:8443/ws",
+      "tls_ca": "/home/user/certs/prod-cert.pem",
+      "metrics_interval_ms": 500,
+      "processes_interval_ms": 2000
+    }
+  },
+  "version": 0
+}
+```
+
+Notes:
+- The `tls_ca` path is stored as given; if you move or rotate the certificate update the profile by re-running with `--profile NAME --save`.
+- Deleting a profile: edit the JSON file and remove the entry (TUI does not yet have an in-app delete command).
+- Profiles are client-side convenience only; they do not affect the agent.
+- Intervals: `metrics_interval_ms` controls the fast metrics poll (default 500 ms). `processes_interval_ms` controls process list polling (default 2000 ms). Values below 100 ms (metrics) or 200 ms (processes) are clamped.
+
+---
+
+## Updating
+
+Update the agent (systemd):
+
+```bash
+# on the server running the agent
+cargo install socktop_agent --force
+sudo systemctl stop socktop-agent
+sudo install -o root -g root -m 0755 "$HOME/.cargo/bin/socktop_agent" /usr/local/bin/socktop_agent
+# if you changed the unit file:
+# sudo install -o root -g root -m 0644 docs/socktop-agent.service /etc/systemd/system/socktop-agent.service
+# sudo systemctl daemon-reload
+sudo systemctl start socktop-agent
+sudo systemctl status socktop-agent --no-pager
+# logs:
+# journalctl -u socktop-agent -f
+```
+
+Update the TUI (client):
+```bash
+cargo install socktop --force
+socktop ws://HOST:3000/ws
+```
+
+Tip: If only the binary changed, restart is enough. If the unit file changed, run sudo systemctl daemon-reload.
+
+---
+
+## Configuration (agent)
+
+- Port:
+  - Flag: --port 8080 or -p 8080
+  - Positional: socktop_agent 8080
+  - Env: SOCKTOP_PORT=8080
+- TLS (self‑signed):
+  - Enable: --enableSSL
+  - Default TLS port: 8443 (override with --port/-p)
+  - Certificate/Key location (created on first TLS run):
+    - Linux (XDG): $XDG_CONFIG_HOME/socktop_agent/tls/{cert.pem,key.pem} (defaults to ~/.config)
+    - The agent prints these paths on creation.
+  - You can set XDG_CONFIG_HOME before first run to control where certs are written.
+  - Additional SANs: set `SOCKTOP_AGENT_EXTRA_SANS` (comma‑separated) before first TLS start to include extra IPs/DNS names in the cert. Example:
+    ```bash
+    SOCKTOP_AGENT_EXTRA_SANS="192.168.1.101,myhost.internal" socktop_agent --enableSSL
+    ```
+    This prevents client errors like `NotValidForName` when connecting via an IP not present in the default cert SAN list.
+  - Expiry / rotation: the generated cert is valid for ~397 days from creation. If the agent fails to start with an "ExpiredCertificate" error (or your client reports expiry), simply delete the existing cert and key:
+    ```bash
+    rm ~/.config/socktop_agent/tls/cert.pem ~/.config/socktop_agent/tls/key.pem
+    # (adjust path if XDG_CONFIG_HOME is set or different user)
+    systemctl restart socktop-agent   # if running under systemd
+    ```
+    On next TLS start the agent will generate a fresh pair. Only distribute the new cert.pem to clients (never the key).
+- Auth token (optional): SOCKTOP_TOKEN=changeme
+- Disable GPU metrics: SOCKTOP_AGENT_GPU=0
+- Disable CPU temperature: SOCKTOP_AGENT_TEMP=0
+
+---
+
+## Keyboard & Mouse
+
+- Quit: q or Esc
+- Processes pane:
+  - Click “CPU %” to sort by CPU descending
+  - Click “Mem” to sort by memory descending
+  - Mouse wheel: scroll
+  - Drag scrollbar: scroll
+  - Arrow/PageUp/PageDown/Home/End: scroll
+
+---
+
+## Example agent JSON
+
+```json
+{
+  "sampled_at_ms": 1786752000123,
+  "cpu_total": 12.4,
+  "cpu_per_core": [11.2, 15.7],
+  "mem_total": 33554432,
+  "mem_used": 18321408,
+  "swap_total": 0,
+  "swap_used": 0,
+  "process_count": 127,
+  "hostname": "myserver",
+  "cpu_temp_c": 42.5,
+  "disks": [{"name":"nvme0n1p2","total":512000000000,"available":320000000000}],
+  "networks": [{"name":"eth0","received":12345678,"transmitted":87654321}],
+  "top_processes": [
+    {"pid":1234,"name":"nginx","cpu_usage":1.2,"mem_bytes":12345678}
+  ],
+  "gpus": null
+}
+```
+
+Notes:
+- process_count is merged into the main metrics on the client when processes are polled.
+- top_processes are the current top 50 (sorting in the TUI is client-side).
+
+---
+
+## Security
+
+Set a token on the agent and pass it as a query param from the client:
+
+Server:
+
+```bash
+SOCKTOP_TOKEN=changeme socktop_agent --port 3000
+```
+
+Client:
+
+```bash
+socktop "ws://HOST:3000/ws?token=changeme"
+```
+
+### TLS / WSS
+
+For encrypted connections, enable TLS on the agent and pin the server certificate on the client.
+
+Server (generates self‑signed cert and key on first run):
+
+```bash
+socktop_agent --enableSSL --port 8443
+```
+
+Client (trust/pin the server cert; copy cert.pem from the agent):
+
+```bash
+socktop --tls-ca /path/to/agent/cert.pem wss://HOST:8443/ws
+```
+
+Notes:
+- Do not copy the private key off the server; only the cert.pem is needed by clients.
+- When --tls-ca/-t is supplied, the client auto‑upgrades ws:// to wss:// to avoid protocol mismatch.
+- Hostname (SAN) verification is DISABLED by default; instead the client PINS the certificate: the agent must present a cert byte-identical to one in your `--tls-ca` file (expiry is ignored in this mode — you pinned that exact cert). Use `--verify-hostname` to switch to strict chain + SAN validation instead.
+- You can run multiple clients with different cert paths by passing --tls-ca per invocation.
+
+---
+
+## Using tmux to monitor multiple hosts
+
+You can use tmux to show multiple socktop instances in a single terminal.
+
+![socktop screenshot](./docs/tmux_4_rpis_v3.jpg)
+monitoring 4 Raspberry Pis using Tmux
+
+Prerequisites:
+- Install tmux (Ubuntu/Debian: `sudo apt-get install tmux`)
+
+Key bindings (defaults):
+- Split left/right: Ctrl-b %
+- Split top/bottom: Ctrl-b "
+- Move between panes: Ctrl-b + Arrow keys
+- Show pane numbers: Ctrl-b q
+- Close a pane: Ctrl-b x
+- Detach from session: Ctrl-b d
+
+Two panes (left/right)
+- This creates a session named "socktop", splits it horizontally, and starts two socktops.
+
+```bash
+tmux new-session -d -s socktop 'socktop ws://HOST1:3000/ws' \; \
+  split-window -h 'socktop ws://HOST2:3000/ws' \; \
+  select-layout even-horizontal \; \
+  attach
+```
+
+Four panes (top-left, top-right, bottom-left, bottom-right)
+- This creates a 2x2 grid with one socktop per pane.
+
+```bash
+tmux new-session -d -s socktop 'socktop ws://HOST1:3000/ws' \; \
+  split-window -h 'socktop ws://HOST2:3000/ws' \; \
+  select-pane -t 0 \; split-window -v 'socktop ws://HOST3:3000/ws' \; \
+  select-pane -t 1 \; split-window -v 'socktop ws://HOST4:3000/ws' \; \
+  select-layout tiled \; \
+  attach
+```
+
+Tips:
+- Replace HOST1..HOST4 (and ports) with your targets.
+- Reattach later: `tmux attach -t socktop`
+
+---
+
+## Platform notes
+
+- Linux: fully supported (agent and client).
+- Raspberry Pi:
+  - 64-bit: aarch64-unknown-linux-gnu
+  - 32-bit: armv7-unknown-linux-gnueabihf
+- Windows:
+  - TUI + agent can build with stable Rust; bring your own MSVC. You’re on Windows; you know the drill.
+  - CPU temperature may be unavailable.
+  - binary exe for both available in build artifacts under actions.
+- macOS:
+  - TUI works; agent is primarily targeted at Linux. Agent will run just fine on macos for debugging but I have not documented how to run as a service, I may not given the "security" feautures with applications on macos. We will see. 
+
+---
+
+## Development
 
 ```bash
 cargo fmt
@@ -45,11 +557,35 @@ cargo run -p socktop_agent -- --enableSSL --port 8443
 A sample pre-commit hook that runs `cargo fmt --all` is provided in `.githooks/pre-commit`.
 Enable it (one-time):
 
+```bash
+git config core.hooksPath .githooks
+chmod +x .githooks/pre-commit
+```
+
+Every commit will then format Rust sources and restage them automatically.
+
+---
+
+## Roadmap
+
+- [x] Agent authentication (token)
+- [x] Hide per-thread entries; only show processes
+- [x] Sort top processes in the TUI
+- [x] Configurable refresh intervals (client)
+- [ ] Export metrics to file
+- [x] TLS / WSS support (self‑signed server cert + client pinning)
+- [x] Split processes/disks to separate WS calls with independent cadences (already logical on client; formalize API)
+- [ ] Outage notifications and reconnect.
+- [ ] Per process detailed statistics pane
+- [ ] cleanup of Disks section, properly display physical disks / partitions, remove duplicate entries
+
 ---
 
 ## License
 
-MIT — see [LICENSE](LICENSE).
+MIT — see LICENSE.
+
+---
 
 ## Acknowledgements
 

socktop/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "socktop"
-version = "1.60.2"
+version = "1.60.0"
 authors = ["Jason Witty <jasonpwitty+socktop@proton.me>"]
 description = "Remote system monitor over WebSocket, TUI like top"
 edition = "2024"
@@ -11,7 +11,7 @@ repository = "https://github.com/jasonwitty/socktop"
 
 [dependencies]
 # socktop connector for agent communication
-socktop_connector = { version = "1.60.1", path = "../socktop_connector" }
+socktop_connector = { version = "1.60.0", path = "../socktop_connector" }
 
 tokio = { workspace = true }
 futures-util = { workspace = true }
@@ -22,9 +22,6 @@ ratatui = { workspace = true }
 crossterm = { workspace = true }
 unicode-width = { workspace = true }
 anyhow = { workspace = true }
-# Local process signalling only (src/proc_kill.rs). The TUI never gathers its
-# own metrics — everything on screen comes from the agent over the connector.
-sysinfo = { workspace = true }
 dirs-next = { workspace = true }
 
 [dev-dependencies]

socktop/src/app.rs

@@ -20,7 +20,6 @@ use ratatui::{
 use tokio::time::{sleep, timeout};
 
 use crate::history::{PerCoreHistory, push_capped};
-use crate::proc_kill::{KillSignal, kill_local_process};
 use crate::retry::{RetryTiming, compute_retry_timing};
 use crate::types::Metrics;
 use crate::ui::cpu::{
@@ -52,21 +51,6 @@ use socktop_connector::{
 const MIN_METRICS_INTERVAL_MS: u64 = 100;
 const MIN_PROCESSES_INTERVAL_MS: u64 = 200;
 
-/// Floor for the post-kill forced refresh delay: just past the agent's
-/// DEFAULT `Processes` cache TTL of 1500ms, so the answer reflects the kill
-/// instead of the cached snapshot taken before it. The effective delay scales
-/// with the user's processes interval — see [`App::proc_refresh_settle`].
-const PROC_CACHE_SETTLE_FLOOR: Duration = Duration::from_millis(1_600);
-
-/// Margin a tombstone outlives the settle window by. With default intervals
-/// this reproduces the original fixed 5s tombstone (1.6s + 3.4s).
-const TOMBSTONE_MARGIN: Duration = Duration::from_millis(3_400);
-
-/// How long to keep re-checking a signalled process for its exit. Long enough
-/// to cover a slow shutdown, short enough that a process which plainly ignored
-/// the signal keeps its row.
-const KILL_WATCH_FOR: Duration = Duration::from_secs(5);
-
 /// Budget for one request/response round trip. Replies are matched to
 /// requests by order, so a request that never answers would otherwise hang
 /// `ws.next()` forever and freeze the TUI (raw mode even eats Ctrl+C).
@@ -152,15 +136,6 @@ pub struct App {
     procs_row_peak_cpu: f32,
 
     last_procs_poll: Instant,
-    /// When set, the next metrics tick polls processes regardless of the
-    /// regular cadence. Used after a kill — see refresh_after_kill.
-    procs_refresh_due_at: Option<Instant>,
-    /// PIDs we have signalled, with the instant we stop watching for their
-    /// exit. Re-checked each metrics tick — see poll_kill_watch.
-    kill_watch: Vec<(u32, Instant)>,
-    /// PIDs confirmed gone after a signal, kept briefly so the agent's cached
-    /// process list cannot put them back on screen.
-    killed_gone: Vec<(u32, Instant)>,
     last_disks_poll: Instant,
     procs_interval: Duration,
     disks_interval: Duration,
@@ -178,10 +153,6 @@ pub struct App {
     last_io_write_bytes: Option<u64>,            // Previous write bytes for delta calculation
     pub max_process_mem_bytes: u64, // Maximum memory usage observed for current process
     pub process_details_unsupported: bool, // Track if agent doesn't support process details
-    /// The agent has successfully answered at least one details request this
-    /// session. Distinguishes "this agent is too old" from "that process is
-    /// gone", which arrive over the wire as the same error.
-    process_details_answered: bool,
     last_process_details_poll: Instant,
     last_journal_poll: Instant,
     process_details_interval: Duration,
@@ -194,14 +165,6 @@ pub struct App {
     // Security / status flags
     pub is_tls: bool,
     pub has_token: bool,
-    // Whether the local process-kill feature (t = SIGTERM, k = SIGKILL) is
-    // available: the connected agent is on this machine AND no policy override
-    // (--no-kill / SOCKTOP_NO_KILL) has disabled it.
-    pub kill_enabled: bool,
-    // Pending kill awaiting confirmation: (pid, process name). Which signal is
-    // sent depends on the button chosen in the confirmation modal, so it isn't
-    // decided until then.
-    pending_kill: Option<(u32, String)>,
 
     // --compact: pin the compact layout regardless of window size. Without it the
     // layout switches on its own once the window is too short for the Disks pane.
@@ -259,9 +222,6 @@ impl App {
             procs_filter_dirty: true,
             procs_row_cache: Vec::new(),
             procs_row_peak_cpu: 0.0,
-            procs_refresh_due_at: None,
-            kill_watch: Vec::new(),
-            killed_gone: Vec::new(),
             last_procs_poll: Instant::now()
                 .checked_sub(Duration::from_secs(2))
                 .unwrap_or_else(Instant::now), // trigger immediately on first loop
@@ -282,7 +242,6 @@ impl App {
             last_io_write_bytes: None,
             max_process_mem_bytes: 0,
             process_details_unsupported: false,
-            process_details_answered: false,
             last_process_details_poll: Instant::now()
                 .checked_sub(Duration::from_secs(10))
                 .unwrap_or_else(Instant::now),
@@ -296,8 +255,6 @@ impl App {
             verify_hostname: false,
             is_tls: false,
             has_token: false,
-            kill_enabled: false,
-            pending_kill: None,
             force_compact: false,
             header_title: String::new(),
             header_intervals_text: String::new(),
@@ -349,233 +306,6 @@ impl App {
         self
     }
 
-    /// Enable the local process-kill feature. Only set true when the agent has
-    /// been verified to be on this machine (see [`crate::local`]) and no
-    /// policy override (`--no-kill`, `SOCKTOP_NO_KILL`) forbids it.
-    pub fn with_kill_enabled(mut self, kill_enabled: bool) -> Self {
-        self.kill_enabled = kill_enabled;
-        self
-    }
-
-    /// Look up the display name of a process by PID. Prefers the details
-    /// payload, which is the only source that has a name for a process not in
-    /// the top-N list — e.g. after walking up to a parent from the details
-    /// modal.
-    fn process_name_for_pid(&self, pid: u32) -> Option<String> {
-        if let Some(details) = self
-            .process_details
-            .as_ref()
-            .filter(|d| d.process.pid == pid)
-        {
-            return Some(details.process.name.clone());
-        }
-        self.last_metrics
-            .as_ref()?
-            .top_processes
-            .iter()
-            .find(|p| p.pid == pid)
-            .map(|p| p.name.clone())
-    }
-
-    /// Raise the kill confirmation for `pid`. No-op unless the kill feature is
-    /// enabled — the same gate the keybinding uses, repeated here because this
-    /// is also reachable from the details modal.
-    fn prompt_kill(&mut self, pid: u32) {
-        if !self.kill_enabled {
-            return;
-        }
-        let name = self
-            .process_name_for_pid(pid)
-            .unwrap_or_else(|| "process".to_string());
-        self.modal_manager.push_modal(ModalType::Confirmation {
-            title: "Confirm signal".to_string(),
-            message: format!("Send a signal to {name} (PID {pid})?"),
-            confirm_text: "Terminate".to_string(),
-            cancel_text: "Cancel".to_string(),
-        });
-        self.pending_kill = Some((pid, name));
-    }
-
-    /// Signal the process the confirmation was raised for, then report the
-    /// outcome. Pops the confirmation first so the result lands on top of
-    /// whatever was underneath it (the process list, or the details modal).
-    fn run_pending_kill(&mut self, signal: KillSignal) {
-        let Some((pid, name)) = self.pending_kill.take() else {
-            return;
-        };
-        self.modal_manager.pop_modal();
-        // The name shown in the confirmation doubles as the reuse guard: if
-        // the PID has been recycled since, the kill is refused. The "process"
-        // fallback from prompt_kill means "name unknown" — no guard possible.
-        let expected = (name != "process").then_some(name.as_str());
-        let (title, message) = match kill_local_process(pid, expected, signal) {
-            Ok(()) => {
-                self.refresh_after_kill(pid);
-                (
-                    "Signal sent".to_string(),
-                    format!("Sent {} to {name} (PID {pid}).", signal.label()),
-                )
-            }
-            Err(e) => ("Signal failed".to_string(), e),
-        };
-        self.modal_manager
-            .push_modal(ModalType::Info { title, message });
-    }
-
-    /// Bring the process list back in step with reality after a signal.
-    ///
-    /// A single check at signal time is not enough, which is what the first
-    /// version got wrong: SIGTERM is a *request*, so the process is usually
-    /// still alive for the few hundred milliseconds it takes to wind down. The
-    /// row therefore stayed put, and the list looked like the kill had done
-    /// nothing.
-    ///
-    /// So the PID goes on a watch list, re-checked every metrics tick until it
-    /// exits (or the watch expires). Confirmed-gone PIDs are also remembered
-    /// briefly — see `killed_gone` — because the agent serves `Processes` from
-    /// a 1500ms cache and would otherwise hand back a snapshot taken before
-    /// the kill and put the row straight back.
-    fn refresh_after_kill(&mut self, pid: u32) {
-        self.kill_watch.retain(|(p, _)| *p != pid);
-        self.kill_watch.push((pid, Instant::now() + KILL_WATCH_FOR));
-        // Check once right now: SIGKILL, and anything already exiting, is gone
-        // by the time the confirmation is dismissed.
-        self.poll_kill_watch();
-        self.procs_refresh_due_at = Some(Instant::now() + self.proc_refresh_settle());
-    }
-
-    /// How long the post-kill forced refresh waits, and the base of the
-    /// tombstone lifetime. Scales with the user's processes interval: someone
-    /// who raised the agent's Processes TTL will have raised their client
-    /// interval to match (there is no point polling faster than the cache),
-    /// so the interval is the best client-side signal for how stale an agent
-    /// snapshot can be. Never below the default-TTL floor.
-    fn proc_refresh_settle(&self) -> Duration {
-        PROC_CACHE_SETTLE_FLOOR.max(self.procs_interval)
-    }
-
-    /// How long a confirmed-dead PID is remembered, so a cached agent snapshot
-    /// taken before the kill cannot resurrect its row. Must outlive the settle
-    /// window plus one round trip, hence settle + margin.
-    fn kill_tombstone_for(&self) -> Duration {
-        self.proc_refresh_settle() + TOMBSTONE_MARGIN
-    }
-
-    /// Re-check the processes we have signalled and retire the rows of any that
-    /// have since exited. Cheap: one `/proc` lookup per watched PID, and the
-    /// list is almost always empty.
-    fn poll_kill_watch(&mut self) {
-        if self.kill_watch.is_empty() {
-            return;
-        }
-        let now = Instant::now();
-        let mut gone = Vec::new();
-        self.kill_watch.retain(|(pid, deadline)| {
-            if !crate::proc_kill::process_exists(*pid) {
-                gone.push(*pid);
-                return false;
-            }
-            // Still alive. Keep watching until the deadline — a process that
-            // ignores the signal outright should keep its row.
-            now < *deadline
-        });
-        for pid in gone {
-            self.forget_process_row(pid);
-            // Nothing left to show details for. Also matters mechanically: the
-            // details poll keys off the selection, which forget_process_row
-            // just cleared, so leaving the modal open would freeze it on the
-            // dead process's last sample.
-            self.close_details_for_gone_process(pid);
-            self.killed_gone.push((pid, now));
-        }
-        let tombstone_for = self.kill_tombstone_for();
-        self.killed_gone
-            .retain(|(_, at)| now.duration_since(*at) < tombstone_for);
-    }
-
-    /// Drop rows for processes we have confirmed dead. Applied to every process
-    /// list the agent sends, because its cached snapshot can predate the kill.
-    fn drop_tombstoned_rows(&mut self) {
-        if self.killed_gone.is_empty() {
-            return;
-        }
-        let now = Instant::now();
-        let tombstone_for = self.kill_tombstone_for();
-        self.killed_gone
-            .retain(|(_, at)| now.duration_since(*at) < tombstone_for);
-        let pids: Vec<u32> = self.killed_gone.iter().map(|(p, _)| *p).collect();
-        for pid in pids {
-            self.forget_process_row(pid);
-        }
-    }
-
-    /// Give up a selection whose process is no longer in the list. `Processes`
-    /// carries every process, not a top-N window, so a PID that is absent has
-    /// genuinely gone — and a selection pointing at it means the hint offers to
-    /// kill a corpse and `t` reports "no longer exists".
-    fn drop_vanished_selection(&mut self) {
-        let Some(pid) = self.selected_process_pid else {
-            return;
-        };
-        let present = self
-            .last_metrics
-            .as_ref()
-            .is_some_and(|m| m.top_processes.iter().any(|p| p.pid == pid));
-        if !present {
-            self.selected_process_pid = None;
-            self.selected_process_index = None;
-        }
-    }
-
-    /// Close the details view for a process that no longer exists, and drop the
-    /// data collected for it.
-    ///
-    /// A parent-navigation chain can leave another details view underneath
-    /// (child → P → parent killed): the resurfacing view must resume polling,
-    /// so retarget the selection to it — the same thing SwitchToParentProcess
-    /// does on the way down. Without this the child view came back with no
-    /// selection (forget_process_row had just cleared it) and wiped data, and
-    /// the selection-gated details poll never refilled it: a frozen, orphaned
-    /// window.
-    fn close_details_for_gone_process(&mut self, pid: u32) {
-        if self.modal_manager.close_process_details(pid) {
-            self.clear_process_details();
-            if let Some(next_pid) = self.modal_manager.topmost_process_details() {
-                self.selected_process_pid = Some(next_pid);
-                // Fire the details poll on the next tick rather than waiting
-                // out the interval.
-                self.last_process_details_poll = Instant::now()
-                    .checked_sub(self.process_details_interval)
-                    .unwrap_or_else(Instant::now);
-            }
-        }
-    }
-
-    /// Drop a process from the cached view without waiting for the agent, and
-    /// give up any selection pointing at it — a hint offering to kill a process
-    /// that no longer exists is worse than no hint.
-    fn forget_process_row(&mut self, pid: u32) {
-        let Some(m) = self.last_metrics.as_mut() else {
-            return;
-        };
-        let before = m.top_processes.len();
-        m.top_processes.retain(|p| p.pid != pid);
-        if m.top_processes.len() == before {
-            return; // wasn't on screen; nothing to reconcile
-        }
-        // Keep the header's "(N total)" honest until the next real poll.
-        m.process_count = m.process_count.map(|c| c.saturating_sub(1));
-        if self.selected_process_pid == Some(pid) {
-            self.selected_process_pid = None;
-            self.selected_process_index = None;
-        }
-        self.invalidate_procs_filter();
-        if let Some(mm) = self.last_metrics.as_ref() {
-            self.procs_row_peak_cpu =
-                crate::ui::processes::rebuild_row_cache(mm, &mut self.procs_row_cache);
-        }
-    }
-
     /// Show a connection error modal
     pub fn show_connection_error(&mut self, message: String) {
         if !self.modal_manager.is_active() {
@@ -1027,47 +757,18 @@ impl App {
                                 continue; // Skip normal key processing
                             }
                             ModalAction::Cancel | ModalAction::Dismiss => {
-                                // If a ProcessDetails view is what we landed on,
-                                // clear the stale data AND point the poll at it —
-                                // Esc-ing back from a parent view otherwise left
-                                // the selection on the parent, refilling the
-                                // child-titled view with the parent's data.
-                                if let Some(crate::ui::modal::ModalType::ProcessDetails { pid }) =
-                                    self.modal_manager.current_modal()
+                                // If ProcessDetails modal was dismissed, clear the data to save resources
+                                if let Some(crate::ui::modal::ModalType::ProcessDetails {
+                                    ..
+                                }) = self.modal_manager.current_modal()
                                 {
-                                    let pid = *pid;
                                     self.clear_process_details();
-                                    self.selected_process_pid = Some(pid);
-                                    self.last_process_details_poll = Instant::now()
-                                        .checked_sub(self.process_details_interval)
-                                        .unwrap_or_else(Instant::now);
                                 }
-                                // Abandon any pending kill the user backed out of.
-                                self.pending_kill = None;
                                 // Modal was dismissed, skip normal key processing
                                 continue;
                             }
                             ModalAction::Confirm => {
-                                // The only confirmation in the app is the
-                                // process-kill prompt; Confirm is the polite
-                                // signal, ConfirmForce the forceful one.
-                                if self.pending_kill.is_some() {
-                                    self.run_pending_kill(KillSignal::Term);
-                                    continue;
-                                }
-                            }
-                            ModalAction::ConfirmForce => {
-                                if self.pending_kill.is_some() {
-                                    self.run_pending_kill(KillSignal::Kill);
-                                    continue;
-                                }
-                            }
-                            ModalAction::KillSelected(pid) => {
-                                // `t` from inside the details modal. The
-                                // confirmation stacks on top of it, so
-                                // cancelling returns to the details view.
-                                self.prompt_kill(pid);
-                                continue;
+                                // Handle confirmation action here if needed in the future
                             }
                             ModalAction::SwitchToParentProcess(_current_pid) => {
                                 // Get parent PID from current process details
@@ -1179,20 +880,6 @@ impl App {
                         self.modal_manager.push_modal(ModalType::Help);
                     }
 
-                    // Kill the selected process — local agents only. `t` is the
-                    // one kill key everywhere: `k` scrolls the thread table in
-                    // the details modal so it could not be reused there, and one
-                    // key for both entry points is one thing to remember.
-                    // SIGTERM vs SIGKILL is chosen in the confirmation modal.
-                    if self.kill_enabled
-                        && !self.modal_manager.is_active()
-                        && matches!(k.code, KeyCode::Char('t') | KeyCode::Char('T'))
-                        && let Some(pid) = self.selected_process_pid
-                    {
-                        self.prompt_kill(pid);
-                        continue;
-                    }
-
                     // Per-core scroll via keys (Up/Down/PageUp/PageDown/Home/End)
                     let sz = terminal.size()?;
                     let area = Rect::new(0, 0, sz.width, sz.height);
@@ -1430,21 +1117,8 @@ impl App {
                         self.consecutive_request_timeouts = 0;
                         self.update_with_metrics(m);
 
-                        // A process signalled a moment ago may have exited
-                        // since. Checked here, on every tick, so its row goes
-                        // as soon as it is actually gone rather than at the
-                        // next full process poll.
-                        self.poll_kill_watch();
-
-                        // Only poll processes every 2s — unless a kill asked for
-                        // a refresh, which jumps the queue.
-                        let forced = self
-                            .procs_refresh_due_at
-                            .is_some_and(|due| Instant::now() >= due);
-                        if forced || self.last_procs_poll.elapsed() >= self.procs_interval {
-                            if forced {
-                                self.procs_refresh_due_at = None;
-                            }
+                        // Only poll processes every 2s
+                        if self.last_procs_poll.elapsed() >= self.procs_interval {
                             let mut updated = false;
                             match timeout(REQUEST_TIMEOUT, ws.request(AgentRequest::Processes))
                                 .await
@@ -1474,14 +1148,6 @@ impl App {
                                             &mut self.procs_row_cache,
                                         );
                                 }
-                                // The agent's snapshot can predate a kill by up
-                                // to its cache TTL, so strip anything we already
-                                // know is gone before it reaches the screen.
-                                self.drop_tombstoned_rows();
-                                // And a selection whose process is no longer in
-                                // the list would otherwise still be the target
-                                // of `t`.
-                                self.drop_vanished_selection();
                             }
                             self.last_procs_poll = Instant::now();
                         }
@@ -1586,44 +1252,11 @@ impl App {
 
                                             self.process_details = Some(details);
                                             self.process_details_unsupported = false;
-                                            // This agent demonstrably answers
-                                            // details requests, which is what
-                                            // lets the error arm below read a
-                                            // later failure as "that process is
-                                            // gone" rather than "old agent".
-                                            self.process_details_answered = true;
                                         }
                                         Ok(Err(_)) => {
-                                            // An error reply means one of two very
-                                            // different things, and the wire cannot
-                                            // tell them apart: the agent lacks the
-                                            // endpoint, or this PID is gone (the
-                                            // agent sends {"error":"Process N not
-                                            // found"}, which fails to deserialize
-                                            // and arrives here identically).
-                                            //
-                                            // If the agent has already answered a
-                                            // details request this session, the
-                                            // endpoint plainly works, so the PID is
-                                            // the problem — close the view instead
-                                            // of claiming the agent needs updating.
-                                            //
-                                            // Unless the process is still in the
-                                            // agent's own list: then this error is a
-                                            // transient (socket blip, torn frame),
-                                            // not a death — keep the view and let
-                                            // the next poll retry.
-                                            if self.process_details_answered {
-                                                let still_listed =
-                                                    self.last_metrics.as_ref().is_some_and(|m| {
-                                                        m.top_processes.iter().any(|p| p.pid == pid)
-                                                    });
-                                                if !still_listed {
-                                                    self.close_details_for_gone_process(pid);
-                                                }
-                                            } else {
-                                                self.process_details_unsupported = true;
-                                            }
+                                            // Agent responded with an error: endpoint
+                                            // not supported.
+                                            self.process_details_unsupported = true;
                                         }
                                         Err(_) => {
                                             // No reply at all: old agents IGNORE
@@ -1950,7 +1583,6 @@ impl App {
                 filtered_indices: &self.procs_filtered,
                 cached_rows: &self.procs_row_cache,
                 peak_cpu: self.procs_row_peak_cpu,
-                kill_enabled: self.kill_enabled,
             },
         );
 
@@ -1971,7 +1603,6 @@ impl App {
                     },
                     max_mem_bytes: self.max_process_mem_bytes,
                     unsupported: self.process_details_unsupported,
-                    kill_enabled: self.kill_enabled,
                 },
             );
         }
@@ -1983,418 +1614,3 @@ impl Default for App {
         Self::new()
     }
 }
-
-#[cfg(test)]
-mod kill_refresh_tests {
-    use super::*;
-    use socktop_connector::{Metrics, ProcessInfo};
-
-    fn proc(pid: u32, name: &str) -> ProcessInfo {
-        ProcessInfo {
-            pid,
-            name: name.into(),
-            cpu_usage: 1.0,
-            mem_bytes: 1_000,
-        }
-    }
-
-    fn app_with(pids: &[u32]) -> App {
-        let mut app = App::new();
-        app.last_metrics = Some(Metrics {
-            sampled_at_ms: None,
-            cpu_total: 0.0,
-            cpu_per_core: vec![],
-            mem_total: 1_000_000,
-            mem_used: 0,
-            swap_total: 0,
-            swap_used: 0,
-            hostname: "t".into(),
-            cpu_temp_c: None,
-            disks: vec![],
-            networks: vec![],
-            top_processes: pids.iter().map(|p| proc(*p, "victim")).collect(),
-            gpus: None,
-            process_count: Some(pids.len()),
-        });
-        app
-    }
-
-    #[test]
-    fn dropping_a_row_updates_the_list_count_and_selection() {
-        let mut app = app_with(&[1, 2, 3]);
-        app.selected_process_pid = Some(2);
-        app.selected_process_index = Some(1);
-
-        app.forget_process_row(2);
-
-        let m = app.last_metrics.as_ref().unwrap();
-        assert_eq!(
-            m.top_processes.iter().map(|p| p.pid).collect::<Vec<_>>(),
-            vec![1, 3]
-        );
-        assert_eq!(m.process_count, Some(2), "header count went stale");
-        assert_eq!(
-            app.selected_process_pid, None,
-            "selection still points at a dead process"
-        );
-        assert_eq!(app.selected_process_index, None);
-    }
-
-    /// A process that was never on screen (outside the top-N) must not decrement
-    /// the total or disturb the selection.
-    #[test]
-    fn dropping_an_offscreen_row_changes_nothing() {
-        let mut app = app_with(&[1, 2, 3]);
-        app.selected_process_pid = Some(1);
-        app.forget_process_row(999);
-        let m = app.last_metrics.as_ref().unwrap();
-        assert_eq!(m.top_processes.len(), 3);
-        assert_eq!(m.process_count, Some(3));
-        assert_eq!(app.selected_process_pid, Some(1));
-    }
-
-    /// A dead process disappears immediately, and a refresh is still scheduled
-    /// so the agent's own view catches up past its cache TTL.
-    #[test]
-    fn a_confirmed_dead_process_leaves_at_once() {
-        let mut child = std::process::Command::new("true").spawn().expect("spawn");
-        let pid = child.id();
-        child.wait().expect("reap");
-
-        let mut app = app_with(&[pid, 4242]);
-        app.refresh_after_kill(pid);
-
-        let m = app.last_metrics.as_ref().unwrap();
-        assert_eq!(
-            m.top_processes.iter().map(|p| p.pid).collect::<Vec<_>>(),
-            vec![4242],
-            "a process known to be gone should not still be listed"
-        );
-        assert!(app.procs_refresh_due_at.is_some(), "no refresh scheduled");
-    }
-
-    /// A process that survived the signal keeps its row — better a row that is
-    /// still true than one that vanishes and comes back.
-    #[test]
-    fn a_surviving_process_keeps_its_row_until_the_refresh() {
-        let mut child = std::process::Command::new("sleep")
-            .arg("30")
-            .spawn()
-            .expect("spawn");
-        let pid = child.id();
-
-        let mut app = app_with(&[pid]);
-        app.refresh_after_kill(pid);
-        let listed = app
-            .last_metrics
-            .as_ref()
-            .unwrap()
-            .top_processes
-            .iter()
-            .any(|p| p.pid == pid);
-
-        let _ = child.kill();
-        let _ = child.wait();
-
-        assert!(listed, "row for a live process was removed optimistically");
-        assert!(app.procs_refresh_due_at.is_some());
-    }
-
-    /// The scheduled refresh must land after the agent's process cache TTL,
-    /// or it just re-reads the pre-kill snapshot.
-    #[test]
-    fn the_forced_refresh_waits_out_the_agent_cache() {
-        assert!(
-            PROC_CACHE_SETTLE_FLOOR >= Duration::from_millis(1_500),
-            "agent serves Processes from a 1500ms cache by default"
-        );
-    }
-
-    /// Users who raise the agent's Processes TTL raise the client interval to
-    /// match, so the settle window (and the tombstone that must outlive it)
-    /// scales with the interval instead of assuming the default TTL.
-    #[test]
-    fn settle_and_tombstone_scale_with_the_processes_interval() {
-        // The default processes interval is 2s, which already exceeds the
-        // 1.6s floor — so the default settle is the interval itself.
-        let mut app = App::new();
-        assert_eq!(app.proc_refresh_settle(), Duration::from_secs(2));
-
-        app = app.with_intervals(None, Some(10_000));
-        assert_eq!(app.proc_refresh_settle(), Duration::from_secs(10));
-        assert!(app.kill_tombstone_for() > app.proc_refresh_settle());
-
-        // A tiny interval never drops the settle below the default-TTL floor.
-        app = app.with_intervals(None, Some(200));
-        assert_eq!(app.proc_refresh_settle(), PROC_CACHE_SETTLE_FLOOR);
-    }
-}
-
-#[cfg(test)]
-mod parent_chain_tests {
-    use super::*;
-    use crate::ui::modal::ModalType;
-
-    /// Kill a parent reached via P-navigation: the child's view resurfaces and
-    /// must resume polling. Reported as: "I can still see the orphaned window
-    /// if I open a process, hit P, then terminate that process with t".
-    #[test]
-    fn killing_a_navigated_to_parent_retargets_the_child_view() {
-        let mut app = App::new();
-        let (child, parent) = (200u32, 100u32);
-        app.modal_manager
-            .push_modal(ModalType::ProcessDetails { pid: child });
-        app.modal_manager
-            .push_modal(ModalType::ProcessDetails { pid: parent });
-        // The kill flow stacks the "Signal sent" Info on top, and the watch
-        // usually confirms the death while it is still up.
-        app.modal_manager.push_modal(ModalType::Info {
-            title: "Signal sent".into(),
-            message: "Sent SIGTERM".into(),
-        });
-        // forget_process_row has already cleared the selection by this point.
-        app.selected_process_pid = None;
-
-        app.close_details_for_gone_process(parent);
-
-        assert_eq!(
-            app.selected_process_pid,
-            Some(child),
-            "resurfaced child view has no selection: its poll never runs and \
-             the window sits frozen"
-        );
-        assert_eq!(app.modal_manager.topmost_process_details(), Some(child));
-        assert!(
-            app.last_process_details_poll.elapsed() >= app.process_details_interval,
-            "poll should be due immediately"
-        );
-    }
-}
-
-#[cfg(test)]
-mod details_close_tests {
-    use super::*;
-    use crate::ui::modal::ModalType;
-    use socktop_connector::{Metrics, ProcessInfo};
-
-    fn app_viewing(pid: u32) -> App {
-        let mut app = App::new();
-        app.last_metrics = Some(Metrics {
-            sampled_at_ms: None,
-            cpu_total: 0.0,
-            cpu_per_core: vec![],
-            mem_total: 1_000_000,
-            mem_used: 0,
-            swap_total: 0,
-            swap_used: 0,
-            hostname: "t".into(),
-            cpu_temp_c: None,
-            disks: vec![],
-            networks: vec![],
-            top_processes: vec![ProcessInfo {
-                pid,
-                name: "victim".into(),
-                cpu_usage: 1.0,
-                mem_bytes: 1_000,
-            }],
-            gpus: None,
-            process_count: Some(1),
-        });
-        app.selected_process_pid = Some(pid);
-        app.selected_process_index = Some(0);
-        app.modal_manager
-            .push_modal(ModalType::ProcessDetails { pid });
-        app.max_process_mem_bytes = 12_345; // stand-in for collected history
-        app
-    }
-
-    /// Killing the process you are looking at should not leave you staring at
-    /// its details — especially since the details poll keys off the selection,
-    /// which is cleared at the same time.
-    #[test]
-    fn killing_the_viewed_process_closes_its_details() {
-        let mut child = std::process::Command::new("true").spawn().expect("spawn");
-        let pid = child.id();
-        child.wait().expect("reap");
-
-        let mut app = app_viewing(pid);
-        app.refresh_after_kill(pid);
-
-        assert!(
-            !app.modal_manager.is_active(),
-            "details modal stayed open for a dead process"
-        );
-        assert_eq!(
-            app.max_process_mem_bytes, 0,
-            "details state was not cleared"
-        );
-        assert!(app.last_metrics.as_ref().unwrap().top_processes.is_empty());
-    }
-
-    /// A process that survived the signal keeps both its row and its details.
-    #[test]
-    fn a_surviving_process_keeps_its_details_open() {
-        let mut child = std::process::Command::new("sleep")
-            .arg("30")
-            .spawn()
-            .expect("spawn");
-        let pid = child.id();
-
-        let mut app = app_viewing(pid);
-        app.refresh_after_kill(pid);
-        let still_open = app.modal_manager.is_active();
-
-        let _ = child.kill();
-        let _ = child.wait();
-
-        assert!(still_open, "closed the details of a process still running");
-    }
-}
-
-#[cfg(test)]
-mod kill_watch_tests {
-    use super::*;
-    use socktop_connector::{Metrics, ProcessInfo};
-
-    fn metrics_with(pids: &[(u32, &str)]) -> Metrics {
-        Metrics {
-            sampled_at_ms: None,
-            cpu_total: 0.0,
-            cpu_per_core: vec![],
-            mem_total: 1_000_000,
-            mem_used: 0,
-            swap_total: 0,
-            swap_used: 0,
-            hostname: "t".into(),
-            cpu_temp_c: None,
-            disks: vec![],
-            networks: vec![],
-            top_processes: pids
-                .iter()
-                .map(|(pid, name)| ProcessInfo {
-                    pid: *pid,
-                    name: (*name).into(),
-                    cpu_usage: 1.0,
-                    mem_bytes: 1_000,
-                })
-                .collect(),
-            gpus: None,
-            process_count: Some(pids.len()),
-        }
-    }
-
-    fn listed(app: &App, pid: u32) -> bool {
-        app.last_metrics
-            .as_ref()
-            .is_some_and(|m| m.top_processes.iter().any(|p| p.pid == pid))
-    }
-
-    /// The reported bug: SIGTERM is a request, so the process is normally still
-    /// alive at signal time. The row must go when it actually exits, not stay
-    /// until the next full poll.
-    #[test]
-    fn a_row_goes_as_soon_as_the_process_actually_exits() {
-        let mut child = std::process::Command::new("sleep")
-            .arg("30")
-            .spawn()
-            .expect("spawn");
-        let pid = child.id();
-
-        let mut app = App::new();
-        app.last_metrics = Some(metrics_with(&[(pid, "sleep"), (1, "init")]));
-        app.selected_process_pid = Some(pid);
-
-        // Signalled, but it has not exited yet: the row stays.
-        app.refresh_after_kill(pid);
-        assert!(
-            listed(&app, pid),
-            "row vanished while the process was alive"
-        );
-
-        // It exits (as a SIGTERM'd process does, a moment later).
-        let _ = child.kill();
-        let _ = child.wait();
-
-        // The next tick notices.
-        app.poll_kill_watch();
-        assert!(!listed(&app, pid), "row survived the process exiting");
-        assert_eq!(app.selected_process_pid, None, "selection left on a corpse");
-    }
-
-    /// Also reported: after terminating, the row came back. The agent serves
-    /// `Processes` from a 1500ms cache, so its next answer can predate the kill.
-    #[test]
-    fn a_stale_agent_snapshot_cannot_resurrect_a_killed_process() {
-        let mut child = std::process::Command::new("true").spawn().expect("spawn");
-        let pid = child.id();
-        child.wait().expect("reap");
-
-        let mut app = App::new();
-        app.last_metrics = Some(metrics_with(&[(pid, "true"), (1, "init")]));
-        app.refresh_after_kill(pid);
-        assert!(!listed(&app, pid), "confirmed-dead row should be gone");
-
-        // The agent answers with a snapshot taken before the kill.
-        app.last_metrics = Some(metrics_with(&[(pid, "true"), (1, "init")]));
-        app.drop_tombstoned_rows();
-        assert!(!listed(&app, pid), "stale snapshot put the row back");
-        assert!(listed(&app, 1), "unrelated processes must survive");
-    }
-
-    /// His exact path: find the process with `/`, then kill it. The filtered
-    /// view is derived from the same list, so it must lose the row too.
-    #[test]
-    fn a_search_filtered_view_loses_the_row_as_well() {
-        let mut child = std::process::Command::new("true").spawn().expect("spawn");
-        let pid = child.id();
-        child.wait().expect("reap");
-
-        let mut app = App::new();
-        app.last_metrics = Some(metrics_with(&[(pid, "victim"), (1, "init")]));
-        app.process_search_query = "victim".into();
-        assert_eq!(
-            app.procs_filter().len(),
-            1,
-            "search should match the victim"
-        );
-
-        app.refresh_after_kill(pid);
-
-        assert!(
-            app.procs_filter().is_empty(),
-            "killed process still present in the filtered list"
-        );
-    }
-
-    #[test]
-    fn a_selection_that_leaves_the_list_is_dropped() {
-        let mut app = App::new();
-        app.last_metrics = Some(metrics_with(&[(1, "init")]));
-        app.selected_process_pid = Some(4242);
-        app.selected_process_index = Some(7);
-        app.drop_vanished_selection();
-        assert_eq!(app.selected_process_pid, None);
-        assert_eq!(app.selected_process_index, None);
-    }
-
-    #[test]
-    fn a_selection_still_in_the_list_is_kept() {
-        let mut app = App::new();
-        app.last_metrics = Some(metrics_with(&[(1, "init")]));
-        app.selected_process_pid = Some(1);
-        app.drop_vanished_selection();
-        assert_eq!(app.selected_process_pid, Some(1));
-    }
-
-    /// A process that ignores the signal must not be watched forever.
-    #[test]
-    fn the_watch_expires() {
-        let mut app = App::new();
-        app.last_metrics = Some(metrics_with(&[(1, "init")]));
-        // Already-expired deadline, for a PID that certainly exists (ourselves).
-        let me = std::process::id();
-        app.kill_watch.push((me, Instant::now()));
-        app.poll_kill_watch();
-        assert!(app.kill_watch.is_empty(), "expired watch was not dropped");
-    }
-}

socktop/src/local.rs

@@ -1,85 +0,0 @@
-//! Detection of whether the connected agent is running on this same machine.
-//!
-//! Process-kill is only offered for *local* agents. The reasoning is a
-//! security one: the PIDs shown in the UI are reported by the agent, and when
-//! the user asks to kill one, socktop sends the signal with its OWN local OS
-//! privileges (a direct syscall — never over the network; see [`crate::proc_kill`]).
-//! A PID is therefore only meaningful — and only safe to act on — when the
-//! agent lives on this machine. If we acted on a remote agent's PIDs we would
-//! be signalling whatever unrelated *local* process happened to share that
-//! number.
-//!
-//! An address is considered local when it is loopback, or when we can bind an
-//! ephemeral socket to it: a bind only succeeds for an address assigned to one
-//! of this host's own network interfaces, so it also covers the case of an
-//! agent reached over this machine's LAN IP. Detection fails closed — any
-//! parse/resolution failure, or any resolved address that is not local,
-//! disables the feature.
-
-use std::net::{IpAddr, ToSocketAddrs, UdpSocket};
-
-/// Returns true only if the agent reached at `ws_url` is on this machine.
-pub fn agent_is_local(ws_url: &str) -> bool {
-    let Ok(parsed) = url::Url::parse(ws_url) else {
-        return false;
-    };
-    match parsed.host() {
-        // IP literals can be checked directly without any name resolution.
-        Some(url::Host::Ipv4(ip)) => ip_is_local(IpAddr::V4(ip)),
-        Some(url::Host::Ipv6(ip)) => ip_is_local(IpAddr::V6(ip)),
-        // A hostname (e.g. "localhost", or a LAN name) must resolve, and every
-        // address it resolves to must be local. ws=80, wss=443 are the known
-        // default ports; an explicit port in the URL is honored.
-        Some(url::Host::Domain(domain)) => {
-            let port = parsed.port_or_known_default().unwrap_or(0);
-            match (domain, port).to_socket_addrs() {
-                Ok(addrs) => {
-                    let mut saw_any = false;
-                    for addr in addrs {
-                        saw_any = true;
-                        if !ip_is_local(addr.ip()) {
-                            return false;
-                        }
-                    }
-                    saw_any
-                }
-                Err(_) => false,
-            }
-        }
-        None => false,
-    }
-}
-
-/// An address is local if it is loopback, or if we can bind an ephemeral
-/// socket to it (only possible for an address on one of our own interfaces).
-/// Port 0 requests an ephemeral port and sends no traffic.
-fn ip_is_local(ip: IpAddr) -> bool {
-    ip.is_loopback() || UdpSocket::bind((ip, 0)).is_ok()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::agent_is_local;
-
-    #[test]
-    fn loopback_hosts_are_local() {
-        assert!(agent_is_local("ws://127.0.0.1:3000/ws"));
-        assert!(agent_is_local("ws://localhost:3000/ws"));
-        assert!(agent_is_local("ws://[::1]:3000/ws"));
-        assert!(agent_is_local("wss://127.0.0.1/ws"));
-    }
-
-    #[test]
-    fn public_addresses_are_not_local() {
-        // 8.8.8.8 is not assigned to any local interface.
-        assert!(!agent_is_local("ws://8.8.8.8:3000/ws"));
-        // Documentation-range address, guaranteed not bound locally.
-        assert!(!agent_is_local("ws://203.0.113.1:3000/ws"));
-    }
-
-    #[test]
-    fn garbage_fails_closed() {
-        assert!(!agent_is_local("not a url"));
-        assert!(!agent_is_local(""));
-    }
-}

socktop/src/main.rs

@@ -2,8 +2,6 @@
 
 mod app;
 mod history;
-mod local;
-mod proc_kill;
 mod profiles;
 mod retry;
 mod types;
@@ -25,18 +23,6 @@ pub(crate) struct ParsedArgs {
     processes_interval_ms: Option<u64>,
     verify_hostname: bool,
     compact: bool,
-    no_kill: bool,
-}
-
-/// True when the `SOCKTOP_NO_KILL` environment variable disables the process-kill
-/// feature. Any value other than empty, `0`, or `false` (case-insensitive) counts
-/// as set, so a deployment can export `SOCKTOP_NO_KILL=1` once and every socktop
-/// launched under it — whatever its command line — has the feature off.
-pub(crate) fn no_kill_from_env() -> bool {
-    match env::var("SOCKTOP_NO_KILL") {
-        Ok(v) => !v.is_empty() && v != "0" && !v.eq_ignore_ascii_case("false"),
-        Err(_) => false,
-    }
 }
 
 pub(crate) fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<ParsedArgs, String> {
@@ -52,12 +38,11 @@ pub(crate) fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<Pars
     let mut processes_interval_ms: Option<u64> = None;
     let mut verify_hostname = false;
     let mut compact = false;
-    let mut no_kill = false;
     while let Some(arg) = it.next() {
         match arg.as_str() {
             "-h" | "--help" => {
                 return Err(format!(
-                    "Usage: {prog} [--tls-ca CERT_PEM|-t CERT_PEM] [--verify-hostname] [--profile NAME|-P NAME] [--save] [--demo] [--compact] [--no-kill] [--metrics-interval-ms N] [--processes-interval-ms N] [ws://HOST:PORT/ws]\n"
+                    "Usage: {prog} [--tls-ca CERT_PEM|-t CERT_PEM] [--verify-hostname] [--profile NAME|-P NAME] [--save] [--demo] [--compact] [--metrics-interval-ms N] [--processes-interval-ms N] [ws://HOST:PORT/ws]\n"
                 ));
             }
             "--tls-ca" | "-t" => {
@@ -83,12 +68,6 @@ pub(crate) fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<Pars
                 // layout switches on its own once the window gets too short.
                 compact = true;
             }
-            "--no-kill" => {
-                // Disable the local process-kill feature even when the agent is
-                // local. For shared/kiosk deployments; SOCKTOP_NO_KILL=1 in the
-                // environment does the same without touching the command line.
-                no_kill = true;
-            }
             "--dry-run" => {
                 // intentionally undocumented
                 dry_run = true;
@@ -124,20 +103,11 @@ pub(crate) fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<Pars
                 }
             }
             _ => {
-                // An unrecognized option must never fall through to the
-                // positional URL slot: an older binary handed a newer flag
-                // would otherwise "connect" to the flag text — and offer to
-                // save it over a named profile's URL.
-                if arg.starts_with('-') {
-                    return Err(format!(
-                        "Unknown option '{arg}'. Usage: {prog} [--tls-ca CERT_PEM|-t CERT_PEM] [--verify-hostname] [--profile NAME|-P NAME] [--save] [--demo] [--compact] [--no-kill] [ws://HOST:PORT/ws]"
-                    ));
-                }
                 if url.is_none() {
                     url = Some(arg);
                 } else {
                     return Err(format!(
-                        "Unexpected argument. Usage: {prog} [--tls-ca CERT_PEM|-t CERT_PEM] [--verify-hostname] [--profile NAME|-P NAME] [--save] [--demo] [--compact] [--no-kill] [ws://HOST:PORT/ws]"
+                        "Unexpected argument. Usage: {prog} [--tls-ca CERT_PEM|-t CERT_PEM] [--verify-hostname] [--profile NAME|-P NAME] [--save] [--demo] [--compact] [ws://HOST:PORT/ws]"
                     ));
                 }
             }
@@ -154,7 +124,6 @@ pub(crate) fn parse_args<I: IntoIterator<Item = String>>(args: I) -> Result<Pars
         processes_interval_ms,
         verify_hostname,
         compact,
-        no_kill,
     })
 }
 
@@ -164,11 +133,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         Ok(v) => v,
         Err(msg) => {
             eprintln!("{msg}");
-            // --help produces the bare usage text and exits cleanly; real
-            // parse errors must be visible to scripts and CI as a failure.
-            if !msg.starts_with("Usage:") {
-                std::process::exit(2);
-            }
             return Ok(());
         }
     };
@@ -180,7 +144,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 
     if parsed.demo || matches!(parsed.profile.as_deref(), Some("demo")) {
-        return run_demo_mode(parsed.tls_ca.as_deref(), parsed.compact, parsed.no_kill).await;
+        return run_demo_mode(parsed.tls_ca.as_deref(), parsed.compact).await;
     }
 
     let profiles_file = load_profiles();
@@ -285,12 +249,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     if (1..=names.len()).contains(&idx) {
                         let name = &names[idx - 1];
                         if name == "demo" {
-                            return run_demo_mode(
-                                parsed.tls_ca.as_deref(),
-                                parsed.compact,
-                                parsed.no_kill,
-                            )
-                            .await;
+                            return run_demo_mode(parsed.tls_ca.as_deref(), parsed.compact).await;
                         }
                         if let Some(entry) = profiles_mut.profiles.get(name) {
                             (
@@ -350,8 +309,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 );
                 eprintln!("If you don't have an agent running, you can try the demo mode.");
                 if prompt_yes_no("Would you like to start the demo mode now? [Y/n]: ") {
-                    return run_demo_mode(parsed.tls_ca.as_deref(), parsed.compact, parsed.no_kill)
-                        .await;
+                    return run_demo_mode(parsed.tls_ca.as_deref(), parsed.compact).await;
                 } else {
                     eprintln!("Aborting. You can run 'socktop --help' for usage information.");
                     return Ok(());
@@ -363,17 +321,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let is_tls = url.starts_with("wss://");
     let has_token = url.contains("token=");
-    // Only enable local process-kill when the agent is verified to be on this
-    // machine — otherwise on-screen PIDs refer to a remote host and acting on
-    // them locally would signal the wrong process (see local::agent_is_local) —
-    // AND neither --no-kill nor SOCKTOP_NO_KILL disables it as a matter of
-    // policy (shared terminals, public demos).
-    let kill_enabled = local::agent_is_local(&url) && !parsed.no_kill && !no_kill_from_env();
     let mut app = App::new()
         .with_intervals(metrics_interval_ms, processes_interval_ms)
         .with_status(is_tls, has_token)
-        .with_compact(parsed.compact)
-        .with_kill_enabled(kill_enabled);
+        .with_compact(parsed.compact);
     if parsed.dry_run {
         return Ok(());
     }
@@ -440,7 +391,6 @@ fn gather_intervals(
 async fn run_demo_mode(
     _tls_ca: Option<&str>,
     compact: bool,
-    no_kill: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let port = 3231;
     let url = format!("ws://127.0.0.1:{port}/ws");
@@ -454,13 +404,7 @@ async fn run_demo_mode(
         }
         Err(e) => return Err(e.into()),
     };
-    // Demo mode runs the real agent on loopback, so its PIDs are real local
-    // processes — enable the local process-kill feature, gated the same way as
-    // the normal connect path (loopback resolves local, --no-kill and
-    // SOCKTOP_NO_KILL still override).
-    let mut app = App::new()
-        .with_compact(compact)
-        .with_kill_enabled(local::agent_is_local(&url) && !no_kill && !no_kill_from_env());
+    let mut app = App::new().with_compact(compact);
     // Demo mode connects to localhost, so disable hostname verification
     tokio::select! { res=app.run(&url,None,false)=>{ drop(child); res } _=tokio::signal::ctrl_c()=>{ drop(child); Ok(()) } }
 }

socktop/src/proc_kill.rs

@@ -1,181 +0,0 @@
-//! Local process termination.
-//!
-//! Signals are sent by socktop itself, using this process's own OS privileges,
-//! via a direct `sysinfo` call. Nothing is transmitted to the agent — the
-//! agent and connector have no kill capability at all. This code path is only
-//! reachable once the agent has been verified to be local (see
-//! [`crate::local`]), which guarantees the PID refers to a process on this
-//! machine.
-
-use sysinfo::{ProcessRefreshKind, ProcessesToUpdate, Signal, System};
-
-/// The signals socktop can send. Deliberately limited to the two btop-style
-/// primaries; no arbitrary-signal chooser.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum KillSignal {
-    /// SIGTERM — polite request to terminate.
-    Term,
-    /// SIGKILL — forceful, cannot be caught.
-    Kill,
-}
-
-impl KillSignal {
-    fn as_sysinfo(self) -> Signal {
-        match self {
-            KillSignal::Term => Signal::Term,
-            KillSignal::Kill => Signal::Kill,
-        }
-    }
-
-    /// Human-facing label for confirmation/result messages.
-    pub fn label(self) -> &'static str {
-        match self {
-            KillSignal::Term => "SIGTERM",
-            KillSignal::Kill => "SIGKILL",
-        }
-    }
-}
-
-/// Is `pid` still a live local process?
-///
-/// A zombie counts as gone: after a kill the entry can linger until the parent
-/// reaps it, and showing a row for a process that no longer runs is exactly the
-/// staleness this check exists to avoid.
-pub fn process_exists(pid: u32) -> bool {
-    let spid = sysinfo::Pid::from_u32(pid);
-    let mut sys = System::new();
-    sys.refresh_processes_specifics(
-        ProcessesToUpdate::Some(&[spid]),
-        false,
-        ProcessRefreshKind::nothing(),
-    );
-    match sys.process(spid) {
-        Some(p) => p.status() != sysinfo::ProcessStatus::Zombie,
-        None => false,
-    }
-}
-
-/// Send `signal` to local process `pid`. Returns `Ok(())` on success, or an
-/// `Err` with a human-readable reason (process gone, PID reused, permission
-/// denied, signal unsupported on this platform).
-///
-/// `expected_name`, when given, is compared against the process that owns the
-/// PID **right now**: the PID came from an agent snapshot and the confirmation
-/// dialog can sit open indefinitely, so by signal time the kernel may have
-/// recycled the number for an unrelated process. Both names come from the
-/// same sysinfo source, so a live, unchanged target compares equal.
-pub fn kill_local_process(
-    pid: u32,
-    expected_name: Option<&str>,
-    signal: KillSignal,
-) -> Result<(), String> {
-    let spid = sysinfo::Pid::from_u32(pid);
-
-    // Refresh just this one PID — we don't need a full process scan to signal it.
-    let mut sys = System::new();
-    sys.refresh_processes_specifics(
-        ProcessesToUpdate::Some(&[spid]),
-        false,
-        ProcessRefreshKind::nothing(),
-    );
-
-    let Some(proc_) = sys.process(spid) else {
-        return Err(format!("Process {pid} no longer exists"));
-    };
-
-    if let Some(expected) = expected_name {
-        let current = proc_.name().to_string_lossy();
-        if current != expected {
-            return Err(format!(
-                "PID {pid} now belongs to \"{current}\", not \"{expected}\" — \
-                 not signalling. Reselect the process and try again."
-            ));
-        }
-    }
-
-    match proc_.kill_with(signal.as_sysinfo()) {
-        Some(true) => Ok(()),
-        Some(false) => Err(format!(
-            "Could not send {} to PID {pid} (permission denied?)",
-            signal.label()
-        )),
-        None => Err(format!(
-            "{} is not supported on this platform",
-            signal.label()
-        )),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::process::Command;
-    use std::time::{Duration, Instant};
-
-    /// The path that matters: a real, live, local process must actually receive
-    /// the signal. Exercises the `refresh_processes_specifics` lookup as well —
-    /// if that call does not populate the process map, `sys.process()` returns
-    /// None and a live PID is reported as "no longer exists".
-    #[test]
-    fn signals_a_real_child_process() {
-        let mut child = Command::new("sleep")
-            .arg("30")
-            .spawn()
-            .expect("spawn sleep for the test");
-        let pid = child.id();
-
-        let result = kill_local_process(pid, Some("sleep"), KillSignal::Term);
-
-        // Reap on every path before asserting, so a failing assert cannot leak a
-        // 30s sleep and cannot trip clippy's zombie_processes lint.
-        let deadline = Instant::now() + Duration::from_secs(5);
-        let mut exited = false;
-        while Instant::now() < deadline {
-            if matches!(child.try_wait(), Ok(Some(_))) {
-                exited = true;
-                break;
-            }
-            std::thread::sleep(Duration::from_millis(20));
-        }
-        if !exited {
-            let _ = child.kill();
-        }
-        let _ = child.wait();
-
-        assert!(result.is_ok(), "kill_local_process returned {result:?}");
-        assert!(
-            exited,
-            "SIGTERM was reported sent but the child never exited"
-        );
-    }
-
-    /// The reuse guard: a live PID whose owner does not match the name the
-    /// user confirmed must NOT be signalled. This also proves the name is
-    /// populated under ProcessRefreshKind::nothing() — if it weren't, the
-    /// matching-name test above would fail instead.
-    #[test]
-    fn refuses_a_pid_owned_by_a_different_process() {
-        let mut child = Command::new("sleep")
-            .arg("30")
-            .spawn()
-            .expect("spawn sleep");
-        let pid = child.id();
-
-        let result = kill_local_process(pid, Some("firefox"), KillSignal::Term);
-
-        let _ = child.kill();
-        let _ = child.wait();
-
-        let err = result.expect_err("signalled a process under the wrong name");
-        assert!(err.contains("firefox") && err.contains("sleep"), "{err}");
-    }
-
-    #[test]
-    fn reports_a_pid_that_is_gone() {
-        let mut child = Command::new("true").spawn().expect("spawn true");
-        let pid = child.id();
-        child.wait().expect("reap");
-        // The PID is now free; signalling it must fail cleanly, not panic.
-        assert!(kill_local_process(pid, None, KillSignal::Term).is_err());
-    }
-}

socktop/src/ui/modal.rs

@@ -1,10 +1,6 @@
 //! Modal window system for socktop TUI application
 
-use super::fit;
-use super::theme::{
-    BTN_EXIT_BG_ACTIVE, BTN_RETRY_BG_ACTIVE, MODAL_BG, MODAL_BORDER_FG, MODAL_DIM_BG, MODAL_FG,
-    MODAL_TITLE_FG,
-};
+use super::theme::MODAL_DIM_BG;
 use crossterm::event::KeyCode;
 use ratatui::{
     Frame,
@@ -30,10 +26,6 @@ pub struct ModalManager {
     pub help_scroll_offset: usize,
 }
 
-/// Key hints shown under the confirmation buttons. Also sets the minimum
-/// width of that dialog — sizing from the question alone clipped this line.
-const CONFIRM_HINT: &str = "Tab ← → choose  ·  Enter run  ·  Esc cancel";
-
 impl ModalManager {
     pub fn new() -> Self {
         Self {
@@ -91,52 +83,6 @@ impl ModalManager {
         }
         m
     }
-    /// Close the details view for `pid` WHEREVER it sits in the stack.
-    /// Returns whether anything was closed.
-    ///
-    /// Not just the top: killing from inside the details view stacks the
-    /// "Signal sent" Info modal on top of it, and a SIGKILL victim is usually
-    /// confirmed dead on the very next tick — while that Info is still up. A
-    /// top-only check missed the close, and since a gone PID is processed
-    /// once, the details view stayed open (frozen on the dead process's last
-    /// sample) with nothing left to ever close it.
-    ///
-    /// Per-PID matching keeps the parent-navigation property: only the dead
-    /// process's view goes; parent views underneath are other processes that
-    /// may still be alive and close themselves the same way.
-    pub fn close_process_details(&mut self, pid: u32) -> bool {
-        let was_top =
-            matches!(self.stack.last(), Some(ModalType::ProcessDetails { pid: p }) if *p == pid);
-        let before = self.stack.len();
-        self.stack
-            .retain(|m| !matches!(m, ModalType::ProcessDetails { pid: p } if *p == pid));
-        if self.stack.len() == before {
-            return false;
-        }
-        // Mirror pop_modal's focus bookkeeping when the top changed.
-        if was_top && let Some(next) = self.stack.last() {
-            self.active_button = match next {
-                ModalType::ConnectionError { .. } => ModalButton::Retry,
-                ModalType::ProcessDetails { .. } => ModalButton::Ok,
-                ModalType::About => ModalButton::Ok,
-                ModalType::Help => ModalButton::Ok,
-                ModalType::Confirmation { .. } => ModalButton::Confirm,
-                ModalType::Info { .. } => ModalButton::Ok,
-            };
-        }
-        true
-    }
-
-    /// PID of the uppermost ProcessDetails view, looking through any
-    /// Info/Confirmation stacked above it. What the user will land on when
-    /// transient modals are dismissed.
-    pub fn topmost_process_details(&self) -> Option<u32> {
-        self.stack.iter().rev().find_map(|m| match m {
-            ModalType::ProcessDetails { pid } => Some(*pid),
-            _ => None,
-        })
-    }
-
     pub fn update_connection_error_countdown(&mut self, new_countdown: Option<u64>) {
         if let Some(ModalType::ConnectionError {
             auto_retry_countdown,
@@ -164,16 +110,6 @@ impl ModalManager {
                 self.prev_button();
                 ModalAction::None
             }
-            // Kill the process being viewed. `t` rather than `k` because `k`
-            // scrolls the thread table in this modal — and using the same key
-            // here as on the processes pane means one thing to remember.
-            KeyCode::Char('t') | KeyCode::Char('T') => {
-                if let Some(ModalType::ProcessDetails { pid }) = self.stack.last() {
-                    ModalAction::KillSelected(*pid)
-                } else {
-                    ModalAction::None
-                }
-            }
             KeyCode::Char('r') | KeyCode::Char('R') => {
                 if matches!(self.stack.last(), Some(ModalType::ConnectionError { .. })) {
                     ModalAction::RetryConnection
@@ -305,16 +241,7 @@ impl ModalManager {
                 ModalAction::Dismiss
             }
             (Some(ModalType::Confirmation { .. }), ModalButton::Confirm) => ModalAction::Confirm,
-            (Some(ModalType::Confirmation { .. }), ModalButton::ConfirmForce) => {
-                ModalAction::ConfirmForce
-            }
-            (Some(ModalType::Confirmation { .. }), ModalButton::Cancel) => {
-                // Pop here so Enter-on-Cancel behaves like Esc (which pops in
-                // handle_key); the app's Cancel handler can then assume the
-                // modal is already gone.
-                self.pop_modal();
-                ModalAction::Cancel
-            }
+            (Some(ModalType::Confirmation { .. }), ModalButton::Cancel) => ModalAction::Cancel,
             (Some(ModalType::Info { .. }), ModalButton::Ok) => {
                 self.pop_modal();
                 ModalAction::Dismiss
@@ -326,29 +253,12 @@ impl ModalManager {
         self.active_button = match (&self.stack.last(), &self.active_button) {
             (Some(ModalType::ConnectionError { .. }), ModalButton::Retry) => ModalButton::Exit,
             (Some(ModalType::ConnectionError { .. }), ModalButton::Exit) => ModalButton::Retry,
-            // Confirmation cycles through three: the safe affirmative, the
-            // escalated one, then cancel.
-            (Some(ModalType::Confirmation { .. }), ModalButton::Confirm) => {
-                ModalButton::ConfirmForce
-            }
-            (Some(ModalType::Confirmation { .. }), ModalButton::ConfirmForce) => {
-                ModalButton::Cancel
-            }
+            (Some(ModalType::Confirmation { .. }), ModalButton::Confirm) => ModalButton::Cancel,
             (Some(ModalType::Confirmation { .. }), ModalButton::Cancel) => ModalButton::Confirm,
             _ => self.active_button.clone(),
         };
     }
     fn prev_button(&mut self) {
-        // Confirmation has three buttons, so stepping back is not the same as
-        // stepping forward; everything else is a two-way toggle.
-        if let Some(ModalType::Confirmation { .. }) = self.stack.last() {
-            self.active_button = match self.active_button {
-                ModalButton::Confirm => ModalButton::Cancel,
-                ModalButton::ConfirmForce => ModalButton::Confirm,
-                _ => ModalButton::ConfirmForce,
-            };
-            return;
-        }
         self.next_button();
     }
 
@@ -370,150 +280,6 @@ impl ModalManager {
         );
     }
 
-    /// Wrap `text` to at most `width` columns on word boundaries, so a dialog
-    /// can be sized from its content instead of guessing.
-    fn wrap_cols(text: &str, width: u16) -> Vec<String> {
-        let mut lines = Vec::new();
-        let mut current = String::new();
-        for word in text.split_whitespace() {
-            let candidate = if current.is_empty() {
-                word.to_string()
-            } else {
-                format!("{current} {word}")
-            };
-            if fit::cols(&candidate) <= width || current.is_empty() {
-                current = candidate;
-            } else {
-                lines.push(std::mem::take(&mut current));
-                current = word.to_string();
-            }
-        }
-        if !current.is_empty() {
-            lines.push(current);
-        }
-        if lines.is_empty() {
-            lines.push(String::new());
-        }
-        lines
-    }
-
-    /// A centered box just big enough for `message` plus `footer_rows` of
-    /// buttons/hints. Never exceeds the screen, and never gets so narrow that
-    /// the title is clipped.
-    ///
-    /// `min_content_w` is the width the footer needs. Sizing from the message
-    /// alone clipped the key-hint line, which is longer than most questions.
-    fn dialog_rect(area: Rect, message: &str, footer_rows: u16, min_content_w: u16) -> Rect {
-        // 2 border columns + 2 columns of breathing room on each side.
-        const CHROME_W: u16 = 6;
-        const MAX_TEXT_W: u16 = 64;
-        const MIN_TEXT_W: u16 = 24;
-
-        let avail_text = area.width.saturating_sub(CHROME_W).max(1);
-        let text_w = fit::cols(message)
-            .min(MAX_TEXT_W)
-            .min(avail_text)
-            .max(MIN_TEXT_W.min(avail_text));
-        let lines = Self::wrap_cols(message, text_w);
-        let widest = lines
-            .iter()
-            .map(|l| fit::cols(l))
-            .max()
-            .unwrap_or(text_w)
-            .max(min_content_w.min(avail_text));
-
-        let width = (widest + CHROME_W).min(area.width);
-        // borders + blank + message + blank + footer
-        let height = (lines.len() as u16 + footer_rows + 4).min(area.height);
-        Rect {
-            x: area.x + (area.width.saturating_sub(width)) / 2,
-            y: area.y + (area.height.saturating_sub(height)) / 2,
-            width,
-            height,
-        }
-    }
-
-    /// Shared chrome for the small dialogs: themed border, centered message
-    /// with real padding, and the footer row(s) returned for the caller to
-    /// fill with buttons.
-    ///
-    /// The old versions laid their content out over `area` rather than the
-    /// block's inner rect, which put the first line of text on top of the
-    /// border and pushed the buttons against the frame.
-    fn render_dialog_frame(
-        f: &mut Frame,
-        area: Rect,
-        title: &str,
-        message: &str,
-        footer_rows: u16,
-    ) -> Rect {
-        let block = Block::default()
-            .title(
-                Line::from(format!(" {title} ")).style(
-                    Style::default()
-                        .fg(MODAL_TITLE_FG)
-                        .add_modifier(Modifier::BOLD),
-                ),
-            )
-            .borders(Borders::ALL)
-            .border_style(Style::default().fg(MODAL_BORDER_FG))
-            .style(Style::default().bg(MODAL_BG));
-        let inner = block.inner(area);
-        f.render_widget(block, area);
-
-        // Pad one column each side so text never touches the border.
-        let padded = Rect {
-            x: inner.x + 1,
-            y: inner.y,
-            width: inner.width.saturating_sub(2),
-            height: inner.height,
-        };
-        let rows = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Length(1),           // breathing room under the title
-                Constraint::Min(1),              // message
-                Constraint::Length(1),           // gap above the footer
-                Constraint::Length(footer_rows), // buttons / hints
-            ])
-            .split(padded);
-
-        f.render_widget(
-            Paragraph::new(message)
-                .style(Style::default().fg(MODAL_FG))
-                .alignment(Alignment::Center)
-                .wrap(Wrap { trim: true }),
-            rows[1],
-        );
-        rows[3]
-    }
-
-    /// One button, sized to its label and centered in `area`.
-    fn render_button(f: &mut Frame, area: Rect, label: &str, active: bool, accent: Color) {
-        let style = if active {
-            Style::default()
-                .bg(accent)
-                .fg(MODAL_BG)
-                .add_modifier(Modifier::BOLD)
-        } else {
-            Style::default().fg(accent)
-        };
-        let text = format!(" {label} ");
-        let w = fit::cols(&text).min(area.width);
-        let btn = Rect {
-            x: area.x + (area.width.saturating_sub(w)) / 2,
-            y: area.y,
-            width: w,
-            height: 1,
-        };
-        f.render_widget(
-            Paragraph::new(text)
-                .style(style)
-                .alignment(Alignment::Center),
-            btn,
-        );
-    }
-
     fn render_modal_content(&mut self, f: &mut Frame, modal: &ModalType, data: ProcessModalData) {
         let area = f.area();
         // Different sizes for different modal types
@@ -530,13 +296,6 @@ impl ModalManager {
                 // Help modal uses medium size
                 self.centered_rect(70, 80, area)
             }
-            // Confirmation and Info are one-question dialogs. A fixed 70%x50%
-            // box left a short question floating in a mostly-empty pane, so
-            // these size themselves to their content instead.
-            ModalType::Confirmation { message, .. } => {
-                Self::dialog_rect(area, message, 3, fit::cols(CONFIRM_HINT))
-            }
-            ModalType::Info { message, .. } => Self::dialog_rect(area, message, 1, 16),
             _ => {
                 // Other modals use smaller size
                 self.centered_rect(70, 50, area)
@@ -581,64 +340,86 @@ impl ModalManager {
         confirm_text: &str,
         cancel_text: &str,
     ) {
-        // Three buttons + a key hint line.
-        let footer = Self::render_dialog_frame(f, area, title, message, 3);
-        let rows = Layout::default()
+        let chunks = Layout::default()
             .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Length(1), // buttons
-                Constraint::Length(1), // spacer
-                Constraint::Length(1), // key hints
-            ])
-            .split(footer);
-
-        let cols = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Ratio(1, 3),
-                Constraint::Ratio(1, 3),
-                Constraint::Ratio(1, 3),
-            ])
-            .split(rows[0]);
-
-        Self::render_button(
-            f,
-            cols[0],
-            confirm_text,
-            self.active_button == ModalButton::Confirm,
-            BTN_RETRY_BG_ACTIVE,
-        );
-        Self::render_button(
-            f,
-            cols[1],
-            "Force kill",
-            self.active_button == ModalButton::ConfirmForce,
-            MODAL_TITLE_FG,
-        );
-        Self::render_button(
-            f,
-            cols[2],
-            cancel_text,
-            self.active_button == ModalButton::Cancel,
-            BTN_EXIT_BG_ACTIVE,
-        );
-
+            .constraints([Constraint::Min(1), Constraint::Length(3)])
+            .split(area);
+        let block = Block::default()
+            .title(format!(" {title} "))
+            .borders(Borders::ALL)
+            .style(Style::default().bg(Color::Black));
+        f.render_widget(block, area);
         f.render_widget(
-            Paragraph::new(CONFIRM_HINT)
-                .style(Style::default().fg(MODAL_FG).add_modifier(Modifier::DIM))
+            Paragraph::new(message)
+                .style(Style::default().fg(Color::White))
+                .alignment(Alignment::Center)
+                .wrap(Wrap { trim: true }),
+            chunks[0],
+        );
+        let buttons = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+            .split(chunks[1]);
+        let confirm_style = if self.active_button == ModalButton::Confirm {
+            Style::default()
+                .bg(Color::Green)
+                .fg(Color::Black)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default().fg(Color::Green)
+        };
+        let cancel_style = if self.active_button == ModalButton::Cancel {
+            Style::default()
+                .bg(Color::Red)
+                .fg(Color::Black)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default().fg(Color::Red)
+        };
+        f.render_widget(
+            Paragraph::new(confirm_text)
+                .style(confirm_style)
                 .alignment(Alignment::Center),
-            rows[2],
+            buttons[0],
+        );
+        f.render_widget(
+            Paragraph::new(cancel_text)
+                .style(cancel_style)
+                .alignment(Alignment::Center),
+            buttons[1],
         );
     }
 
     fn render_info(&self, f: &mut Frame, area: Rect, title: &str, message: &str) {
-        let footer = Self::render_dialog_frame(f, area, title, message, 1);
-        Self::render_button(
-            f,
-            footer,
-            "Enter — OK",
-            self.active_button == ModalButton::Ok,
-            BTN_RETRY_BG_ACTIVE,
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Min(1), Constraint::Length(3)])
+            .split(area);
+        let block = Block::default()
+            .title(format!(" {title} "))
+            .borders(Borders::ALL)
+            .style(Style::default().bg(Color::Black));
+        f.render_widget(block, area);
+        f.render_widget(
+            Paragraph::new(message)
+                .style(Style::default().fg(Color::White))
+                .alignment(Alignment::Center)
+                .wrap(Wrap { trim: true }),
+            chunks[0],
+        );
+        let ok_style = if self.active_button == ModalButton::Ok {
+            Style::default()
+                .bg(Color::Blue)
+                .fg(Color::White)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default().fg(Color::Blue)
+        };
+        f.render_widget(
+            Paragraph::new("[ Enter ] OK")
+                .style(ok_style)
+                .alignment(Alignment::Center),
+            chunks[1],
         );
     }
 
@@ -724,9 +505,6 @@ impl ModalManager {
             "  ↑/↓ ............ Select/navigate processes",
             "  Enter .......... Open Process Details",
             "  x/X ............ Clear selection",
-            "  t .............. Signal selected process — local agent only",
-            "                   (also works inside Process Details; the prompt",
-            "                    offers Terminate/SIGTERM or Force kill/SIGKILL)",
             "  Click header ... Sort by column (CPU/Mem)",
             "  Click row ...... Select process",
             "",
@@ -854,254 +632,3 @@ impl ModalManager {
             .split(vert[1])[1]
     }
 }
-
-#[cfg(test)]
-mod confirm_tests {
-    use super::*;
-
-    fn confirm_modal() -> ModalManager {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::Confirmation {
-            title: "Confirm signal".into(),
-            message: "Send a signal to bash (PID 42)?".into(),
-            confirm_text: "Terminate".into(),
-            cancel_text: "Cancel".into(),
-        });
-        m
-    }
-
-    /// The safe option is focused first, so a reflexive Enter terminates rather
-    /// than force-kills.
-    #[test]
-    fn opens_on_the_safe_option() {
-        let mut m = confirm_modal();
-        assert_eq!(m.active_button, ModalButton::Confirm);
-        assert_eq!(m.handle_key(KeyCode::Enter), ModalAction::Confirm);
-    }
-
-    #[test]
-    fn tab_cycles_all_three_buttons_forward() {
-        let mut m = confirm_modal();
-        m.handle_key(KeyCode::Tab);
-        assert_eq!(m.active_button, ModalButton::ConfirmForce);
-        m.handle_key(KeyCode::Tab);
-        assert_eq!(m.active_button, ModalButton::Cancel);
-        m.handle_key(KeyCode::Tab);
-        assert_eq!(m.active_button, ModalButton::Confirm);
-    }
-
-    /// With three buttons, back is not the same as forward — the old
-    /// prev_button just called next_button, which only worked for two.
-    #[test]
-    fn shift_tab_cycles_backward() {
-        let mut m = confirm_modal();
-        m.handle_key(KeyCode::BackTab);
-        assert_eq!(m.active_button, ModalButton::Cancel);
-        m.handle_key(KeyCode::BackTab);
-        assert_eq!(m.active_button, ModalButton::ConfirmForce);
-        m.handle_key(KeyCode::BackTab);
-        assert_eq!(m.active_button, ModalButton::Confirm);
-    }
-
-    #[test]
-    fn force_kill_reports_its_own_action() {
-        let mut m = confirm_modal();
-        m.handle_key(KeyCode::Tab);
-        assert_eq!(m.handle_key(KeyCode::Enter), ModalAction::ConfirmForce);
-    }
-
-    #[test]
-    fn escape_cancels_and_closes() {
-        let mut m = confirm_modal();
-        assert_eq!(m.handle_key(KeyCode::Esc), ModalAction::Cancel);
-        assert!(!m.is_active());
-    }
-
-    /// Enter on Cancel must behave like Esc, including closing the modal.
-    #[test]
-    fn enter_on_cancel_closes_too() {
-        let mut m = confirm_modal();
-        m.handle_key(KeyCode::Tab);
-        m.handle_key(KeyCode::Tab);
-        assert_eq!(m.handle_key(KeyCode::Enter), ModalAction::Cancel);
-        assert!(!m.is_active());
-    }
-
-    /// `t` inside process details asks the app to raise the kill prompt for the
-    /// process being viewed — not for whatever is selected in the list behind it.
-    #[test]
-    fn t_in_process_details_targets_that_pid() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::ProcessDetails { pid: 4242 });
-        assert_eq!(
-            m.handle_key(KeyCode::Char('t')),
-            ModalAction::KillSelected(4242)
-        );
-    }
-
-    /// `k` still scrolls the thread table, which is why `t` is the kill key.
-    #[test]
-    fn k_in_process_details_still_scrolls() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::ProcessDetails { pid: 1 });
-        m.thread_scroll_max = 5;
-        m.handle_key(KeyCode::Char('j'));
-        assert_eq!(m.thread_scroll_offset, 1);
-        assert_eq!(m.handle_key(KeyCode::Char('k')), ModalAction::Handled);
-        assert_eq!(m.thread_scroll_offset, 0);
-    }
-
-    #[test]
-    fn t_elsewhere_is_not_a_kill() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::Help);
-        assert_eq!(m.handle_key(KeyCode::Char('t')), ModalAction::None);
-    }
-
-    /// A one-line question must not be handed a half-screen box.
-    #[test]
-    fn dialog_is_sized_to_its_content() {
-        let screen = Rect::new(0, 0, 120, 40);
-        let r = ModalManager::dialog_rect(
-            screen,
-            "Send a signal to bash (PID 42)?",
-            3,
-            fit::cols(CONFIRM_HINT),
-        );
-        assert!(r.width < screen.width, "dialog took the full width");
-        assert!(r.height <= 12, "dialog was {} rows tall", r.height);
-        assert!(r.height >= 7, "dialog too short to hold its own footer");
-        // Centered to within the rounding of integer division.
-        let center_delta = (r.x + r.width / 2) as i32 - (screen.width / 2) as i32;
-        assert!(center_delta.abs() <= 1, "off-center by {center_delta}");
-    }
-
-    #[test]
-    fn dialog_never_exceeds_a_small_screen() {
-        let screen = Rect::new(0, 0, 20, 8);
-        let long = "a".repeat(400);
-        let r = ModalManager::dialog_rect(screen, &long, 3, fit::cols(CONFIRM_HINT));
-        assert!(r.width <= screen.width && r.height <= screen.height);
-    }
-}
-
-#[cfg(test)]
-mod button_style_tests {
-    use super::*;
-    use ratatui::Terminal;
-    use ratatui::backend::TestBackend;
-
-    /// The focused button must be the highlighted one — the whole point of the
-    /// three-button layout is that you can see which action Enter will run.
-    #[test]
-    fn focus_moves_the_highlight() {
-        let msg = "Send a signal to bash (PID 42)?";
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::Confirmation {
-            title: "Confirm signal".into(),
-            message: msg.into(),
-            confirm_text: "Terminate".into(),
-            cancel_text: "Cancel".into(),
-        });
-
-        // Background colors present on the button row, per focused button.
-        let bgs = |m: &ModalManager| -> Vec<Color> {
-            let screen = Rect::new(0, 0, 100, 30);
-            let area = ModalManager::dialog_rect(screen, msg, 3, fit::cols(CONFIRM_HINT));
-            let mut t = Terminal::new(TestBackend::new(100, 30)).unwrap();
-            t.draw(|f| {
-                m.render_confirmation(f, area, "Confirm signal", msg, "Terminate", "Cancel")
-            })
-            .unwrap();
-            let buf = t.backend().buffer();
-            // Buttons sit on the first footer row: title, gap, message, gap.
-            let row = area.y + 4;
-            (area.x..area.x + area.width)
-                .map(|x| buf[(x, row)].bg)
-                .collect()
-        };
-
-        let terminate_focused = bgs(&m);
-        assert!(
-            terminate_focused.contains(&BTN_RETRY_BG_ACTIVE),
-            "Terminate should be highlighted when focused"
-        );
-        assert!(
-            !terminate_focused.contains(&BTN_EXIT_BG_ACTIVE),
-            "Cancel must not be highlighted while Terminate has focus"
-        );
-
-        m.handle_key(KeyCode::Tab);
-        m.handle_key(KeyCode::Tab);
-        let cancel_focused = bgs(&m);
-        assert!(
-            cancel_focused.contains(&BTN_EXIT_BG_ACTIVE),
-            "Cancel should be highlighted after two Tabs"
-        );
-        assert!(
-            !cancel_focused.contains(&BTN_RETRY_BG_ACTIVE),
-            "Terminate must not stay highlighted"
-        );
-    }
-}
-
-#[cfg(test)]
-mod close_details_tests {
-    use super::*;
-
-    #[test]
-    fn closes_the_view_for_that_pid() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::ProcessDetails { pid: 4242 });
-        assert!(m.close_process_details(4242));
-        assert!(!m.is_active());
-    }
-
-    #[test]
-    fn leaves_a_different_pid_alone() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::ProcessDetails { pid: 4242 });
-        assert!(!m.close_process_details(1));
-        assert!(m.is_active());
-    }
-
-    /// Walking up to a parent stacks details views. Only the dead process's
-    /// view goes — whichever position it holds — and the survivor stays put.
-    #[test]
-    fn closes_only_the_dead_pids_view_in_a_parent_chain() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::ProcessDetails { pid: 100 }); // parent
-        m.push_modal(ModalType::ProcessDetails { pid: 200 }); // child, on top
-
-        // Parent dies while the child is viewed: its view is removed from
-        // UNDER the top, so closing the child later lands on the process list
-        // instead of a frozen corpse view.
-        assert!(m.close_process_details(100));
-        assert!(matches!(
-            m.current_modal(),
-            Some(ModalType::ProcessDetails { pid: 200 })
-        ));
-        assert!(m.close_process_details(200));
-        assert!(!m.is_active());
-    }
-
-    /// The F1 regression: killing from inside the details view stacks the
-    /// "Signal sent" Info on top, and the death is usually confirmed while
-    /// that Info is still up. The details view must close anyway — a top-only
-    /// check left it open forever, frozen on the dead process.
-    #[test]
-    fn closes_details_beneath_a_stacked_info_modal() {
-        let mut m = ModalManager::new();
-        m.push_modal(ModalType::ProcessDetails { pid: 7 });
-        m.push_modal(ModalType::Info {
-            title: "Signal sent".into(),
-            message: "Sent SIGKILL".into(),
-        });
-
-        assert!(m.close_process_details(7));
-        // The Info survives on top; dismissing it lands on the process list.
-        assert!(matches!(m.current_modal(), Some(ModalType::Info { .. })));
-        m.pop_modal();
-        assert!(!m.is_active());
-    }
-}

socktop/src/ui/modal_process.rs

@@ -95,7 +95,7 @@ impl ModalManager {
         }
 
         // Help line
-        let mut help_text = vec![Line::from(vec![
+        let help_text = vec![Line::from(vec![
             Span::styled(
                 "X ",
                 Style::default()
@@ -129,23 +129,6 @@ impl ModalManager {
             Span::styled("journal", Style::default().add_modifier(Modifier::DIM)),
         ])];
 
-        // Kill from here too — same key as the processes pane, and only shown
-        // when the kill feature is enabled (agent local, no policy override).
-        if data.kill_enabled
-            && let Some(line) = help_text.first_mut()
-        {
-            line.spans.push(Span::styled(
-                "  t ",
-                Style::default()
-                    .fg(PROCESS_DETAILS_ACCENT)
-                    .add_modifier(Modifier::BOLD),
-            ));
-            line.spans.push(Span::styled(
-                "kill",
-                Style::default().add_modifier(Modifier::DIM),
-            ));
-        }
-
         let help = Paragraph::new(Text::from(help_text))
             .alignment(Alignment::Center)
             .style(Style::default());

socktop/src/ui/modal_types.rs

@@ -19,10 +19,6 @@ pub struct ProcessModalData<'a> {
     pub history: ProcessHistoryData<'a>,
     pub max_mem_bytes: u64,
     pub unsupported: bool,
-    /// Whether the process-kill feature is available (agent local, no policy
-    /// override). Only used to decide whether the `t` kill hint is shown —
-    /// the kill itself is gated in `App`.
-    pub kill_enabled: bool,
 }
 
 /// Parameters for rendering scatter plot
@@ -68,15 +64,9 @@ pub enum ModalAction {
     RetryConnection,
     ExitApp,
     Confirm,
-    /// Confirmation modal's second affirmative: the same action, escalated.
-    /// Used by the kill prompt for SIGKILL, where `Confirm` means SIGTERM.
-    ConfirmForce,
     Cancel,
     Dismiss,
     SwitchToParentProcess(u32), // Switch to viewing parent process details
-    /// `t` pressed while viewing a process's details — the app decides whether
-    /// the agent is local and, if so, raises the kill confirmation.
-    KillSelected(u32),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -84,10 +74,6 @@ pub enum ModalButton {
     Retry,
     Exit,
     Confirm,
-    /// Escalated affirmative on a Confirmation modal (SIGKILL for the kill
-    /// prompt). Separate button rather than a separate keybinding so the
-    /// destructive option has to be selected deliberately.
-    ConfirmForce,
     Cancel,
     Ok,
 }

socktop/src/ui/processes.rs

@@ -5,14 +5,13 @@ use ratatui::style::Modifier;
 use ratatui::{
     layout::{Constraint, Direction, Layout, Rect},
     style::{Color, Style},
-    text::{Line, Span},
+    text::Span,
     widgets::{Block, Borders, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState, Table},
 };
 use std::cmp::Ordering;
 
 use crate::types::Metrics;
 use crate::ui::cpu::{per_core_clamp, per_core_handle_scrollbar_mouse};
-use crate::ui::fit;
 use crate::ui::theme::{
     PROCESS_SELECTION_BG, PROCESS_SELECTION_FG, PROCESS_TOOLTIP_BG, PROCESS_TOOLTIP_FG, SB_ARROW,
     SB_THUMB, SB_TRACK,
@@ -87,10 +86,6 @@ pub struct ProcessDisplayParams<'a> {
     /// Peak cpu_usage from the most recent cache build; used to bold the
     /// busiest process. -1.0 if no cache.
     pub peak_cpu: f32,
-    /// The process-kill feature is available (agent local, no policy
-    /// override), so the `t` kill hint applies. Without it the hint would
-    /// advertise a key that deliberately does nothing.
-    pub kill_enabled: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -454,60 +449,16 @@ pub fn draw_top_processes(f: &mut ratatui::Frame<'_>, area: Rect, params: Proces
             format!("PID {selected_pid}")
         };
 
-        // Key hints, built as spans so the keys read as keys. `t` only appears
-        // for a local agent, since that is the only case where it does anything.
-        let key = Style::default()
-            .fg(PROCESS_TOOLTIP_FG)
-            .add_modifier(Modifier::BOLD);
-        let label = Style::default().fg(PROCESS_TOOLTIP_FG);
-        let mut hints: Vec<Span> = vec![
-            Span::styled("⏎", key),
-            Span::styled(" details", label),
-            Span::styled("  ·  ", label),
-        ];
-        if params.kill_enabled {
-            hints.push(Span::styled("t", key));
-            hints.push(Span::styled(" kill", label));
-            hints.push(Span::styled("  ·  ", label));
-        }
-        hints.push(Span::styled("x", key));
-        hints.push(Span::styled(" unselect", label));
-
-        let hints_w: u16 = hints.iter().map(|s| fit::cols(&s.content)).sum();
-        // One row, borders on both sides, a space of padding each side.
+        let tooltip_text = format!("{process_info} | Enter for details • X to unselect");
+        let tooltip_width = tooltip_text.len() as u16 + 2; // Add padding
         let tooltip_height = 3;
-        let max_w = area.width.saturating_sub(2);
-        if max_w > hints_w + 6 && area.height > tooltip_height + 1 {
-            // The process name is the elastic part: truncate it so the hint
-            // always fits. The old version sized the box from the full string
-            // and skipped rendering entirely when a long process name made it
-            // wider than the pane — so the hint silently vanished exactly when
-            // a long-named process was selected.
-            let room_for_info = max_w - hints_w - 6;
-            let info = fit::truncate_cols(&process_info, room_for_info);
-            let mut spans: Vec<Span> = vec![
-                Span::styled(" ", label),
-                Span::styled(
-                    info.clone(),
-                    Style::default()
-                        .fg(PROCESS_TOOLTIP_FG)
-                        .add_modifier(Modifier::BOLD),
-                ),
-                Span::styled("  │  ", label),
-            ];
-            spans.extend(hints);
-            spans.push(Span::styled(" ", label));
 
-            let width = spans
-                .iter()
-                .map(|s| fit::cols(&s.content))
-                .sum::<u16>()
-                .saturating_add(2)
-                .min(area.width);
+        // Position tooltip at bottom-right of the processes area
+        if area.width > tooltip_width + 2 && area.height > tooltip_height + 1 {
             let tooltip_area = Rect {
-                x: area.x + area.width.saturating_sub(width + 1),
+                x: area.x + area.width.saturating_sub(tooltip_width + 1),
                 y: area.y + area.height.saturating_sub(tooltip_height + 1),
-                width,
+                width: tooltip_width,
                 height: tooltip_height,
             };
 
@@ -517,10 +468,11 @@ pub fn draw_top_processes(f: &mut ratatui::Frame<'_>, area: Rect, params: Proces
                     .fg(PROCESS_TOOLTIP_FG),
             );
 
-            f.render_widget(
-                Paragraph::new(Line::from(spans)).block(tooltip_block),
-                tooltip_area,
-            );
+            let tooltip_paragraph = Paragraph::new(tooltip_text)
+                .block(tooltip_block)
+                .wrap(ratatui::widgets::Wrap { trim: true });
+
+            f.render_widget(tooltip_paragraph, tooltip_area);
         }
     }
 
@@ -953,7 +905,6 @@ mod click_tests {
                         filtered_indices: &idxs,
                         cached_rows: &cache,
                         peak_cpu: peak,
-                        kill_enabled: false,
                     },
                 )
             })
@@ -1033,110 +984,3 @@ mod click_tests {
         }
     }
 }
-
-#[cfg(test)]
-mod tooltip_tests {
-    use super::*;
-    use ratatui::Terminal;
-    use ratatui::backend::TestBackend;
-    use ratatui::layout::Rect;
-    use socktop_connector::{Metrics, ProcessInfo};
-
-    fn metrics(name: &str) -> Metrics {
-        Metrics {
-            sampled_at_ms: None,
-            cpu_total: 0.0,
-            cpu_per_core: vec![],
-            mem_total: 32_000_000_000,
-            mem_used: 0,
-            swap_total: 0,
-            swap_used: 0,
-            hostname: "t".into(),
-            cpu_temp_c: None,
-            disks: vec![],
-            networks: vec![],
-            top_processes: vec![ProcessInfo {
-                pid: 4242,
-                name: name.into(),
-                cpu_usage: 1.5,
-                mem_bytes: 1_000_000,
-            }],
-            gpus: None,
-            process_count: Some(1),
-        }
-    }
-
-    /// Render the pane with a selection and return the whole buffer as text.
-    fn rendered(name: &str, width: u16, kill_enabled: bool) -> String {
-        let m = metrics(name);
-        let mut cache = Vec::new();
-        let peak = rebuild_row_cache(&m, &mut cache);
-        let idxs = [0usize];
-        let mut terminal = Terminal::new(TestBackend::new(width, 12)).unwrap();
-        terminal
-            .draw(|f| {
-                draw_top_processes(
-                    f,
-                    Rect::new(0, 0, width, 12),
-                    ProcessDisplayParams {
-                        metrics: Some(&m),
-                        scroll_offset: 0,
-                        sort_by: ProcSortBy::CpuDesc,
-                        selected_process_pid: Some(4242),
-                        selected_process_index: Some(0),
-                        search_query: "",
-                        search_active: false,
-                        filtered_indices: &idxs,
-                        cached_rows: &cache,
-                        peak_cpu: peak,
-                        kill_enabled,
-                    },
-                )
-            })
-            .unwrap();
-        let buf = terminal.backend().buffer();
-        let mut out = String::new();
-        for y in 0..12 {
-            for x in 0..width {
-                out.push_str(buf[(x, y)].symbol());
-            }
-            out.push('\n');
-        }
-        out
-    }
-
-    #[test]
-    fn hint_offers_kill_for_a_local_agent() {
-        let out = rendered("some-process", 80, true);
-        assert!(out.contains("details"), "no hint rendered at all:\n{out}");
-        assert!(
-            out.contains("kill"),
-            "local agent should offer kill:\n{out}"
-        );
-        assert!(out.contains("unselect"));
-    }
-
-    /// The key does nothing for a remote agent, so advertising it would be a lie.
-    #[test]
-    fn hint_omits_kill_for_a_remote_agent() {
-        let out = rendered("some-process", 80, false);
-        assert!(out.contains("details"), "no hint rendered at all:\n{out}");
-        assert!(
-            !out.contains("kill"),
-            "remote agent must not offer kill:\n{out}"
-        );
-    }
-
-    /// Regression: the hint used to be sized from the full label including the
-    /// process name, and was skipped entirely when that made it wider than the
-    /// pane — so it vanished exactly when a long-named process was selected.
-    #[test]
-    fn hint_survives_a_very_long_process_name() {
-        let long = "/usr/lib/firefox-esr/firefox-esr-with-a-really-long-suffix";
-        let out = rendered(long, 80, true);
-        assert!(
-            out.contains("details") && out.contains("kill"),
-            "hint disappeared for a long process name:\n{out}"
-        );
-    }
-}

socktop/tests/cli_args.rs

@@ -106,79 +106,3 @@ fn test_compact_flag_documented_and_accepted() {
         String::from_utf8_lossy(&out2.stderr)
     );
 }
-
-#[test]
-fn test_no_kill_flag_documented_and_accepted() {
-    let exe = env!("CARGO_BIN_EXE_socktop");
-    let out = Command::new(exe)
-        .args(["--no-kill", "--help"])
-        .output()
-        .expect("run socktop --no-kill --help");
-    assert!(
-        out.status.success(),
-        "socktop --no-kill --help did not succeed"
-    );
-    let text = format!(
-        "{}{}",
-        String::from_utf8_lossy(&out.stdout),
-        String::from_utf8_lossy(&out.stderr)
-    );
-    assert!(
-        text.contains("--no-kill"),
-        "help text missing --no-kill\n{text}"
-    );
-
-    // The flag must not be mistaken for the positional URL argument.
-    let out2 = Command::new(exe)
-        .args(["--no-kill", "--dry-run", "ws://127.0.0.1:3000/ws"])
-        .output()
-        .expect("run socktop --no-kill --dry-run");
-    assert!(
-        out2.status.success(),
-        "socktop --no-kill with a URL was rejected: {}",
-        String::from_utf8_lossy(&out2.stderr)
-    );
-}
-
-#[test]
-fn test_no_kill_env_var_accepted() {
-    // SOCKTOP_NO_KILL must not break startup — the env-only path is how the
-    // webterm deployment disables the kill feature for every invocation.
-    let exe = env!("CARGO_BIN_EXE_socktop");
-    let out = Command::new(exe)
-        .env("SOCKTOP_NO_KILL", "1")
-        .args(["--dry-run", "ws://127.0.0.1:3000/ws"])
-        .output()
-        .expect("run socktop with SOCKTOP_NO_KILL=1");
-    assert!(
-        out.status.success(),
-        "socktop with SOCKTOP_NO_KILL=1 did not succeed: {}",
-        String::from_utf8_lossy(&out.stderr)
-    );
-}
-
-#[test]
-fn test_unknown_option_rejected_not_treated_as_url() {
-    // Regression guard for the socktop.io incident (Aug 2026): socktop 1.60.1
-    // parsed the then-unknown --no-kill flag as the positional websocket URL,
-    // which made it prompt to overwrite the 'local' profile's URL with the
-    // literal string "--no-kill". Unknown options must fail loudly instead of
-    // falling through to the URL slot.
-    let exe = env!("CARGO_BIN_EXE_socktop");
-    let out = Command::new(exe)
-        .args(["--not-a-real-flag", "--dry-run", "ws://127.0.0.1:3000/ws"])
-        .output()
-        .expect("run socktop with unknown flag");
-    assert_eq!(
-        out.status.code(),
-        Some(2),
-        "unknown option should exit 2, got: {:?}\nstderr: {}",
-        out.status.code(),
-        String::from_utf8_lossy(&out.stderr)
-    );
-    let err = String::from_utf8_lossy(&out.stderr);
-    assert!(
-        err.contains("Unknown option '--not-a-real-flag'"),
-        "stderr should name the rejected option\n{err}"
-    );
-}

socktop_agent/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "socktop_agent"
-version = "1.60.2"
+version = "1.60.0"
 authors = ["Jason Witty <jasonpwitty+socktop@proton.me>"]
 description = "Socktop agent daemon. Serves host metrics over WebSocket."
 edition = "2024"

socktop_agent/src/metrics.rs

@@ -588,17 +588,9 @@ pub async fn collect_processes_all(state: &AppState) -> ProcessesPayload {
     // filter when downgrading to a minimal refresh spec.
     let mut sys_guard = state.sys.lock().await;
     let sys = &mut *sys_guard;
-    // `true` = remove processes that no longer exist. With `false`, this
-    // long-lived System kept every process it had ever seen: the list grew
-    // without bound (21,648 entries on a machine with 289 processes after a
-    // few hours of build churn), process_count was meaningless, and — the
-    // reason this was found — a process you killed kept its row forever,
-    // because the agent went on reporting it. Safe here only because this is
-    // `ProcessesToUpdate::All`; with `Some(pids)` it would treat every process
-    // outside that list as dead and drop it.
     sys.refresh_processes_specifics(
         ProcessesToUpdate::All,
-        true,
+        false,
         ProcessRefreshKind::nothing().with_memory().without_tasks(),
     );
 
@@ -727,11 +719,8 @@ pub async fn collect_processes_all(state: &AppState) -> ProcessesPayload {
 
         //JW too complicated. simplify to remove strange behavior
 
-        // For active systems, get accurate CPU metrics.
-        // `true` = drop processes that have exited; see the Linux path above for
-        // what `false` cost us (an ever-growing list that kept reporting dead
-        // processes). Correct only because this is `ProcessesToUpdate::All`.
-        sys.refresh_processes_specifics(ProcessesToUpdate::All, true, kind.with_cpu());
+        // For active systems, get accurate CPU metrics
+        sys.refresh_processes_specifics(ProcessesToUpdate::All, false, kind.with_cpu());
 
         // } else {
         //     // For idle systems, just get basic process info

socktop_connector/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "socktop_connector"
-version = "1.60.2"
+version = "1.60.0"
 edition = "2024"
 license = "MIT"
 description = "WebSocket connector library for socktop agent communication"