Rename binaries to illumos-style short names

Follow illumos CLI naming conventions (zoneadm, svcadm, dladm): wayray-server → wrsrvd wayray-client → wrclient wayray-ctl → wradm wayray-greeter → wrlogin wayray-session-launcher → wrsessd wayray-gateway → wrgw wayray-wm-floating → wr-wm-floating wayray-wm-tiling → wr-wm-tiling Updated across all 23 documentation files, ADRs, book pages, roadmap, and CLAUDE.md. Added binary name table to CLAUDE.md.
2026-04-10 13:10:41 +00:00 · 2026-03-29 00:34:19 +01:00 · 2026-03-29 00:34:19 +01:00 · 643c4f042d
commit 643c4f042d
parent c32ed5531d
23 changed files with 90 additions and 77 deletions
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -25,10 +25,10 @@ WayRay is a modern reimplementation of Oracle/Sun's SunRay thin client architect

 WayRay consists of four main components:

-1. **wayray-server** (compositor) - Smithay-based Wayland compositor that runs applications, captures framebuffers, and transmits them to clients. Exposes a pluggable WM protocol.
-2. **wayray-client** (viewer) - Lightweight display client that decodes frames, renders them locally, captures input, and sends it to the server
+1. **wrsrvd** (compositor) - Smithay-based Wayland compositor that runs applications, captures framebuffers, and transmits them to clients. Exposes a pluggable WM protocol.
+2. **wrclient** (viewer) - Lightweight display client that decodes frames, renders them locally, captures input, and sends it to the server
 3. **wayray-protocol** - Shared protocol definitions for the WayRay wire protocol over QUIC
-4. **wayray-ctl** - CLI management tool for server/session administration
+4. **wradm** - CLI management tool for server/session administration

 ## Documentation

@ -54,6 +54,19 @@ WayRay consists of four main components:
 - Audio: PipeWire (Linux) or PulseAudio (illumos/Linux) behind trait abstraction
 - `shm_open` fallback when `memfd_create` unavailable (illumos portability)

+## Binary Names (illumos-style)
+
+| Binary | Purpose |
+|--------|---------|
+| `wrsrvd` | Server compositor daemon |
+| `wrclient` | Client viewer |
+| `wradm` | Administration CLI (`zoneadm`/`svcadm` pattern) |
+| `wrlogin` | Greeter / login screen (`dtlogin` heritage) |
+| `wrsessd` | Session launcher daemon |
+| `wrgw` | Protocol gateway service |
+| `wr-wm-floating` | Default floating WM |
+| `wr-wm-tiling` | Reference tiling WM |
+
 ## Conventions

 - Use miette's diagnostic pattern for all user-facing errors with helpful messages
--- a/book/src/SUMMARY.md
+++ b/book/src/SUMMARY.md
@ -32,7 +32,7 @@

 # Administration

- [wayray-ctl Reference](./admin/wayray-ctl.md)
+- [wradm Reference](./admin/wradm.md)
 - [Security](./admin/security.md)
 - [Monitoring](./admin/monitoring.md)
 - [Troubleshooting](./admin/troubleshooting.md)
--- a/book/src/admin/monitoring.md
+++ b/book/src/admin/monitoring.md
@ -17,7 +17,7 @@ WayRay exposes metrics for monitoring:
 WayRay uses structured logging via the `tracing` crate. Configure log levels via `RUST_LOG`:

 ```bash
-RUST_LOG=wayray=info wayray-server   # Standard
-RUST_LOG=wayray=debug wayray-server  # Verbose
-RUST_LOG=wayray=trace wayray-server  # Everything
+RUST_LOG=wayray=info wrsrvd   # Standard
+RUST_LOG=wayray=debug wrsrvd  # Verbose
+RUST_LOG=wayray=trace wrsrvd  # Everything
 ```
--- a/book/src/admin/troubleshooting.md
+++ b/book/src/admin/troubleshooting.md
@ -7,7 +7,7 @@
 ### Client can't connect to server
 - Check that UDP port 4433 is open
 - Verify TLS certificates are correct
- Check server logs: `RUST_LOG=wayray=debug wayray-server`
+- Check server logs: `RUST_LOG=wayray=debug wrsrvd`

 ### High latency / poor responsiveness
 - Check network latency: `ping <server>`
--- a/book/src/admin/wayray-ctl.md
+++ b/book/src/admin/wayray-ctl.md
@ -1,11 +1,11 @@
-# wayray-ctl Reference
+# wradm Reference

 > This page will be expanded as the management tool is implemented.

 ## Commands

 ```
-wayray-ctl
+wradm
  session
    list              List all sessions
    info <id>         Show session details
--- a/book/src/client/configuration.md
+++ b/book/src/client/configuration.md
@ -4,7 +4,7 @@

 ## Configuration File

-WayRay client reads configuration from `wayray-client.toml`:
+WayRay client reads configuration from `wrclient.toml`:

 ```toml
 [connection]
--- a/book/src/client/connecting.md
+++ b/book/src/client/connecting.md
@ -5,7 +5,7 @@
 ## Basic Connection

 ```bash
-wayray-client --server <host>:<port> --token <token>
+wrclient --server <host>:<port> --token <token>
 ```

 ## Connection Troubleshooting
--- a/book/src/client/tokens.md
+++ b/book/src/client/tokens.md
@ -8,7 +8,7 @@ The simplest token type. A UUID is generated and stored on the client.

 ```bash
 # Generate a new software token
-wayray-client token generate
+wrclient token generate
 # Output: Token: a1b2c3d4-e5f6-7890-abcd-ef1234567890
 ```

@ -18,10 +18,10 @@ Requires a PC/SC compatible smart card reader.

 ```bash
 # List available smart card readers
-wayray-client token list-readers
+wrclient token list-readers

 # Use smart card for session identity
-wayray-client --token-type smartcard --server <host>:<port>
+wrclient --token-type smartcard --server <host>:<port>
 ```

 ## NFC Tokens
@ -30,5 +30,5 @@ Requires an NFC reader.

 ```bash
 # Use NFC for session identity
-wayray-client --token-type nfc --server <host>:<port>
+wrclient --token-type nfc --server <host>:<port>
 ```
--- a/book/src/dev/building.md
+++ b/book/src/dev/building.md
@ -16,21 +16,21 @@ cargo build
 cargo build --release

 # Build only the server
-cargo build -p wayray-server
+cargo build -p wrsrvd

 # Build only the client
-cargo build -p wayray-client
+cargo build -p wrclient

 # Run tests
 cargo test --workspace

 # Run with logging
-RUST_LOG=wayray=debug cargo run -p wayray-server
+RUST_LOG=wayray=debug cargo run -p wrsrvd
 ```

 ## Feature Flags

-### wayray-server
+### wrsrvd

 | Feature | Default | Description |
 |---------|---------|-------------|
@ -39,7 +39,7 @@ RUST_LOG=wayray=debug cargo run -p wayray-server
 | `xwayland` | no | X11 application support |
 | `vaapi` | no | Hardware video encoding |

-### wayray-client
+### wrclient

 | Feature | Default | Description |
 |---------|---------|-------------|
@ -53,7 +53,7 @@ RUST_LOG=wayray=debug cargo run -p wayray-server
 During development, run the WayRay server nested inside your existing desktop using the Winit backend:

 ```bash
-cargo run -p wayray-server -- --backend winit
+cargo run -p wrsrvd -- --backend winit
 ```

 This opens a window on your desktop that acts as the WayRay display. No need for a separate TTY.
@ -62,8 +62,8 @@ This opens a window on your desktop that acts as the WayRay display. No need for

 ```bash
 # Terminal 1: Start server
-cargo run -p wayray-server -- --backend winit --listen 127.0.0.1:4433
+cargo run -p wrsrvd -- --backend winit --listen 127.0.0.1:4433

 # Terminal 2: Start client
-cargo run -p wayray-client -- --server 127.0.0.1:4433 --token dev
+cargo run -p wrclient -- --server 127.0.0.1:4433 --token dev
 ```
--- a/book/src/installation.md
+++ b/book/src/installation.md
@ -43,15 +43,15 @@ cd wayray
 cargo build --release

 # Binaries are in target/release/
-ls target/release/wayray-server target/release/wayray-client target/release/wayray-ctl
+ls target/release/wrsrvd target/release/wrclient target/release/wradm
 ```

 ### Docker

 ```dockerfile
 # Server image available
-docker pull wayray/wayray-server:latest
+docker pull wayray/wrsrvd:latest

 # Or build locally
-docker build -t wayray-server -f docker/server.Dockerfile .
+docker build -t wrsrvd -f docker/server.Dockerfile .
 ```
--- a/book/src/overview.md
+++ b/book/src/overview.md
@ -4,7 +4,7 @@

 WayRay consists of four components:

-### wayray-server
+### wrsrvd

 The server is a Wayland compositor built on [Smithay](https://github.com/Smithay/smithay). It:

@ -17,7 +17,7 @@ The server is a Wayland compositor built on [Smithay](https://github.com/Smithay

 The server runs on Linux and can operate headless (no GPU required) or with GPU acceleration.

-### wayray-client
+### wrclient

 The client is a lightweight viewer application that:

@ -34,7 +34,7 @@ The client runs on Linux, with macOS and Windows support planned.

 A shared library defining the wire protocol between server and client. This ensures both sides agree on message formats at compile time.

-### wayray-ctl
+### wradm

 A command-line tool for administering WayRay servers:

--- a/book/src/quickstart.md
+++ b/book/src/quickstart.md
@ -7,7 +7,7 @@ This guide gets you running a WayRay server and connecting a client in minutes.
 WayRay requires TLS for all connections. For development, generate self-signed certificates:

 ```bash
-wayray-ctl cert generate --output ./certs
+wradm cert generate --output ./certs
 ```

 This creates `certs/server.crt` and `certs/server.key`.
@ -15,7 +15,7 @@ This creates `certs/server.crt` and `certs/server.key`.
 ## 2. Start the Server

 ```bash
-wayray-server \
+wrsrvd \
  --cert ./certs/server.crt \
  --key ./certs/server.key \
  --listen 0.0.0.0:4433 \
@ -29,7 +29,7 @@ The server starts and listens for client connections on port 4433.
 On another machine (or the same machine for testing):

 ```bash
-wayray-client \
+wrclient \
  --server 192.168.1.100:4433 \
  --token my-dev-token \
  --ca ./certs/server.crt  # Trust the self-signed cert
@ -58,7 +58,7 @@ nautilus &      # File manager
 3. Your applications keep running on the server
 4. Reconnect with the same token:
   ```bash
-   wayray-client --server 192.168.1.100:4433 --token my-dev-token
+   wrclient --server 192.168.1.100:4433 --token my-dev-token
   ```
 5. Your desktop reappears with all windows intact

--- a/book/src/server/configuration.md
+++ b/book/src/server/configuration.md
@ -4,7 +4,7 @@

 ## Configuration File

-WayRay server reads configuration from `wayray-server.toml`:
+WayRay server reads configuration from `wrsrvd.toml`:

 ```toml
 [server]
--- a/book/src/server/running.md
+++ b/book/src/server/running.md
@ -5,7 +5,7 @@
 ## Standalone

 ```bash
-wayray-server --config /etc/wayray/wayray-server.toml
+wrsrvd --config /etc/wayray/wrsrvd.toml
 ```

 ## Systemd Service
@ -17,7 +17,7 @@ After=network.target

 [Service]
 Type=simple
-ExecStart=/usr/bin/wayray-server --config /etc/wayray/wayray-server.toml
+ExecStart=/usr/bin/wrsrvd --config /etc/wayray/wrsrvd.toml
 Restart=always
 User=wayray
 Group=wayray
@ -30,8 +30,8 @@ WantedBy=multi-user.target

 ```bash
 docker run -d \
-  --name wayray-server \
+  --name wrsrvd \
  -p 4433:4433/udp \
  -v /etc/wayray:/etc/wayray:ro \
-  wayray/wayray-server:latest
+  wayray/wrsrvd:latest
 ```
--- a/book/src/server/sessions.md
+++ b/book/src/server/sessions.md
@ -13,14 +13,14 @@

 ```bash
 # List active sessions
-wayray-ctl session list
+wradm session list

 # View session details
-wayray-ctl session info <session-id>
+wradm session info <session-id>

 # Terminate a session
-wayray-ctl session kill <session-id>
+wradm session kill <session-id>

 # Set session timeout
-wayray-ctl session set-timeout <session-id> 48h
+wradm session set-timeout <session-id> 48h
 ```
--- a/docs/ai/adr/007-project-structure.md
+++ b/docs/ai/adr/007-project-structure.md
@ -13,7 +13,7 @@ WayRay consists of multiple binaries and shared libraries. We need a project str
 wayray/
 ├── Cargo.toml              # Workspace root
 ├── crates/
-│   ├── wayray-server/      # Wayland compositor + frame encoder + network server
+│   ├── wrsrvd/      # Wayland compositor + frame encoder + network server
 │   │   ├── Cargo.toml
 │   │   └── src/
 │   │       ├── main.rs
@ -22,7 +22,7 @@ wayray/
 │   │       ├── network/     # QUIC server, session management
 │   │       └── audio/       # PipeWire integration
 │   │
-│   ├── wayray-client/      # Remote viewer + input capture + decoder
+│   ├── wrclient/      # Remote viewer + input capture + decoder
 │   │   ├── Cargo.toml
 │   │   └── src/
 │   │       ├── main.rs
@ -40,7 +40,7 @@ wayray/
 │   │       ├── codec.rs     # Serialization/deserialization
 │   │       └── version.rs   # Protocol versioning
 │   │
-│   └── wayray-ctl/         # CLI management tool
+│   └── wradm/         # CLI management tool
 │       ├── Cargo.toml
 │       └── src/
 │           └── main.rs
@ -54,7 +54,7 @@ wayray/
 - `crates/` directory keeps workspace root clean
 - Protocol crate ensures server and client agree on wire format at compile time
 - Server and client have completely different dependency trees (smithay vs wgpu)
- `wayray-ctl` as separate binary avoids bloating server/client with admin dependencies
+- `wradm` as separate binary avoids bloating server/client with admin dependencies
 - Integration tests at workspace root can spin up server + client together

 ## Consequences
--- a/docs/ai/adr/010-greeter-session-launch.md
+++ b/docs/ai/adr/010-greeter-session-launch.md
@ -93,7 +93,7 @@ This is analogous to:
 - Sway: greetd + gtkgreet/regreet
 - GNOME: GDM + gnome-shell (but GDM IS a compositor; our greeter is a client)

-We provide a **reference session launcher** (`wayray-session-launcher`) but the interface is a simple protocol/hook so admins can replace it with their own.
+We provide a **reference session launcher** (`wrsessd`) but the interface is a simple protocol/hook so admins can replace it with their own.

 ### The Greeter

@ -103,7 +103,7 @@ A Wayland client application that:
 - On success, signals the session launcher to proceed with user session setup
 - Exits

-We ship a reference greeter (`wayray-greeter`) but any Wayland client implementing the greeter protocol works. Community can build GTK, Qt, or TUI-based greeters.
+We ship a reference greeter (`wrlogin`) but any Wayland client implementing the greeter protocol works. Community can build GTK, Qt, or TUI-based greeters.

 ### The User Session (Desktop Experience)

@ -113,8 +113,8 @@ After authentication, the session launcher starts the user's configured environm
 # Example: ~/.config/wayray/session.toml

 # Window manager (connects via wayray_wm_manager_v1 protocol)
-wm = "wayray-wm-floating"
-# wm = "wayray-wm-tiling"
+wm = "wr-wm-floating"
+# wm = "wr-wm-tiling"
 # wm = "/usr/local/bin/my-custom-wm"

 # Panel (layer-shell Wayland client)
--- a/docs/ai/adr/011-local-display-mode.md
+++ b/docs/ai/adr/011-local-display-mode.md
@ -116,7 +116,7 @@ Wayland apps → Smithay compositor → PixmanRenderer → CPU buffer

 ### Tier 2: Loopback Optimization (Local Server+Client)

-When wayray-server and wayray-client run on the same machine, skip encoding entirely:
+When wrsrvd and wrclient run on the same machine, skip encoding entirely:

 1. Server renders to shared memory ring buffer (`shm_open` + `mmap`)
 2. Client reads framebuffers directly from shared memory
@ -125,7 +125,7 @@ When wayray-server and wayray-client run on the same machine, skip encoding enti

 ```
 Wayland apps → Smithay compositor → PixmanRenderer → shared memory
-    → wayray-client (local) → fbdev or X11 SHM → screen
+    → wrclient (local) → fbdev or X11 SHM → screen
 ```

 Performance: sub-millisecond frame latency (vs 5-30ms with encode/decode), near-zero CPU overhead for transport, pixel-perfect quality.
--- a/docs/ai/adr/012-cloud-auth-greeter.md
+++ b/docs/ai/adr/012-cloud-auth-greeter.md
@ -90,7 +90,7 @@ The greeter is the natural integration point -- it runs before any user context

 ### Pre-Auth Ephemeral Session

-The greeter itself needs a Wayland session to display the login UI, but no user is authenticated yet. The session launcher creates a minimal **ephemeral session** running as a service user (e.g., `wayray-greeter`):
+The greeter itself needs a Wayland session to display the login UI, but no user is authenticated yet. The session launcher creates a minimal **ephemeral session** running as a service user (e.g., `wrlogin`):
 - Limited compositor session (no user apps, no shell access)
 - Only the greeter client is allowed to connect
 - Destroyed after authentication succeeds or times out
@ -259,7 +259,7 @@ What changes is how the greeter *arrives* at that identity.
 Rather than hardcoding auth methods, the greeter supports **auth plugins**:

 ```
-wayray-greeter
+wrlogin
  ├── auth-local        (username + password → PAM)
  ├── auth-oidc         (OAuth/OIDC device code or auth code)
  ├── auth-smartcard    (PC/SC → certificate → PAM or IdP)
--- a/docs/ai/adr/014-federation-and-foreign-surfaces.md
+++ b/docs/ai/adr/014-federation-and-foreign-surfaces.md
@ -352,7 +352,7 @@ Scenario 3 in practice:
 ```
 Company B admin:
  1. Publishes app "internal-tool" for federation
-  2. Creates invite: wayray-ctl federation invite \
+  2. Creates invite: wradm federation invite \
       --app internal-tool \
       --peer wayray.companya.com \
       --user jdoe@companya.com \
@ -360,7 +360,7 @@ Company B admin:

 Company A user (jdoe):
  1. Sits at their normal WayRay terminal
-  2. Opens federation panel or runs: wayray-ctl federation accept <invite-url>
+  2. Opens federation panel or runs: wradm federation accept <invite-url>
  3. OIDC authentication confirms jdoe's identity to Company B
  4. Company B's "internal-tool" appears as a window in jdoe's desktop
  5. Window has "Trusted" border and "Company B" origin badge
--- a/docs/ai/adr/015-virtual-desktops-rdp-gateway.md
+++ b/docs/ai/adr/015-virtual-desktops-rdp-gateway.md
@ -171,7 +171,7 @@ The user sees: "Connect to Customer D" → windows appear. The gateway handles V
 │    │ ForeignWindow protocol (Unix socket or QUIC)           │
 │    │                                                        │
 │  ┌─┴────────────────────────────────────────────────────┐   │
-│  │  Protocol Gateway Service (wayray-gateway)            │   │
+│  │  Protocol Gateway Service (wrgw)            │   │
 │  │                                                       │   │
 │  │  ┌─────────────┐  ┌───────────────┐  ┌───────────┐  │   │
 │  │  │ VPN Client  │  │ RDP Client    │  │ Surface   │  │   │
@ -273,25 +273,25 @@ name = "Customer D"
 auto_workspace = true
 ```

-### Gateway Management via wayray-ctl
+### Gateway Management via wradm

 ```bash
 # List configured gateways
-wayray-ctl gateway list
+wradm gateway list

 # Connect to a gateway
-wayray-ctl gateway connect customer-d
+wradm gateway connect customer-d

 # Status of active gateways
-wayray-ctl gateway status
+wradm gateway status
 # customer-d: connected (VPN: up, RDP: 3 windows active)
 # customer-b: connected (WayRay federation: 2 apps)

 # Disconnect
-wayray-ctl gateway disconnect customer-d
+wradm gateway disconnect customer-d

 # Import a gateway profile (shared by team lead / IT admin)
-wayray-ctl gateway import customer-d.toml
+wradm gateway import customer-d.toml
 ```

 ### Network Isolation
@ -375,14 +375,14 @@ Putting it all together:
        → Workspace 1: "My Desktop" with email, chat, docs

 09:00 - Customer B maintenance window
-        → wayray-ctl gateway connect customer-b
+        → wradm gateway connect customer-b
        → VPN tunnel establishes automatically
        → Workspace 2 appears: "Customer B"
        → SAP GUI and monitoring console open seamlessly
        → Fix the issue, close the ticket in customer's Jira

 10:30 - Disconnect Customer B
-        → wayray-ctl gateway disconnect customer-b
+        → wradm gateway disconnect customer-b
        → VPN torn down, workspace closes
        → Back to Workspace 1

--- a/docs/ai/plans/001-implementation-roadmap.md
+++ b/docs/ai/plans/001-implementation-roadmap.md
@ -3,7 +3,7 @@
 ## Phase 0: Foundation (Weeks 1-2)

 ### 0.1 Project Structure
- Set up Cargo workspace with four crates: `wayray-server`, `wayray-client`, `wayray-protocol`, `wayray-ctl`
+- Set up Cargo workspace with four crates: `wrsrvd`, `wrclient`, `wayray-protocol`, `wradm`
 - Configure shared dependencies, feature flags, CI (Linux + illumos)
 - Set up tracing/logging infrastructure with miette error handling
 - Smithay with `default-features = false` + portable features only in core
@ -30,8 +30,8 @@
 - Version negotiation and capability exchange

 ### 1.2 QUIC Transport Layer
- Implement QUIC server (quinn) in wayray-server
- Implement QUIC client (quinn) in wayray-client
+- Implement QUIC server (quinn) in wrsrvd
+- Implement QUIC client (quinn) in wrclient
 - Stream mapping:
  - Stream 0: Control channel (session mgmt, capabilities)
  - Stream 1: Display channel (frame updates, damage regions)
@ -52,7 +52,7 @@
 ## Phase 2: Client Viewer (Weeks 5-7)

 ### 2.1 Display Client
- Implement wayray-client as a standalone application
+- Implement wrclient as a standalone application
 - Use winit + wgpu for cross-platform display
 - Frame decoding pipeline: receive -> decompress -> decode -> upload to GPU -> display
 - Double-buffered rendering with VSync
@ -78,7 +78,7 @@
 - Generate Rust bindings via wayland-scanner

 ### 2.5.2 WM Protocol Server (in compositor)
- Implement WM global in wayray-server
+- Implement WM global in wrsrvd
 - Window lifecycle events (new, closed, properties)
 - Manage phase: receive policy decisions, send configures
 - Render phase: apply positions/z-order atomically
@ -91,7 +91,7 @@
 - Yields to external WM on connect

 ### 2.5.4 Example Tiling WM
- Ship a reference tiling WM as a separate binary (`wayray-wm-tiling`)
+- Ship a reference tiling WM as a separate binary (`wr-wm-tiling`)
 - Demonstrates the protocol for third-party WM developers
 - Basic BSP tiling with keyboard-driven focus

@ -104,12 +104,12 @@

 ### 3.2 Greeter and Session Launch
 - Define session launcher interface (events over Unix socket: session_requested, session_authenticated, session_logout)
- Implement reference session launcher (`wayray-session-launcher`) that:
+- Implement reference session launcher (`wrsessd`) that:
  - Receives "new session needed" events from WayRay
  - Creates user environment (delegates to PAM, system tools)
  - Starts WayRay compositor session for the user
  - Launches greeter as first Wayland client
- Implement reference greeter (`wayray-greeter`) as a Wayland client:
+- Implement reference greeter (`wrlogin`) as a Wayland client:
  - Login form (username + password)
  - Authenticates via PAM through session launcher
  - On success, session launcher starts user's configured session (WM, panel, apps)
@ -160,7 +160,7 @@
 ## Phase 5: Production Hardening (Weeks 14-17)

 ### 5.1 Platform-Specific Backends
- Linux: DRM/KMS backend for running wayray-server on hardware (optional, feature-gated)
+- Linux: DRM/KMS backend for running wrsrvd on hardware (optional, feature-gated)
 - Linux: Multi-GPU support via MultiRenderer
 - Linux: Session management via logind/libseat
 - illumos: Custom input backend for `/dev/kbd` + `/dev/mouse` (local console use)
@ -187,7 +187,7 @@
 ## Phase 6: Management & Operations (Weeks 16-20)

 ### 6.1 Administration
- CLI tool: `wayray-ctl` for server/session management
+- CLI tool: `wradm` for server/session management
 - REST API for external integration
 - Session monitoring: active sessions, resource usage, network stats

--- a/docs/architecture/overview.md
+++ b/docs/architecture/overview.md
@ -181,7 +181,7 @@ WayRay is a compositor, not a desktop environment or login system.
 | Compositor | X server (Xnewt) | Wayland (Smithay) |
 | Client Hardware | Purpose-built DTU | Any Linux/macOS/Windows device |
 | Session Mobility | Smart card | Pluggable tokens (smart card, NFC, software) |
-| Login Screen | dtlogin (X11 client) | wayray-greeter (Wayland client) |
+| Login Screen | dtlogin (X11 client) | wrlogin (Wayland client) |
 | Desktop | CDE/GNOME on X11 | Composable: pluggable WM + panel + launcher |
 | Audio | Custom ALP channel | Opus over QUIC |
 | USB Forwarding | Custom | Userspace over QUIC |