Merge pull request #58 from HueByte/dev

Dev

.github/workflows/ci.yml

@@ -14,6 +14,15 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - name: Install pinned linter
+        run: npm ci
+
       - name: Run markdownlint
         run: bash scripts/lint-markdown.sh
 

docs/articles/configuration.md

@@ -101,6 +101,23 @@ Access tokens expire after 15 minutes, refresh tokens after 30 days with rotatio
 | `Server:PublicHost` | *(empty)* | Public hostname for the directory listing (e.g. `chat.example.com:5000`) |
 | `Server:Admins` | `[]` | Array of admin usernames (e.g. `["alice", "bob"]`) |
 
+### Uploads
+
+Per-attachment size limits by kind (in megabytes) and the per-message attachment cap. An
+absent or partial `Uploads` section keeps the built-in defaults. See
+[Messages & Attachments](messages-and-attachments.md) for how kinds are detected.
+
+| Key | Default | Description |
+| --- | --- | --- |
+| `Uploads:MaxImageSizeMB` | `10` | Max size for one image attachment |
+| `Uploads:MaxAudioSizeMB` | `10` | Max size for one audio attachment |
+| `Uploads:MaxFileSizeMB` | `100` | Max size for any other attachment |
+| `Uploads:MaxAvatarSizeMB` | `2` | Max avatar upload size |
+| `Uploads:MaxAttachmentsPerMessage` | `10` | Attachments allowed on a single message |
+
+The server sizes its request-body limits from these values, so raising a limit here is all
+that's needed — no separate Kestrel tuning.
+
 ### Encryption
 
 | Key | Default | Description |

docs/articles/getting-started.md

@@ -17,7 +17,7 @@ curl -sSfL https://raw.githubusercontent.com/HueByte/EchoHub/master/scripts/inst
 To install a specific version or to a custom directory:
 
 ```bash
-curl -sSfL .../install.sh | sh -s -- --version 0.2.11
+curl -sSfL .../install.sh | sh -s -- --version 0.2.14
 curl -sSfL .../install.sh | sh -s -- --install-dir /opt/echohub
 ```
 
@@ -76,11 +76,11 @@ Then connect with any standard IRC client:
 irssi -c localhost -p 6667 -w <password> -n <username>
 ```
 
-IRC users must have an existing EchoHub account. Authentication works via `PASS`/`NICK`/`USER` or SASL PLAIN. Messages flow bidirectionally between IRC and TUI clients.
+Your nick is your EchoHub username and the server password is your account password (`PASS`/`NICK`/`USER` or SASL PLAIN). Connecting with a new username registers the account. Messages flow bidirectionally between IRC and TUI clients.
 
 For TLS, set `TlsEnabled: true`, `TlsPort: 6697`, and provide a PKCS#12 certificate path.
 
-See the [Architecture](architecture.md) page for details on how the IRC gateway integrates with the chat service.
+See the [IRC Gateway guide](irc-gateway.md) for command mapping, attachment rendering, and limitations, or [Architecture](architecture.md) for how the gateway integrates with the chat service.
 
 ## Configuration
 

docs/articles/irc-gateway.md

@@ -0,0 +1,103 @@
+# IRC Gateway
+
+Every EchoHub server can expose a second door: a built-in **IRC gateway** that speaks the
+classic IRC protocol on port 6667. Any standard IRC client — irssi, WeeChat, HexChat,
+Halloy — can join the same channels as TUI users, see the same messages, and chat with the
+same accounts. Under the hood both protocols call the same chat service, so a message sent
+from IRC appears instantly in the TUI and vice versa (see [Architecture](architecture.md)).
+
+## Enabling the gateway
+
+The gateway is off by default. Enable it in `appsettings.json` (or `Irc__Enabled=true` as an
+environment variable):
+
+```json
+{
+  "Irc": {
+    "Enabled": true,
+    "Port": 6667,
+    "TlsEnabled": false,
+    "TlsPort": 6697,
+    "TlsCertPath": "",
+    "ServerName": "echohub",
+    "Motd": "Welcome to EchoHub IRC Gateway!"
+  }
+}
+```
+
+The plaintext listener always starts on `Port`. The TLS listener on `TlsPort` starts only
+when `TlsEnabled` is `true` **and** `TlsCertPath` points to a PKCS#12 (`.pfx`) certificate.
+See the [configuration reference](configuration.md#irc-gateway) for every option.
+
+## Connecting & authentication
+
+Your IRC **nick is your EchoHub username** and your server password is your **account
+password**. Two flows are supported:
+
+```bash
+# classic PASS/NICK/USER — most clients call this the "server password"
+irssi -c chat.example.com -p 6667 -w <password> -n <username>
+```
+
+or **SASL PLAIN** (advertised via `CAP LS`), where the SASL username/password are the account
+credentials.
+
+A few things worth knowing:
+
+- **Connecting auto-registers.** If the username doesn't exist yet, the gateway creates the
+  account with that password (usernames: 3–50 chars of `a-z 0-9 _ -`; passwords: 6+ chars).
+  The very first account ever created on a server becomes the **Owner**.
+- Because of that, a typo'd password for an *existing* account fails with
+  `Username is already taken` — the gateway tried to log in, couldn't, then tried to register
+  the name. If you see that error, re-check your password.
+- Connecting without a password is rejected: `Password required. Use PASS command or SASL PLAIN.`
+
+## What maps to what
+
+| IRC | EchoHub |
+| --- | --- |
+| `JOIN #room` | Join a channel (history is replayed on join) |
+| `JOIN #room <key>` | Join a password-protected (`+k`) channel |
+| `PART` / `QUIT` | Leave channel / disconnect |
+| `LIST` | Public channels only (password-protected ones show a `[+k]` hint) |
+| `TOPIC` | Read or set the channel topic (permission-checked) |
+| `NAMES` / `WHO` | Online users in the channel |
+| `WHOIS` | Profile: display name, channels, idle time, away status |
+| `AWAY [message]` | Sets your EchoHub status to Away / back to Online |
+| `MODE #room +k <key>` / `-k` | Set / clear the channel password |
+
+Private (unlisted) channels don't appear in `LIST`, but members who know the exact name can
+still `JOIN` them. Channels are not auto-created from IRC — create them from the TUI first.
+
+## How messages look
+
+- **Attachments** arrive as labeled link lines — `[Image: photo.png] https://…`,
+  `♪ [Audio: song.mp3] https://…`, `[File: report.pdf] https://…` — and image attachments
+  additionally render their **ASCII-art preview** using truecolor ANSI escapes, so a modern
+  terminal IRC client shows actual picture previews.
+- **Link embeds** are appended as `│`-prefixed text lines.
+- Long messages are split at word boundaries into IRC-safe lines (~400 bytes each);
+  incoming messages may be up to 2,000 characters like any EchoHub message.
+- Your own messages aren't echoed back (standard IRC convention).
+- Moderation actions surface natively: kicks arrive as `KICK`, bans and channel nukes as
+  server `NOTICE`s.
+
+## Limitations
+
+The gateway bridges what IRC can express — and deliberately refuses what it can't:
+
+- **No end-to-end encrypted rooms.** Joining an [encrypted room](encrypted-rooms.md) fails
+  with *"Cannot join channel — end-to-end encrypted, use the EchoHub client."* Bridging one
+  would require the server to hold the room key, breaking the zero-knowledge design.
+- **No private messages.** `PRIVMSG` to a nick is rejected; EchoHub is channel-based.
+- **Usernames, not display names.** Messages are attributed to the account username;
+  a user's display name is visible via `WHOIS`/`WHO` (realname field).
+- **No client features.** Uploading attachments, profiles, themes, and reactions to status
+  changes are TUI-client features. Other users' status changes aren't pushed to IRC —
+  discover them with `WHOIS`/`WHO`.
+
+## How IRC users appear to TUI users
+
+Users connected *only* through the gateway are tagged `[irc]` in the users panel — a hint
+that they can't receive encrypted content or use client-side features. Someone connected
+with both an IRC client and the TUI shows untagged.

docs/articles/messages-and-attachments.md

@@ -0,0 +1,109 @@
+# Messages & Attachments
+
+An EchoHub message is **text content plus up to 10 attachments**, Discord-style. A plain chat
+line is just a message with no attachments; a photo dump is one message with several files and
+an optional caption. This page explains how to attach files, what happens to them on the way to
+the server, and how other clients receive them.
+
+## Message basics
+
+| Limit | Value |
+| --- | --- |
+| Max message length | 2,000 characters |
+| Max newlines per message | 30 (no blank-line runs) |
+| Max attachments per message | 10 |
+| Link embeds per message | first 3 URLs |
+
+Multiline messages are written with `Ctrl+N` for a newline; `Enter` sends. URLs in a message
+get link embeds (title, description, theme color) fetched by the server.
+
+## Attaching files
+
+All of these end up in the same place — the **staging tray** — and are sent together as one
+message the next time you press `Enter`, with whatever you've typed as the caption:
+
+- **Paste a copied file** — copy one *or several* files in your file manager and press
+  `Ctrl+V` in the input. All of them are staged at once.
+- **Paste an image from the clipboard** — copy an image in a browser (right-click → *Copy
+  image*), take a screenshot (`Win+Shift+S`), or copy from an image editor, then `Ctrl+V`.
+  The image is attached directly as a PNG named `image.png` — no saving to disk first.
+  On Linux this uses `wl-paste` or `xclip`; on macOS it requires
+  [`pngpaste`](https://github.com/jcsalterego/pngpaste) (`brew install pngpaste`).
+- **Drag & drop** — drop a file onto the terminal window; the client recognizes the dropped
+  path and stages the file.
+- **`/send <filepath>`** — stage a file by path (quote paths containing spaces).
+
+The input frame's title shows what's currently staged. `/clear` drops all staged attachments
+without sending. Sending with an empty input is fine — the message is just the attachments.
+
+```text
+┌ Message (2 attached: report.pdf, image.png) ──────────────┐
+│ here's the summary and a screenshot_                      │
+└────────────────────────────────────────────────────────────┘
+```
+
+**URL sends are different:** `/send <https://…>` sends an image URL immediately as its own
+message — nothing is staged, and it isn't available in end-to-end encrypted rooms (the server
+would have to fetch the image, which would defeat the encryption).
+
+## Attachment kinds
+
+The kind is detected per attachment, not per message:
+
+| Kind | Detected by | Renders as | Default size limit |
+| --- | --- | --- | --- |
+| **Image** | Magic bytes: JPEG, PNG, GIF, WebP | ASCII-art preview in chat | 10 MB |
+| **Audio** | Extension: `.mp3` `.wav` `.ogg` `.flac` `.aac` `.m4a` `.wma` | Playable row (▶) | 10 MB |
+| **File** | Everything else | Downloadable row | 100 MB |
+
+Limits are per file and server-configurable — see the `Uploads` section in the
+[configuration guide](configuration.md) (`MaxImageSizeMB`, `MaxAudioSizeMB`, `MaxFileSizeMB`,
+`MaxAttachmentsPerMessage`).
+
+## Image previews (ASCII art)
+
+Images are rendered in chat as half-block ASCII art. You pick the rendering size:
+
+| Flag | Size | Feel |
+| --- | --- | --- |
+| `-s` / `/size s` | 40 × 40 | compact |
+| `-m` / `/size m` | 80 × 80 | default |
+| `-l` / `/size l` | 120 × 120 | detailed |
+
+`/size` with no argument opens a picker; the choice persists as your default. A one-off
+`-s|-m|-l` flag on `/send` applies to that message.
+
+## Receiving attachments
+
+Right-click a message (or press `F6` to select one with the arrow keys) for actions:
+
+- **Images** → save to disk
+- **Audio** → play (in-client playback)
+- **Files** → download
+
+Downloads go to your configured download folder — set it with `/downloadpath` (no argument
+opens a native folder picker, or pass a path directly).
+
+## Attachments in encrypted rooms
+
+In an [end-to-end encrypted room](encrypted-rooms.md) every attachment is encrypted
+client-side **before** upload:
+
+```mermaid
+flowchart LR
+    F[File bytes] -->|AES-256-GCM with room key| B[Ciphertext blob]
+    F -->|if image: render ASCII locally| A[ASCII preview]
+    A -->|room-encrypt| AP["$RC1$… preview"]
+    B --> S[Server stores blob + name + size]
+    AP --> S
+```
+
+The server never sees the file contents or the rendered preview — it stores an opaque blob and
+broadcasts it to members, who decrypt locally. File **names and sizes remain visible** to the
+server so the file list stays usable; don't put secrets in a file name. Pasted clipboard
+images go through exactly the same pipeline.
+
+## Deleting messages with attachments
+
+Deleting a message also removes its uploaded attachment files from the server. You can always
+delete your own messages; moderators can delete others' — see [Moderation & Roles](moderation.md).

docs/articles/moderation.md

@@ -0,0 +1,71 @@
+# Moderation & Roles
+
+Every EchoHub server has a four-tier role hierarchy. Moderation is **strictly hierarchical**:
+acting on another user requires outranking them — equal rank is never enough — and a few
+invariants protect the server owner from lockouts.
+
+## Roles
+
+| Role | Rank | Users panel glyph | How it's granted |
+| --- | --- | --- | --- |
+| **Owner** | 3 | ★ | The first account ever registered on the server |
+| **Admin** | 2 | ♦ | Assigned by the Owner |
+| **Mod** | 1 | ❀ | Assigned by an Admin or the Owner |
+| **Member** | 0 | — | Everyone else |
+
+Assign roles with `/role <user> <admin|mod|member>`. Two rules apply:
+
+- You can only assign roles **strictly below your own** — an Admin can promote to Mod but
+  cannot create another Admin; only the Owner can.
+- **Owner is not assignable and not demotable.** There is exactly one Owner (the first
+  account), nobody can be promoted to it, and the Owner's role can't be changed.
+
+## Actions
+
+| Command | Minimum role | Effect |
+| --- | --- | --- |
+| `/kick <user> [reason]` | Mod | Disconnects the user. Not persistent — they can reconnect immediately. |
+| `/ban <user> [reason]` | Admin | Persistent: flags the account banned and disconnects it. Banned accounts are rejected at login. |
+| `/unban <user>` | Admin | Lifts a ban. |
+| `/mute <user> [minutes]` | Mod | Blocks the user from sending messages or uploading files. Without a duration the mute is **indefinite**; with one it auto-expires (checked every ~15 seconds). |
+| `/unmute <user>` | Mod | Lifts a mute early. |
+| `/role <user> <role>` | Admin | Assign a role (see rules above). |
+| `/nuke` | Mod | Deletes the **entire history of the current channel**, including all attachment files on disk. Channel-wide — no per-user check. |
+
+Kick, ban, and mute all enforce the hierarchy: the target's role must be **strictly lower**
+than yours. A Mod cannot kick another Mod; nobody can kick, ban, mute, or demote the Owner.
+
+## Deleting messages
+
+Deletion has its own, slightly different rule set:
+
+- **Your own messages** — always deletable, whatever your role. Right-click a message →
+  *Delete message*, or press `F6`, pick the message, and hit `Delete`.
+- **Someone else's messages** — requires **Mod or higher** *and* strictly outranking the
+  author. A Mod can delete a Member's message, but not another Mod's.
+
+Deleting a message also purges its uploaded attachment blobs from the server's disk, and the
+removal is broadcast live — the message disappears from everyone's chat immediately.
+
+## How actions surface
+
+Everyone in the channel sees moderation happen:
+
+- **TUI clients** show system messages — *"alice was kicked (reason)"*, *"bob was banned"*,
+  *"Channel history has been cleared by a moderator."* The kicked or banned user themselves
+  gets a dialog with the reason, then the client disconnects.
+- **IRC clients** get native protocol events: kicks arrive as a real `KICK` command, bans as
+  a server `NOTICE`. (See the [IRC Gateway guide](irc-gateway.md).)
+
+Muted users aren't announced; they simply receive *"You are muted and cannot send messages."*
+when they try to speak.
+
+## Design notes
+
+- All checks run server-side in the moderation API — the client commands are conveniences,
+  and the same rules bind IRC users and any direct API caller.
+- Bans are account-level, not IP-level. A banned person can register a fresh account; pair
+  bans with registration hygiene on public servers.
+- In [end-to-end encrypted rooms](encrypted-rooms.md) moderation still works at the metadata
+  level — messages can be deleted and users muted/kicked by identity — but no moderator can
+  *read* the content, including the Owner.

docs/articles/toc.yml

@@ -2,6 +2,14 @@
   items:
     - name: Getting Started
       href: getting-started.md
+    - name: TUI Guide
+      href: tui-guide.md
+    - name: Messages & Attachments
+      href: messages-and-attachments.md
+    - name: Moderation & Roles
+      href: moderation.md
+    - name: IRC Gateway
+      href: irc-gateway.md
     - name: Docker
       href: docker.md
     - name: Architecture

docs/articles/tui-guide.md

@@ -0,0 +1,116 @@
+# TUI Guide
+
+Everything you can do in the EchoHub terminal client: keyboard shortcuts, mouse actions,
+slash commands, themes, and the everyday behaviors (unread markers, auto-join, scrollback)
+that make it feel like a proper IRC-era client with modern comforts.
+
+## Layout
+
+```text
+┌ Menu bar ──────────────────────────────────────────────────┐
+│ ┌ Channels ─┐ ┌ Messages ────────────────────┐ ┌ Users ──┐ │
+│ │ #general 3│ │ 12:01 <alice> hi             │ │ ★ alice │ │
+│ │ #dev      │ │ ── new messages ──           │ │ ❀ bob   │ │
+│ │ #random*~ │ │ 12:04 <bob> anyone around?   │ │ carol   │ │
+│ └───────────┘ └──────────────────────────────┘ │ d [irc] │ │
+│ ┌ Message │ Enter=send │ Tab=complete │ … ────┐ └─────────┘ │
+│ │ _                                           │             │
+│ └─────────────────────────────────────────────┘             │
+│ Status: Connected │ v0.2.14 │ alice │ Act: #dev             │
+└─────────────────────────────────────────────────────────────┘
+```
+
+Channel list markers: `*` = password-protected, `~` = private (unlisted), plus unread counts
+(orange when you were @mentioned). Users panel glyphs: `★` Owner, `♦` Admin, `❀` Mod,
+`[irc]` for IRC-gateway-only users; status icons `●`/`○`/`◐`/`◌` for online/offline/away/dnd.
+
+## Keyboard shortcuts
+
+### In the message input
+
+| Key | Action |
+| --- | --- |
+| `Enter` | Send the message (also sends staged attachments with the text as caption) |
+| `Ctrl+N` | Insert a newline (multiline message) |
+| `Tab` | Autocomplete a slash command (`/th` → `/theme`) |
+| `Ctrl+V` (or `Ctrl+Y`) | Paste — copied files and images become attachments, text pastes normally ([details](messages-and-attachments.md)) |
+| `Ctrl+C` / `Ctrl+X` | Copy / cut in the input |
+| `Ctrl+W` | Delete the word left of the cursor |
+| `Ctrl+K` | Open the search palette |
+| `F6` | Move focus into the message list |
+
+### In the message list (after `F6`)
+
+| Key | Action |
+| --- | --- |
+| `↑` / `↓` | Select a message |
+| `Enter` | Activate: play/download/save an attachment, open an `@mention`'s profile, join a `#channel`, or open the sender's profile |
+| `Delete` / `Backspace` | Delete the selected message (with confirmation; [permission rules](moderation.md)) |
+| `F6` | Return focus to the input |
+
+### Anywhere
+
+| Key | Action |
+| --- | --- |
+| `F2` | Toggle the users panel |
+| `Ctrl+K` | Search palette |
+| `Alt+Q` | Quit |
+
+## The search palette (`Ctrl+K`)
+
+A command-palette that searches **channels and app actions** — type to filter, `↓` to
+navigate, `Enter` to jump. Actions include Connect, Disconnect, Logout, My Profile,
+Set Status, Create/Delete Channel, Saved Servers, Toggle Users Panel, Check for Updates,
+and Quit. `Ctrl+K` again closes it.
+
+## Mouse
+
+- **Right-click a message** for the context menu: save image / play audio / download file
+  (depending on the attachment), *Mention @user*, *View profile*, *Copy text*,
+  *Copy message ID*, *Delete message*.
+- **Left-click a message** does the most useful thing for that line: attachments
+  play/download/save, `@mentions` and the sender open profiles, `#channel` references join
+  that channel.
+- **Click a user** in the users panel to open their profile; **click a channel** to switch.
+
+## Slash commands
+
+Type `/help` in any channel for the full list. The highlights:
+
+| Command | What it does |
+| --- | --- |
+| `/status <online\|away\|dnd\|invisible>` or `/status <message>` | Presence / status message |
+| `/nick <name>`, `/color <#hex>`, `/avatar <url or path>` | Display name, nick color, avatar |
+| `/theme <name>` | Switch theme |
+| `/send`, `/clear`, `/size`, `/downloadpath` | Attachments — see [Messages & Attachments](messages-and-attachments.md) |
+| `/join <channel> [password]`, `/leave`, `/topic <text>` | Channel membership and topic |
+| `/passwd <old> <new>` | Rotate an encrypted room's passphrase |
+| `/profile [user]`, `/users`, `/meta` | Profiles, online users, room info |
+| `/kick`, `/ban`, `/mute`, `/role`, `/nuke`, … | [Moderation](moderation.md) |
+| `/servers`, `/quit` | Saved servers, exit |
+
+Emoji shortcodes (`:smile:` style) are replaced live as you type.
+
+## Themes
+
+14 built-in themes: **Default, Transparent, TransparentLight, Classic, Light, Hacker,
+Solarized, Dracula, Monokai, Nord, Gruvbox, Ocean, HighContrast, RosePine** — switch from
+the User menu or `/theme <name>`. The two *Transparent* themes use no background color at
+all, so your terminal's own background (and any blur/acrylic) shows through.
+
+You can add your own: drop a theme JSON into `~/.echohub/themes/` and it appears in the list
+(names that collide with a built-in are skipped).
+
+## Everyday behaviors
+
+- **Unread markers** — a `── new messages ──` rule marks where you left off in each channel,
+  irssi-style. Read positions are **persisted per server**, so the marker survives
+  reconnects and restarts. The status bar's `Act:` segment lists channels with activity
+  (orange when you were @mentioned), and day boundaries draw a date rule.
+- **Auto-join** — connecting joins `#general` plus every channel you're a member of, so
+  unread counts and mentions accumulate everywhere. Channels you `/leave` stay left, and
+  password-protected or [encrypted rooms](encrypted-rooms.md) are never auto-prompted —
+  join those explicitly. `#general` is the home channel and can't be left or deleted.
+- **Scrollback** — history loads 100 messages at a time; scrolling to the top of a channel
+  fetches the next page and keeps your position (no jump).
+- **Drag & drop** — dropping a file onto the window stages it as an attachment.

docs/auriondocs/index.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>AurionDocs</title>
+  <style>
+    body { font-family: system-ui, sans-serif; display: grid; place-items: center; min-height: 100vh; margin: 0; background: #1a1a1e; color: #ddd; }
+    main { text-align: center; }
+    a { color: #7aa2f7; }
+  </style>
+</head>
+<body>
+  <main>
+    <h1>AurionDocs</h1>
+    <p>Supplementary documentation for EchoHub.</p>
+    <p><a href="../index.html">&larr; Back to EchoHub documentation</a></p>
+  </main>
+</body>
+</html>

docs/changelog/index.md

@@ -4,6 +4,7 @@ Release history for EchoHub.
 
 ## Releases
 
+- [v0.2.14](v0.2.14.md) - Clipboard Image & Multi-File Paste, E2E Room Unlock Fixes, Encrypted Key Cache & IRC Gateway Polish
 - [v0.2.13](v0.2.13.md) - Chat Visual Overhaul, Auto-Join All Channels & Persistent Read Positions
 - [v0.2.12](v0.2.12.md) - End-to-End Encrypted Channels, IRC Channel Keys, Image Save & Ctrl+W Crash Fix
 - [v0.2.11](v0.2.11.md) - EchoHubSpace Auth, Live Directory Updates & Server Browser Metadata

docs/changelog/toc.yml

@@ -1,5 +1,7 @@
 - name: Overview
   href: index.md
+- name: v0.2.14
+  href: v0.2.14.md
 - name: v0.2.13
   href: v0.2.13.md
 - name: v0.2.12

docs/changelog/v0.2.14.md

@@ -0,0 +1,22 @@
+# v0.2.14
+
+A reliability and security pass over end-to-end encrypted rooms: locked channels now offer the passphrase prompt instead of dead-ending on the "rejoin to unlock" placeholder, the client can no longer be tricked into sending plaintext into an encrypted room, and cached room keys are encrypted at rest instead of sitting in the config as base64. Ctrl+V grows up too — images copied from a browser or screenshot tool paste straight into the chat as attachments, and copying several files pastes them all into one message. Plus a set of IRC gateway fixes — decrypted image previews, display-name plumbing, and user/channel indicators.
+
+## New Features
+
+- **Paste images straight from the clipboard** — copy an image from a browser, a screenshot tool (Win+Shift+S), or an image editor and Ctrl+V it into the input: it's attached as a PNG (`image.png`), no saving to disk first, Discord-style. Transparency is preserved when the source provides PNG data; plain clipboard bitmaps are converted automatically. On Linux this uses `wl-paste`/`xclip`; on macOS it requires `pngpaste`. In end-to-end encrypted rooms pasted images go through the same client-side encryption as any other attachment.
+- **Multi-file paste** — copying several files in your file manager and pasting attaches them all to a single message (up to the 10-attachment cap), staged as one batch alongside anything you type as the caption. Previously each pasted file was routed through its own `/send`, which could misbehave on large batches.
+- **Room keys encrypted at rest** — the per-channel room keys cached so you don't retype a passphrase every launch are no longer stored as plain base64 in `config.json`. On Windows they're protected with DPAPI (current-user scope); on Linux/macOS with AES-GCM under a per-user key file created with `0600` permissions next to the config. Existing plain entries migrate to the encrypted format automatically on first load. The passphrase itself is never stored in any form.
+- **`[irc]` tag in the users panel** — users online only through the IRC gateway are tagged `[irc]`, useful context since IRC clients lack encryption, attachments, and profiles. Someone also running the TUI shows untagged.
+- **`~` marker for private channels** — the channel list now marks private (unlisted) channels with a trailing `~`, alongside the existing `*` for password-protected ones (`#room*~` when both apply).
+
+## Bug Fixes
+
+- **Locked encrypted channels now prompt for the passphrase.** Auto-joining your channels at connect silently entered end-to-end encrypted rooms you're a member of without running the unlock flow — on a new device (or after a cancelled prompt) the room showed only `[encrypted — rejoin this channel with its passphrase to unlock]` placeholders, and only a manual `/join` recovered it. Selecting the channel now offers the passphrase prompt; entering it unlocks history and live messages in place. Cancelling is remembered for the session so reselecting the channel doesn't nag — `/join` or trying to send always re-offers the prompt.
+- **A stale cached room key no longer beats a fresh one.** If an encrypted channel was deleted and recreated under the same name, a client that still had the old key cached kept encrypting messages nobody else could read. Typing the passphrase on join now always adopts the key from the server's current envelope, replacing the stale cache.
+- **IRC clients no longer get flooded with ciphertext for image messages.** The gateway forwarded image ASCII previews without stripping transport encryption, spamming IRC clients with one enormous `$ENC$v1$…` line per image. Previews are now decrypted before formatting, and any that still can't be read (e.g. end-to-end room ciphertext the server cannot decrypt) are skipped in favor of the plain `[Image: name] url` line.
+- **Display names now show on chat messages.** Messages only carried the sender's username, so a configured display name appeared in the user list but not on the messages themselves. Live messages, history, and attachment messages now all carry it; mention and profile lookups stay keyed to the username.
+
+## Security
+
+- **No plaintext can leak into an encrypted room.** Previously, a client without the room key silently sent unencrypted text into an end-to-end encrypted channel (and other members saw it as a normal message, none the wiser it went over the wire readable by the server). All send paths — typed messages, staged file attachments, and URL sends — are now blocked while a room is locked: the client offers the unlock prompt, keeps staged files in the tray, and refuses to transmit until the key is present, with a hard guard at the connection layer as backstop.

docs/docfx.json

@@ -46,7 +46,7 @@
     "content": [
       {
         "files": ["**/*.{md,yml}"],
-        "exclude": ["_site/**", "_api_meta/**"]
+        "exclude": ["_site/**", "_api_meta/**", "auriondocs/**"]
       },
       {
         "src": "_api_meta/core",
@@ -75,7 +75,7 @@
     ],
     "resource": [
       {
-        "files": ["images/**"]
+        "files": ["images/**", "auriondocs/**"]
       }
     ],
     "output": "_site",

docs/index.md

@@ -11,6 +11,10 @@ Welcome to the EchoHub documentation. EchoHub is a decentralized, IRC-style chat
 ## Quick Links
 
 - [Getting Started](articles/getting-started.md) - Set up and run EchoHub
+- [TUI Guide](articles/tui-guide.md) - Keyboard shortcuts, slash commands, and everyday usage
+- [Messages & Attachments](articles/messages-and-attachments.md) - Attaching, pasting, and receiving files
+- [Encrypted Rooms](articles/encrypted-rooms.md) - End-to-end encrypted channels
+- [IRC Gateway](articles/irc-gateway.md) - Connect with any IRC client
 - [Architecture](articles/architecture.md) - System design and IRC gateway
 - [API Reference](api/index.md) - Generated C# API documentation
 - [Changelog](changelog/index.md) - Release history

docs/toc.yml

@@ -7,3 +7,5 @@
 - name: API
   href: api/
   homepage: api/index.md
+- name: AurionDocs
+  href: auriondocs/index.html

package.json

@@ -0,0 +1,12 @@
+{
+  "name": "echohub",
+  "private": true,
+  "description": "Repo tooling — markdown linting. Not an npm package.",
+  "scripts": {
+    "lint:md": "markdownlint-cli2",
+    "lint:md:fix": "markdownlint-cli2 --fix"
+  },
+  "devDependencies": {
+    "markdownlint-cli2": "^0.23.0"
+  }
+}

scripts/lint-markdown.ps1

@@ -0,0 +1,61 @@
+# EchoHub - Markdown Lint
+#
+# Runs markdownlint-cli2 over the repo. Rules, globs, and ignores all live in
+# .markdownlint-cli2.jsonc; the linter version is pinned in package.json.
+#
+# Usage:
+#   .\scripts\lint-markdown.ps1            # lint-only, exits non-zero on violations
+#   .\scripts\lint-markdown.ps1 -Fix       # auto-fix what markdownlint can
+#
+# Requires: Node + npx on PATH. Prefers the locally installed linter
+# (`npm install` once); otherwise npx fetches the same pinned version.
+
+param(
+    [switch]$Fix
+)
+
+$ErrorActionPreference = "Stop"
+
+if (-not (Get-Command npx -ErrorAction SilentlyContinue)) {
+    Write-Host "  ERROR: npx not found on PATH. Install Node.js (https://nodejs.org) and retry." -ForegroundColor Red
+    exit 1
+}
+
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$RootDir   = Split-Path -Parent $ScriptDir
+
+Push-Location $RootDir
+try {
+    # Local install is version-pinned via package.json/package-lock.json; the
+    # npx fallback pins the same version so CI and local can never drift.
+    if (Test-Path "node_modules/.bin/markdownlint-cli2") {
+        $npxArgs = @('--no-install', 'markdownlint-cli2')
+    } else {
+        $npxArgs = @('--yes', '[email protected]')
+    }
+
+    if ($Fix) {
+        Write-Host "  Auto-fix mode (--fix): markdownlint will rewrite files in place." -ForegroundColor Yellow
+        $npxArgs += '--fix'
+    }
+
+    Write-Host "  > npx $($npxArgs -join ' ')" -ForegroundColor Gray
+    & npx @npxArgs
+    $exit = $LASTEXITCODE
+
+    if ($exit -eq 0) {
+        Write-Host "  Markdown lint clean." -ForegroundColor Green
+    } elseif ($Fix) {
+        Write-Host ""
+        Write-Host "  Some issues could not be auto-fixed. Review the output above and fix manually." -ForegroundColor Yellow
+    } else {
+        Write-Host ""
+        Write-Host "  Markdown lint failed. Re-run with -Fix to auto-correct the fixable rules:" -ForegroundColor Red
+        Write-Host "    .\scripts\lint-markdown.ps1 -Fix" -ForegroundColor Yellow
+    }
+
+    exit $exit
+}
+finally {
+    Pop-Location
+}

scripts/lint-markdown.sh

@@ -2,6 +2,8 @@
 #
 # Lint all Markdown files in the repository.
 # Config, globs, and ignores are defined in .markdownlint-cli2.jsonc.
+# The linter version is pinned in package.json — run `npm install` once,
+# or just use `npm run lint:md` / `npm run lint:md:fix` directly.
 #
 # Usage:
 #   ./scripts/lint-markdown.sh          # check
@@ -12,11 +14,12 @@ set -euo pipefail
 REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$REPO_ROOT"
 
-# Resolve markdownlint-cli2 binary
+# Prefer the locally installed (version-pinned) linter; fall back to a one-off
-if command -v markdownlint-cli2 &>/dev/null; then
+# npx install of the same version pinned in package.json.
-    LINT_CMD="markdownlint-cli2"
+if [ -x "node_modules/.bin/markdownlint-cli2" ]; then
+    LINT_CMD="npx --no-install markdownlint-cli2"
 else
-    LINT_CMD="npx --yes markdownlint-cli2"
+    LINT_CMD="npx --yes markdownlint-cli2@0.23.0"
 fi
 
 echo "Linting Markdown files..."

src/Directory.Build.props

@@ -1,6 +1,6 @@
 <Project>
   <PropertyGroup>
-    <Version>0.2.13</Version>
+    <Version>0.2.14</Version>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);CS1591</NoWarn>
   </PropertyGroup>

src/EchoHub.Client/AppOrchestrator.cs

@@ -35,6 +35,14 @@ public sealed class AppOrchestrator : IDisposable
     private readonly HashSet<string> _channelsLoadingMore = new(StringComparer.OrdinalIgnoreCase);
     private readonly List<string> _stagedAttachments = [];
 
+    // Temp PNGs created for clipboard-image pastes; deleted once their message is sent
+    // (or the staging tray is cleared) so pasted screenshots don't pile up in %TEMP%.
+    private readonly HashSet<string> _tempPastedFiles = [];
+
+    // E2E channels whose unlock prompt the user cancelled — don't nag on every reselect.
+    // Cleared on connect/reconnect; an explicit /join or a send attempt re-offers the prompt.
+    private readonly HashSet<string> _declinedUnlocks = new(StringComparer.OrdinalIgnoreCase);
+
     private ClientConfig _config;
     private readonly UserSession _session = new();
 
@@ -90,6 +98,8 @@ public sealed class AppOrchestrator : IDisposable
         _mainWindow.OnDisconnectRequested += HandleDisconnect;
         _mainWindow.OnLogoutRequested += HandleLogout;
         _mainWindow.OnMessageSubmitted += HandleMessageSubmitted;
+        _mainWindow.OnFilesStaged += HandleFilesStaged;
+        _mainWindow.OnImagePasted += HandleImagePasted;
         _mainWindow.OnChannelSelected += HandleChannelSelected;
         _mainWindow.OnProfileRequested += HandleProfileRequested;
         _mainWindow.OnStatusRequested += HandleStatusRequested;
@@ -187,7 +197,8 @@ public sealed class AppOrchestrator : IDisposable
         if (Uri.TryCreate(target, UriKind.Absolute, out var uri)
             && (uri.Scheme == "http" || uri.Scheme == "https"))
         {
-            if (_conn.RoomKeys.HasKey(channel))
+            // Also blocks locked E2E channels (no cached key) — a URL send would be plaintext
+            if (_conn.RoomKeys.HasKey(channel) || _conn.RoomKeys.IsChannelEncrypted(channel))
             {
                 InvokeUI(() => _mainWindow.ShowError(
                     "Sending by URL isn't available in encrypted channels — download the file and /send it instead."));
@@ -216,11 +227,89 @@ public sealed class AppOrchestrator : IDisposable
 
     private Task HandleCmdClearAttachments()
     {
+        var temps = _stagedAttachments.Where(_tempPastedFiles.Contains).ToList();
+        _tempPastedFiles.ExceptWith(temps);
+        CleanupPastedTempFiles(temps);
+
         _stagedAttachments.Clear();
         InvokeUI(RefreshStagingTray);
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Stages a batch of local files (multi-file paste or drag-and-drop) as attachments of the
+    /// next message. Runs synchronously on the UI thread — unlike routing each file through a
+    /// fire-and-forget /send command, a 10-file paste can't race the staging list.
+    /// </summary>
+    private void HandleFilesStaged(string channel, IReadOnlyList<string> files)
+    {
+        if (!_conn.IsAuthenticated || !_conn.IsConnected)
+            return;
+
+        var slotsLeft = HubConstants.MaxAttachmentsPerMessage - _stagedAttachments.Count;
+        _stagedAttachments.AddRange(files.Take(Math.Max(0, slotsLeft)));
+
+        if (files.Count > slotsLeft)
+            _mainWindow.ShowError($"You can attach at most {HubConstants.MaxAttachmentsPerMessage} files per message.");
+
+        RefreshStagingTray();
+    }
+
+    /// <summary>
+    /// Stages an image pasted as raw clipboard data (copied from a browser, a screenshot tool,
+    /// or an image editor). The PNG is written to a per-paste temp folder so it flows through
+    /// the same path-based staging/encryption pipeline as regular files, and the temp file is
+    /// deleted once the message is sent.
+    /// </summary>
+    private void HandleImagePasted(string channel, byte[] png)
+    {
+        if (!_conn.IsAuthenticated || !_conn.IsConnected)
+            return;
+
+        if (_stagedAttachments.Count >= HubConstants.MaxAttachmentsPerMessage)
+        {
+            _mainWindow.ShowError($"You can attach at most {HubConstants.MaxAttachmentsPerMessage} files per message.");
+            return;
+        }
+
+        try
+        {
+            // A unique folder per paste keeps the Discord-style "image.png" display name
+            // while letting several pasted images coexist in one message.
+            var dir = Path.Combine(Path.GetTempPath(), "EchoHub", "pasted", Guid.NewGuid().ToString("N")[..8]);
+            Directory.CreateDirectory(dir);
+            var path = Path.Combine(dir, "image.png");
+            File.WriteAllBytes(path, png);
+
+            _tempPastedFiles.Add(path);
+            _stagedAttachments.Add(path);
+            RefreshStagingTray();
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Staging a pasted clipboard image failed");
+            _mainWindow.ShowError($"Pasting image failed: {ex.Message}");
+        }
+    }
+
+    /// <summary>Best-effort removal of pasted-image temp files and their per-paste folders.</summary>
+    private static void CleanupPastedTempFiles(IReadOnlyList<string> files)
+    {
+        foreach (var file in files)
+        {
+            try
+            {
+                File.Delete(file);
+                if (Path.GetDirectoryName(file) is { } dir)
+                    Directory.Delete(dir);
+            }
+            catch (Exception ex)
+            {
+                Log.Debug(ex, "Could not delete pasted-image temp file {File}", file);
+            }
+        }
+    }
+
     /// <summary>
     /// Opens the ASCII-art size picker (no argument) or sets it directly from "s"/"m"/"l" (or
     /// small/medium/large). The choice is a persistent preference applied to attached images.
@@ -290,24 +379,41 @@ public sealed class AppOrchestrator : IDisposable
     /// </summary>
     private void SendStagedMessage(string channel, string content)
     {
-        var staged = _stagedAttachments.ToList();
-        _stagedAttachments.Clear();
-        InvokeUI(RefreshStagingTray);
-
-        var hasRoomKey = _conn.RoomKeys.TryGetKey(channel, out var roomKey);
         var size = _config.DefaultAsciiSize;
 
         RunAsync(async () =>
         {
-            var outgoing = new List<OutgoingAttachment>();
+            // Locked E2E channel: block the send and keep the files staged for after the unlock
-            foreach (var path in staged)
+            if (!await EnsureRoomUnlockedForSendAsync(channel))
-                outgoing.Add(await BuildOutgoingAttachmentAsync(path, hasRoomKey ? roomKey : null, size));
+                return;
 
-            var wireContent = hasRoomKey && !string.IsNullOrEmpty(content)
+            var staged = _stagedAttachments.ToList();
-                ? RoomCrypto.EncryptText(content, roomKey)
+            _stagedAttachments.Clear();
-                : content;
+            InvokeUI(RefreshStagingTray);
 
-            await _conn.Api!.SendMessageWithAttachmentsAsync(channel, wireContent, outgoing, size);
+            // Pasted clipboard images live in temp files; once this send owns them they are
+            // deleted whether the upload succeeds or fails (the tray is already cleared).
+            var tempFiles = staged.Where(_tempPastedFiles.Contains).ToList();
+            _tempPastedFiles.ExceptWith(tempFiles);
+
+            try
+            {
+                var hasRoomKey = _conn.RoomKeys.TryGetKey(channel, out var roomKey);
+
+                var outgoing = new List<OutgoingAttachment>();
+                foreach (var path in staged)
+                    outgoing.Add(await BuildOutgoingAttachmentAsync(path, hasRoomKey ? roomKey : null, size));
+
+                var wireContent = hasRoomKey && !string.IsNullOrEmpty(content)
+                    ? RoomCrypto.EncryptText(content, roomKey)
+                    : content;
+
+                await _conn.Api!.SendMessageWithAttachmentsAsync(channel, wireContent, outgoing, size);
+            }
+            finally
+            {
+                CleanupPastedTempFiles(tempFiles);
+            }
         }, "Send failed");
     }
 
@@ -417,6 +523,8 @@ public sealed class AppOrchestrator : IDisposable
         try
         {
             crypto = await _conn.Api!.GetChannelCryptoAsync(channelName);
+            if (crypto is not null)
+                _conn.RoomKeys.MarkChannelEncrypted(channelName, crypto.IsEncrypted);
         }
         catch (Exception ex)
         {
@@ -438,16 +546,20 @@ public sealed class AppOrchestrator : IDisposable
             {
                 var outcome = await _conn.JoinChannelAsync(channelName, wirePassword);
 
-                if (outcome.WrappedRoomKey is not null && !_conn.RoomKeys.HasKey(channelName))
+                if (outcome.WrappedRoomKey is not null)
                 {
-                    if (kek is not null && RoomCrypto.TryUnwrapRoomKey(outcome.WrappedRoomKey, kek, out var roomKey))
+                    // A typed passphrase always wins over the cache: unwrap the fresh envelope
+                    // and overwrite any stale key (e.g. the channel was deleted and recreated
+                    // under the same name — the old key would encrypt for nobody).
+                    if (kek is not null && _conn.RoomKeys.TryStoreFromEnvelope(channelName, outcome.WrappedRoomKey, kek))
                     {
-                        _conn.RoomKeys.StoreKey(channelName, roomKey);
+                        lock (_declinedUnlocks) _declinedUnlocks.Remove(channelName);
                         // Re-fetch so history decrypts with the now-available room key
                         return await _conn.GetHistoryAsync(channelName);
                     }
 
-                    return await UnlockRoomKeyAsync(channelName, outcome);
+                    if (!_conn.RoomKeys.HasKey(channelName))
+                        return await UnlockRoomKeyAsync(channelName, outcome);
                 }
 
                 return outcome.History;
@@ -484,12 +596,17 @@ public sealed class AppOrchestrator : IDisposable
 
             var passphrase = await prompt.Task;
             if (passphrase is null)
-                return outcome.History; // stays locked; placeholders render instead of content
+            {
+                // Stays locked; placeholders render instead of content. Remember the decline
+                // so reselecting the channel doesn't nag every time.
+                lock (_declinedUnlocks) _declinedUnlocks.Add(channelName);
+                return outcome.History;
+            }
 
             var derived = RoomCrypto.DeriveKeys(passphrase, salt);
-            if (RoomCrypto.TryUnwrapRoomKey(outcome.WrappedRoomKey, derived.KeyEncryptionKey, out var roomKey))
+            if (_conn.RoomKeys.TryStoreFromEnvelope(channelName, outcome.WrappedRoomKey, derived.KeyEncryptionKey))
             {
-                _conn.RoomKeys.StoreKey(channelName, roomKey);
+                lock (_declinedUnlocks) _declinedUnlocks.Remove(channelName);
                 return await _conn.GetHistoryAsync(channelName);
             }
 
@@ -497,6 +614,66 @@ public sealed class AppOrchestrator : IDisposable
         }
     }
 
+    /// <summary>
+    /// True when a channel is end-to-end encrypted, its room key isn't cached, and the
+    /// user hasn't already declined the unlock prompt this session.
+    /// </summary>
+    private bool NeedsUnlockPrompt(string channelName)
+    {
+        if (!_conn.RoomKeys.IsChannelEncrypted(channelName) || _conn.RoomKeys.HasKey(channelName))
+            return false;
+
+        lock (_declinedUnlocks) return !_declinedUnlocks.Contains(channelName);
+    }
+
+    /// <summary>
+    /// Unlock flow for a channel that is already hub-joined (auto-join/reconnect discard
+    /// the key envelope): rejoin — members pass the gate without a password and the join
+    /// result carries the envelope — then run the passphrase prompt. On success the
+    /// decrypted history replaces the locked placeholders. Returns true when unlocked.
+    /// </summary>
+    private async Task<bool> UnlockTrackedChannelAsync(string channelName)
+    {
+        try
+        {
+            var outcome = await _conn.JoinChannelAsync(channelName, null);
+            if (outcome.WrappedRoomKey is null)
+                return false; // not an E2E channel after all
+
+            var history = await UnlockRoomKeyAsync(channelName, outcome);
+            if (!_conn.RoomKeys.HasKey(channelName))
+                return false; // cancelled or never unwrapped
+
+            if (history is not null)
+                InvokeUI(() => _messageManager.LoadHistory(channelName, history));
+            return true;
+        }
+        catch (Exception ex)
+        {
+            Log.Warning(ex, "Unlock flow failed for #{Channel}", channelName);
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Send guard for end-to-end encrypted channels: without the cached room key nothing
+    /// may leave the client (it would be plaintext in a room others read as encrypted).
+    /// Offers the unlock prompt right away — even after an earlier decline, since the user
+    /// is actively trying to talk here. Returns true when sending is safe.
+    /// </summary>
+    private async Task<bool> EnsureRoomUnlockedForSendAsync(string channelName)
+    {
+        if (!_conn.RoomKeys.IsChannelEncrypted(channelName) || _conn.RoomKeys.HasKey(channelName))
+            return true;
+
+        if (await UnlockTrackedChannelAsync(channelName))
+            return true;
+
+        InvokeUI(() => _mainWindow.ShowError(
+            $"#{channelName} is end-to-end encrypted and locked — nothing was sent. Enter its passphrase to unlock it first."));
+        return false;
+    }
+
     /// <summary>
     /// Changes the current encrypted channel's passphrase: re-derives the join credential
     /// and re-wraps the cached room content key under the new passphrase. History is
@@ -922,6 +1099,7 @@ public sealed class AppOrchestrator : IDisposable
         _conn.Reconnected += () =>
         {
             lock (_channelUsersLock) _channelUsers.Clear();
+            lock (_declinedUnlocks) _declinedUnlocks.Clear();
             RunAsync(
                 async () => await _conn.RejoinChannelsAsync(),
                 "Failed to rejoin channels after reconnect");
@@ -970,6 +1148,7 @@ public sealed class AppOrchestrator : IDisposable
             }
 
             _session.Username = result.Login.Username;
+            lock (_declinedUnlocks) _declinedUnlocks.Clear();
 
             // Persisted last-read markers for this server — used to seed unread counts,
             // mention highlights, and "new messages" markers from the fetched histories.
@@ -1073,9 +1252,12 @@ public sealed class AppOrchestrator : IDisposable
             return;
         }
 
-        RunAsync(
+        RunAsync(async () =>
-            async () => await _conn.SendMessageAsync(channelName, content),
+        {
-            "Send failed");
+            if (!await EnsureRoomUnlockedForSendAsync(channelName))
+                return;
+            await _conn.SendMessageAsync(channelName, content);
+        }, "Send failed");
     }
 
     private void HandleDeleteMessageRequested(Guid messageId)
@@ -1112,6 +1294,12 @@ public sealed class AppOrchestrator : IDisposable
                 UpdateServerConfig(server =>
                     server.LeftChannels.RemoveAll(c => c.Equals(channelName, StringComparison.OrdinalIgnoreCase)));
             }
+            else if (NeedsUnlockPrompt(channelName))
+            {
+                // Auto-join/reconnect already hub-joined this E2E channel but discarded the
+                // key envelope — selecting it is the user's cue to unlock it.
+                await UnlockTrackedChannelAsync(channelName);
+            }
 
             try
             {

src/EchoHub.Client/Config/ClientConfig.cs

@@ -38,7 +38,8 @@ public class SavedServer
 
     /// <summary>
     /// Cached room content keys for end-to-end encrypted channels on this server,
-    /// keyed by channel name (base64). Like RefreshToken, these live only on the
+    /// keyed by channel name and encrypted at rest (see RoomKeyProtector; legacy
+    /// entries were plain base64). Like RefreshToken, these live only on the
     /// user's machine — the server never sees them.
     /// </summary>
     public Dictionary<string, string> ChannelKeys { get; set; } = [];

src/EchoHub.Client/Config/ConfigManager.cs

@@ -9,6 +9,9 @@ public static class ConfigManager
 
     private static readonly string ConfigPath = Path.Combine(ConfigDir, "config.json");
 
+    /// <summary>Directory holding the client config and local key material.</summary>
+    public static string ConfigDirectory => ConfigDir;
+
     // Load-mutate-save cycles run from both the UI thread and background tasks
     // (token refresh, room keys, last-read checkpoints) — serialize file access.
     private static readonly Lock FileLock = new();

src/EchoHub.Client/EchoHub.Client.csproj

@@ -12,6 +12,7 @@
     <PackageReference Include="Serilog" Version="4.3.1" />
     <PackageReference Include="Serilog.Settings.Configuration" Version="10.0.0" />
     <PackageReference Include="Serilog.Sinks.File" Version="7.0.0" />
+    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="10.0.3" />
     <PackageReference Include="Terminal.Gui" Version="2.0.0-develop.5043" />
   </ItemGroup>
 

src/EchoHub.Client/Services/ClipboardImage.cs

@@ -0,0 +1,257 @@
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using Serilog;
+using SixLabors.ImageSharp;
+
+namespace EchoHub.Client.Services;
+
+/// <summary>
+/// Reads raw image data from the OS clipboard (e.g. an image copied from a browser, or a
+/// Win+Shift+S screenshot), which terminals cannot paste as text. Always returns PNG bytes:
+/// clipboard PNG data is passed through, clipboard bitmaps (CF_DIB) are re-encoded.
+/// </summary>
+public static class ClipboardImage
+{
+    private static readonly byte[] PngMagic = [0x89, 0x50, 0x4E, 0x47];
+
+    public static bool TryGetPng(out byte[] png)
+    {
+        png = [];
+        try
+        {
+            if (OperatingSystem.IsWindows())
+                return TryGetWindows(out png);
+            if (OperatingSystem.IsLinux())
+                return TryGetLinux(out png);
+            if (OperatingSystem.IsMacOS())
+                return TryGetMacOS(out png);
+        }
+        catch (Exception ex)
+        {
+            Log.Warning(ex, "Reading an image from the clipboard failed");
+        }
+
+        return false;
+    }
+
+    private static bool IsPng(byte[] data) =>
+        data.Length > PngMagic.Length && data.AsSpan(0, PngMagic.Length).SequenceEqual(PngMagic);
+
+    /// <summary>
+    /// Converts clipboard DIB bytes (a BITMAPINFOHEADER/V4/V5 + optional palette/masks + pixel
+    /// data, i.e. a .bmp file without its 14-byte file header) to PNG. Returns null when the
+    /// data is malformed or not decodable as a bitmap.
+    /// </summary>
+    public static byte[]? DibToPng(byte[] dib)
+    {
+        if (dib.Length < 40)
+            return null;
+
+        var headerSize = BitConverter.ToInt32(dib, 0);
+        if (headerSize < 40 || headerSize > dib.Length)
+            return null;
+
+        var bitCount = BitConverter.ToUInt16(dib, 14);
+        var compression = BitConverter.ToUInt32(dib, 16);
+        var clrUsed = BitConverter.ToUInt32(dib, 32);
+
+        // Pixel data offset: file header + info header + color masks + palette.
+        // BI_BITFIELDS masks follow a plain 40-byte header; larger headers embed them.
+        var maskBytes = headerSize == 40 && compression == 3 ? 12
+                      : headerSize == 40 && compression == 6 ? 16
+                      : 0;
+        var paletteEntries = clrUsed != 0 ? clrUsed
+                           : bitCount <= 8 ? 1u << bitCount
+                           : 0u;
+        var pixelOffset = (uint)(14 + headerSize + maskBytes) + paletteEntries * 4;
+
+        var bmp = new byte[14 + dib.Length];
+        bmp[0] = (byte)'B';
+        bmp[1] = (byte)'M';
+        BitConverter.TryWriteBytes(bmp.AsSpan(2), (uint)bmp.Length);
+        BitConverter.TryWriteBytes(bmp.AsSpan(10), pixelOffset);
+        dib.CopyTo(bmp, 14);
+
+        try
+        {
+            using var image = Image.Load(bmp);
+            using var ms = new MemoryStream();
+            image.SaveAsPng(ms);
+            return ms.ToArray();
+        }
+        catch (Exception ex) when (ex is ImageFormatException or InvalidOperationException)
+        {
+            Log.Warning(ex, "Clipboard DIB could not be decoded as a bitmap");
+            return null;
+        }
+    }
+
+    // ── Windows: "PNG" / "image/png" registered formats, then CF_DIB ─────────
+
+    private const uint CfDib = 8;
+
+    [SupportedOSPlatform("windows")]
+    private static bool TryGetWindows(out byte[] png)
+    {
+        png = [];
+
+        // Browsers register a "PNG" (Chromium) or "image/png" (some apps) clipboard format
+        // preserving transparency; CF_DIB is synthesized by Windows for everything else
+        // (screenshots, image editors), so together these cover all image sources.
+        var pngFormat = RegisterClipboardFormatW("PNG");
+        var mimeFormat = RegisterClipboardFormatW("image/png");
+
+        var hasAny = (pngFormat != 0 && IsClipboardFormatAvailable(pngFormat))
+                  || (mimeFormat != 0 && IsClipboardFormatAvailable(mimeFormat))
+                  || IsClipboardFormatAvailable(CfDib);
+        if (!hasAny)
+            return false;
+
+        var opened = false;
+        for (var attempt = 0; attempt < 5 && !opened; attempt++)
+            opened = OpenClipboard(IntPtr.Zero);
+        if (!opened)
+            return false;
+
+        try
+        {
+            foreach (var format in new[] { pngFormat, mimeFormat })
+            {
+                if (format == 0 || !IsClipboardFormatAvailable(format))
+                    continue;
+                var data = ReadHGlobal(GetClipboardData(format));
+                if (data is not null && IsPng(data))
+                {
+                    png = data;
+                    return true;
+                }
+            }
+
+            if (IsClipboardFormatAvailable(CfDib)
+                && ReadHGlobal(GetClipboardData(CfDib)) is { } dib
+                && DibToPng(dib) is { } converted)
+            {
+                png = converted;
+                return true;
+            }
+
+            return false;
+        }
+        finally
+        {
+            CloseClipboard();
+        }
+    }
+
+    [SupportedOSPlatform("windows")]
+    private static byte[]? ReadHGlobal(IntPtr handle)
+    {
+        if (handle == IntPtr.Zero)
+            return null;
+
+        var ptr = GlobalLock(handle);
+        if (ptr == IntPtr.Zero)
+            return null;
+
+        try
+        {
+            var size = (int)GlobalSize(handle);
+            if (size <= 0)
+                return null;
+            var data = new byte[size];
+            Marshal.Copy(ptr, data, 0, size);
+            return data;
+        }
+        finally
+        {
+            GlobalUnlock(handle);
+        }
+    }
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool OpenClipboard(IntPtr hWndNewOwner);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool CloseClipboard();
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool IsClipboardFormatAvailable(uint format);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    private static extern IntPtr GetClipboardData(uint uFormat);
+
+    [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    private static extern uint RegisterClipboardFormatW(string lpszFormat);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern IntPtr GlobalLock(IntPtr hMem);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool GlobalUnlock(IntPtr hMem);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern nuint GlobalSize(IntPtr hMem);
+
+    // ── Linux: image/png via wl-paste or xclip ────────────────────────────────
+
+    [SupportedOSPlatform("linux")]
+    private static bool TryGetLinux(out byte[] png)
+    {
+        png = [];
+        var data = RunForBytes("wl-paste", ["--type", "image/png"])
+                ?? RunForBytes("xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]);
+        if (data is null || !IsPng(data))
+            return false;
+
+        png = data;
+        return true;
+    }
+
+    // ── macOS: pngpaste (brew install pngpaste), when present ────────────────
+
+    [SupportedOSPlatform("macos")]
+    private static bool TryGetMacOS(out byte[] png)
+    {
+        png = [];
+        var data = RunForBytes("pngpaste", ["-"]);
+        if (data is null || !IsPng(data))
+            return false;
+
+        png = data;
+        return true;
+    }
+
+    private static byte[]? RunForBytes(string fileName, IEnumerable<string> args)
+    {
+        var psi = new ProcessStartInfo(fileName)
+        {
+            RedirectStandardOutput = true,
+            RedirectStandardError = true,
+            UseShellExecute = false,
+            CreateNoWindow = true,
+        };
+        foreach (var arg in args)
+            psi.ArgumentList.Add(arg);
+
+        try
+        {
+            using var process = Process.Start(psi);
+            if (process is null)
+                return null;
+
+            using var ms = new MemoryStream();
+            process.StandardOutput.BaseStream.CopyTo(ms);
+            process.WaitForExit(2000);
+            return process.ExitCode == 0 && ms.Length > 0 ? ms.ToArray() : null;
+        }
+        catch (Exception ex) when (ex is System.ComponentModel.Win32Exception or FileNotFoundException)
+        {
+            return null; // tool not installed
+        }
+    }
+}

src/EchoHub.Client/Services/ConnectionManager.cs

@@ -112,6 +112,11 @@ internal sealed class ConnectionManager : IAsyncDisposable
 
             var channels = await _apiClient.GetChannelsAsync();
 
+            // Known E2E channels — senders consult this so a client without the room
+            // key never emits plaintext into an encrypted room
+            foreach (var channel in channels)
+                _roomKeys.MarkChannelEncrypted(channel.Name, channel.IsEncrypted);
+
             // Join default channel + fetch history
             onStatus("Joining channels...");
             _joinedChannels.Clear();
@@ -296,7 +301,11 @@ internal sealed class ConnectionManager : IAsyncDisposable
         connection.OnForceDisconnect += reason => ForceDisconnected?.Invoke(reason);
         connection.OnMessageDeleted += (ch, id) => MessageDeleted?.Invoke(ch, id);
         connection.OnChannelNuked += ch => ChannelNuked?.Invoke(ch);
-        connection.OnChannelUpdated += ch => ChannelUpdated?.Invoke(ch);
+        connection.OnChannelUpdated += ch =>
+        {
+            _roomKeys.MarkChannelEncrypted(ch.Name, ch.IsEncrypted);
+            ChannelUpdated?.Invoke(ch);
+        };
         connection.OnError += msg => Error?.Invoke(msg);
         connection.OnConnectionStateChanged += status => ConnectionStatusChanged?.Invoke(status);
         connection.OnReconnected += () => Reconnected?.Invoke();

src/EchoHub.Client/Services/EchoHubConnection.cs

@@ -26,6 +26,21 @@ public sealed class ChannelPasswordRequiredException : Exception
     }
 }
 
+/// <summary>
+/// Thrown when sending into an end-to-end encrypted channel whose room key isn't cached:
+/// without the key the message would leave the client as plaintext, which must never happen.
+/// </summary>
+public sealed class RoomLockedException : Exception
+{
+    public string ChannelName { get; }
+
+    public RoomLockedException(string channelName)
+        : base($"#{channelName} is end-to-end encrypted and locked — enter its passphrase to unlock it before sending.")
+    {
+        ChannelName = channelName;
+    }
+}
+
 public sealed class EchoHubConnection : IAsyncDisposable
 {
     public const string LockedMessagePlaceholder =
@@ -167,6 +182,8 @@ public sealed class EchoHubConnection : IAsyncDisposable
                 throw new ChannelPasswordRequiredException(channelName, result.Error ?? "Channel is password protected.");
             throw new InvalidOperationException(result.Error ?? "Failed to join channel.");
         }
+        if (result.WrappedRoomKey is not null)
+            _roomKeys.MarkChannelEncrypted(channelName, true);
         return new JoinOutcome(DecryptMessages(result.History), result.EncryptionSalt, result.WrappedRoomKey);
     }
 
@@ -180,6 +197,8 @@ public sealed class EchoHubConnection : IAsyncDisposable
         // Room layer first (end-to-end, server can't read), then transport encryption
         if (_roomKeys.TryGetKey(channelName, out var roomKey))
             content = RoomCrypto.EncryptText(content, roomKey);
+        else if (_roomKeys.IsChannelEncrypted(channelName))
+            throw new RoomLockedException(channelName); // never fall through to plaintext
 
         var encrypted = _encryption.Encrypt(content);
         await _connection.InvokeAsync("SendMessage", channelName, encrypted);

src/EchoHub.Client/Services/RoomKeyProtector.cs

@@ -0,0 +1,120 @@
+using System.Security.Cryptography;
+using EchoHub.Core.Security;
+using Serilog;
+
+namespace EchoHub.Client.Services;
+
+/// <summary>
+/// Encrypts cached room content keys at rest so the client config never holds them as
+/// plain base64. Windows uses DPAPI (current-user scope, format prefix "dp1:"). On other
+/// platforms the keys are AES-GCM encrypted with a per-user master key file stored next
+/// to the config with 0600 permissions (prefix "k1:") — without an OS keychain that is
+/// file-permission-level protection, not zero-knowledge: anyone who can read both the
+/// config and the key file can recover the room keys. Values with no recognized prefix
+/// are legacy plain-base64 keys from older clients; they load once and are re-encrypted.
+/// The room passphrase itself is never stored in any form.
+/// </summary>
+public sealed class RoomKeyProtector
+{
+    public const string DpapiPrefix = "dp1:";
+    public const string KeyFilePrefix = "k1:";
+
+    private const string KeyFileName = "roomkeys.key";
+    private const int MasterKeySizeBytes = 32;
+    private const int RoomKeySizeBytes = 32;
+
+    private readonly string _keyFilePath;
+    private readonly bool _useDpapi;
+    private readonly Lock _lock = new();
+    private byte[]? _masterKey;
+
+    /// <param name="keyDirectory">Directory holding the master key file (the client config dir).</param>
+    /// <param name="useDpapi">Overrides the platform default (DPAPI on Windows) — for tests.</param>
+    public RoomKeyProtector(string keyDirectory, bool? useDpapi = null)
+    {
+        _keyFilePath = Path.Combine(keyDirectory, KeyFileName);
+        _useDpapi = useDpapi ?? OperatingSystem.IsWindows();
+    }
+
+    /// <summary>Encrypts a room key for storage in the config file.</summary>
+    public string Protect(byte[] roomKey)
+    {
+        if (_useDpapi && OperatingSystem.IsWindows())
+            return DpapiPrefix + Convert.ToBase64String(
+                ProtectedData.Protect(roomKey, null, DataProtectionScope.CurrentUser));
+
+        return KeyFilePrefix + Convert.ToBase64String(RoomCrypto.EncryptBytes(roomKey, GetMasterKey()));
+    }
+
+    /// <summary>
+    /// Decrypts a stored value back into a room key. <paramref name="wasLegacy"/> is true when
+    /// the value was an unencrypted legacy entry that should be re-persisted via
+    /// <see cref="Protect"/>. Returns false for unreadable values (wrong user/machine, missing
+    /// or regenerated key file, malformed data) — the caller drops the entry and the user can
+    /// recover it by re-entering the passphrase.
+    /// </summary>
+    public bool TryUnprotect(string stored, out byte[] roomKey, out bool wasLegacy)
+    {
+        roomKey = [];
+        wasLegacy = false;
+
+        try
+        {
+            if (stored.StartsWith(DpapiPrefix, StringComparison.Ordinal))
+            {
+                if (!OperatingSystem.IsWindows())
+                    return false; // config copied from a Windows machine
+
+                roomKey = ProtectedData.Unprotect(
+                    Convert.FromBase64String(stored[DpapiPrefix.Length..]), null, DataProtectionScope.CurrentUser);
+                return roomKey.Length > 0;
+            }
+
+            if (stored.StartsWith(KeyFilePrefix, StringComparison.Ordinal))
+            {
+                if (!File.Exists(_keyFilePath))
+                    return false;
+
+                roomKey = RoomCrypto.DecryptBytes(
+                    Convert.FromBase64String(stored[KeyFilePrefix.Length..]), GetMasterKey());
+                return roomKey.Length > 0;
+            }
+
+            // No recognized prefix — legacy plain-base64 room key from a pre-encryption client
+            roomKey = Convert.FromBase64String(stored);
+            wasLegacy = true;
+            return roomKey.Length == RoomKeySizeBytes;
+        }
+        catch (Exception ex) when (ex is FormatException or CryptographicException
+            or IOException or UnauthorizedAccessException)
+        {
+            return false;
+        }
+    }
+
+    private byte[] GetMasterKey()
+    {
+        lock (_lock)
+        {
+            if (_masterKey is not null)
+                return _masterKey;
+
+            if (File.Exists(_keyFilePath))
+            {
+                var existing = File.ReadAllBytes(_keyFilePath);
+                if (existing.Length == MasterKeySizeBytes)
+                    return _masterKey = existing;
+
+                Log.Warning("Room-key master key file has unexpected size — regenerating (previously cached keys become unreadable)");
+            }
+
+            var key = RandomNumberGenerator.GetBytes(MasterKeySizeBytes);
+            Directory.CreateDirectory(Path.GetDirectoryName(_keyFilePath)!);
+            File.WriteAllBytes(_keyFilePath, key);
+            if (!OperatingSystem.IsWindows())
+                File.SetUnixFileMode(_keyFilePath, UnixFileMode.UserRead | UnixFileMode.UserWrite);
+
+            return _masterKey = key;
+        }
+    }
+}

src/EchoHub.Client/Services/RoomKeyStore.cs

@@ -1,4 +1,5 @@
 using EchoHub.Client.Config;
+using EchoHub.Core.Security;
 using Serilog;
 
 namespace EchoHub.Client.Services;
@@ -6,14 +7,28 @@ namespace EchoHub.Client.Services;
 /// <summary>
 /// Holds room content keys for end-to-end encrypted channels: in-memory for the
 /// active session, persisted per-server in the client config (like saved sessions)
-/// so users don't retype the passphrase every launch. Keys never leave this machine.
+/// so users don't retype the passphrase every launch. Keys never leave this machine
+/// and are encrypted at rest by <see cref="RoomKeyProtector"/>. Also tracks which
+/// channels are known to be end-to-end encrypted, so senders can refuse to emit
+/// plaintext into a room whose key isn't cached yet.
 /// </summary>
 public sealed class RoomKeyStore
 {
     private readonly Dictionary<string, byte[]> _keys = new(StringComparer.OrdinalIgnoreCase);
+    private readonly HashSet<string> _encryptedChannels = new(StringComparer.OrdinalIgnoreCase);
+    private readonly RoomKeyProtector _protector;
     private readonly Lock _lock = new();
     private string? _serverUrl;
 
+    public RoomKeyStore() : this(new RoomKeyProtector(ConfigManager.ConfigDirectory))
+    {
+    }
+
+    public RoomKeyStore(RoomKeyProtector protector)
+    {
+        _protector = protector;
+    }
+
     /// <summary>Binds the store to a server and loads that server's cached keys from config.</summary>
     public void LoadForServer(string serverUrl)
     {
@@ -21,21 +36,34 @@ public sealed class RoomKeyStore
         {
             _serverUrl = serverUrl;
             _keys.Clear();
+            _encryptedChannels.Clear();
 
             var server = FindServer(ConfigManager.Load(), serverUrl);
             if (server is null) return;
 
-            foreach (var (channel, base64) in server.ChannelKeys)
+            var legacyFound = false;
+            foreach (var (channel, stored) in server.ChannelKeys)
             {
-                try
+                if (_protector.TryUnprotect(stored, out var key, out var wasLegacy))
                 {
-                    _keys[channel] = Convert.FromBase64String(base64);
+                    _keys[channel] = key;
+                    legacyFound |= wasLegacy;
                 }
-                catch (FormatException)
+                else
                 {
-                    Log.Warning("Ignoring malformed cached room key for #{Channel}", channel);
+                    Log.Warning("Ignoring unreadable cached room key for #{Channel}", channel);
                 }
             }
+
+            // One-way upgrade: legacy plain-base64 entries get re-persisted encrypted
+            // (unreadable entries drop out — the unlock prompt recovers those rooms).
+            if (legacyFound)
+                Persist(s =>
+                {
+                    s.ChannelKeys.Clear();
+                    foreach (var (channel, key) in _keys)
+                        s.ChannelKeys[channel] = _protector.Protect(key);
+                });
         }
     }
 
@@ -62,10 +90,26 @@ public sealed class RoomKeyStore
         lock (_lock)
         {
             _keys[channelName] = key;
-            Persist(server => server.ChannelKeys[channelName] = Convert.ToBase64String(key));
+            _encryptedChannels.Add(channelName);
+            Persist(server => server.ChannelKeys[channelName] = _protector.Protect(key));
         }
     }
 
+    /// <summary>
+    /// Unwraps a fresh key envelope and caches the key, overwriting any stale cached key
+    /// (e.g. the channel was deleted and recreated under the same name, so the old key
+    /// would encrypt messages nobody else can read). Returns false when the KEK doesn't
+    /// open the envelope — the cache is left untouched.
+    /// </summary>
+    public bool TryStoreFromEnvelope(string channelName, string wrappedRoomKey, byte[] kek)
+    {
+        if (!RoomCrypto.TryUnwrapRoomKey(wrappedRoomKey, kek, out var roomKey))
+            return false;
+
+        StoreKey(channelName, roomKey);
+        return true;
+    }
+
     public void RemoveKey(string channelName)
     {
         lock (_lock)
@@ -75,11 +119,36 @@ public sealed class RoomKeyStore
         }
     }
 
+    /// <summary>
+    /// Records whether a channel is end-to-end encrypted (from channel listings, crypto
+    /// metadata, or join outcomes). Senders consult this to block plaintext into rooms
+    /// whose key isn't cached.
+    /// </summary>
+    public void MarkChannelEncrypted(string channelName, bool isEncrypted)
+    {
+        lock (_lock)
+        {
+            if (isEncrypted)
+                _encryptedChannels.Add(channelName);
+            else
+                _encryptedChannels.Remove(channelName);
+        }
+    }
+
+    public bool IsChannelEncrypted(string channelName)
+    {
+        lock (_lock)
+        {
+            return _encryptedChannels.Contains(channelName);
+        }
+    }
+
     public void Clear()
     {
         lock (_lock)
         {
             _keys.Clear();
+            _encryptedChannels.Clear();
             _serverUrl = null;
         }
     }

src/EchoHub.Client/UI/Chat/ChatMessageManager.cs

@@ -381,6 +381,9 @@ public sealed class ChatMessageManager
     private List<ChatLine> FormatMessage(MessageDto message)
     {
         var time = FormatTime(message.SentAt);
+        // Show the display name, but keep color + click identity keyed to the username
+        // so they stay consistent with the user list and profile lookups.
+        var senderName = message.SenderDisplayName ?? message.SenderUsername;
         var senderColor = HexColorHelper.ParseHexColor(message.SenderNicknameColor)
             ?? NickColorHelper.GetAttribute(message.SenderUsername);
 
@@ -394,7 +397,7 @@ public sealed class ChatMessageManager
             var displayContent = EmojiHelper.ReplaceEmoji(message.Content);
             var contentLines = displayContent.Split('\n');
 
-            var header = HeaderSegments(time, message.SenderUsername, senderColor);
+            var header = HeaderSegments(time, senderName, senderColor);
             header.AddRange(ChatColors.SplitMentions(contentLines[0].TrimEnd('\r')));
             lines.Add(new ChatLine(header));
 
@@ -413,7 +416,7 @@ public sealed class ChatMessageManager
                 1 => $"[{attachments[0].Kind.ToString().ToLowerInvariant()}]",
                 _ => $"[{attachments.Count} attachments]",
             };
-            var header = HeaderSegments(time, message.SenderUsername, senderColor);
+            var header = HeaderSegments(time, senderName, senderColor);
             header.Add(new(summary, null));
             lines.Add(new ChatLine(header));
         }

src/EchoHub.Client/UI/ListSources/ChannelListSource.cs

@@ -18,6 +18,7 @@ public class ChannelListSource : IListDataSource
     private readonly Dictionary<string, int> _unreadCounts = [];
     private readonly HashSet<string> _protectedChannels = [];
     private readonly HashSet<string> _mentionChannels = [];
+    private readonly HashSet<string> _privateChannels = [];
     private string _activeChannel = string.Empty;
 
     public event NotifyCollectionChangedEventHandler? CollectionChanged;
@@ -32,7 +33,8 @@ public class ChannelListSource : IListDataSource
     private static readonly Attribute MentionAttr = new(new Color(230, 140, 60), Color.None);
 
     public void Update(List<string> channels, Dictionary<string, int> unread, string activeChannel,
-        IReadOnlySet<string>? protectedChannels = null, IReadOnlySet<string>? mentionChannels = null)
+        IReadOnlySet<string>? protectedChannels = null, IReadOnlySet<string>? mentionChannels = null,
+        IReadOnlySet<string>? privateChannels = null)
     {
         _channelNames.Clear();
         _channelNames.AddRange(channels);
@@ -45,6 +47,9 @@ public class ChannelListSource : IListDataSource
         _mentionChannels.Clear();
         if (mentionChannels is not null)
             _mentionChannels.UnionWith(mentionChannels);
+        _privateChannels.Clear();
+        if (privateChannels is not null)
+            _privateChannels.UnionWith(privateChannels);
         _activeChannel = activeChannel;
         MaxItemLength = channels.Count > 0 ? channels.Max(c => c.Length + 6) : 0;
         if (!SuspendCollectionChangedEvent)
@@ -67,8 +72,12 @@ public class ChannelListSource : IListDataSource
         var normalAttr = listView.GetAttributeForRole(VisualRole.Normal);
         var focusAttr = listView.GetAttributeForRole(VisualRole.Focus);
         var prefix = isActive ? "> " : "  ";
-        // Trailing * marks password-protected (+k) channels
+        // Trailing * marks password-protected (+k) channels; ~ marks private (unlisted) ones
-        var channelText = _protectedChannels.Contains(name) ? $"#{name}*" : $"#{name}";
+        var channelText = $"#{name}";
+        if (_protectedChannels.Contains(name))
+            channelText += "*";
+        if (_privateChannels.Contains(name))
+            channelText += "~";
         var badge = hasUnread ? $" ({unread})" : "";
 
         // Resolve Transparent backgrounds to the view's actual background

src/EchoHub.Client/UI/MainWindow.cs

@@ -11,6 +11,7 @@ using Serilog;
 using Terminal.Gui.App;
 using Terminal.Gui.Configuration;
 using Terminal.Gui.Drawing;
+using Terminal.Gui.Drivers;
 using Terminal.Gui.Input;
 using Terminal.Gui.Text;
 using Terminal.Gui.ViewBase;
@@ -41,23 +42,24 @@ public sealed partial class MainWindow : Runnable
     private bool _usersPanelVisible = true;
     private const int UsersPanelWidth = 22;
     private const string DefaultInputTitle = "Message │ Enter=send │ Tab=complete │ Ctrl+K=search │ F6=pick message";
-    private static readonly Key F2Key = Key.F2;
+    private const KeyCode F2Key = KeyCode.F2;
     private bool _hasStagedAttachments;
 
     internal static readonly string AppVersion =
         typeof(MainWindow).Assembly.GetName().Version?.ToString(3) ?? "?";
 
-    // Cached Key constants — compare via .KeyCode to avoid Key.Equals (which also checks Handled)
+    // Key bindings as KeyCode constants: comparing raw KeyCodes avoids Key.Equals (which also
-    private static readonly Key EnterKey = Key.Enter;
+    // checks Handled), and constants make them usable as switch case labels.
-    private static readonly Key NewlineKey = Key.N.WithCtrl;
+    private const KeyCode EnterKey = KeyCode.Enter;
-    private static readonly Key AltQKey = Key.Q.WithAlt;
+    private const KeyCode NewlineKey = KeyCode.N | KeyCode.CtrlMask;
-    private static readonly Key TabKey = Key.Tab;
+    private const KeyCode AltQKey = KeyCode.Q | KeyCode.AltMask;
-    private static readonly Key CtrlKKey = Key.K.WithCtrl;
+    private const KeyCode TabKey = KeyCode.Tab;
-    private static readonly Key CtrlVKey = Key.V.WithCtrl;
+    private const KeyCode CtrlKKey = KeyCode.K | KeyCode.CtrlMask;
-    private static readonly Key CtrlXKey = Key.X.WithCtrl;
+    private const KeyCode CtrlVKey = KeyCode.V | KeyCode.CtrlMask;
-    private static readonly Key CtrlCKey = Key.C.WithCtrl;
+    private const KeyCode CtrlXKey = KeyCode.X | KeyCode.CtrlMask;
-    private static readonly Key CtrlYKey = Key.Y.WithCtrl;
+    private const KeyCode CtrlCKey = KeyCode.C | KeyCode.CtrlMask;
-    private static readonly Key F6Key = Key.F6;
+    private const KeyCode CtrlYKey = KeyCode.Y | KeyCode.CtrlMask;
+    private const KeyCode F6Key = KeyCode.F6;
 
     // Available slash commands for Tab autocomplete
     private static readonly string[] SlashCommands =
@@ -87,6 +89,18 @@ public sealed partial class MainWindow : Runnable
     /// </summary>
     public event Action<string, string>? OnMessageSubmitted;
 
+    /// <summary>
+    /// Fired when local files arrive via paste or drag-and-drop to be staged as attachments.
+    /// Parameters: channel name, absolute paths of existing files.
+    /// </summary>
+    public event Action<string, IReadOnlyList<string>>? OnFilesStaged;
+
+    /// <summary>
+    /// Fired when raw image data is pasted from the clipboard (e.g. copied from a browser or a
+    /// screenshot tool). Parameters: channel name, PNG-encoded image bytes.
+    /// </summary>
+    public event Action<string, byte[]>? OnImagePasted;
+
     /// <summary>
     /// Fired when the user requests to connect via the menu.
     /// </summary>
@@ -557,7 +571,7 @@ public sealed partial class MainWindow : Runnable
     private void OnMessageListKeyDown(object? sender, Key e)
     {
         // F6 returns focus to the input box.
-        if (e.KeyCode == F6Key.KeyCode)
+        if (e.KeyCode == F6Key)
         {
             _inputField.SetFocus();
             e.Handled = true;
@@ -703,66 +717,69 @@ public sealed partial class MainWindow : Runnable
 
     private void OnInputKeyDown(object? sender, Key e)
     {
-        if (e.KeyCode == TabKey.KeyCode)
+        switch (e.KeyCode)
         {
-            TryAutocompleteCommand();
+            case TabKey:
-            e.Handled = true;
+                TryAutocompleteCommand();
-        }
+                break;
-        else if (e.KeyCode == NewlineKey.KeyCode)
+
-        {
+            case NewlineKey:
-            _inputField.InsertText("\n");
+                _inputField.InsertText("\n");
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == EnterKey.KeyCode)
+            case EnterKey:
-        {
+                var text = _inputField.Text?.Trim() ?? string.Empty;
-            var text = _inputField.Text?.Trim() ?? string.Empty;
+                // Send when there's text, or when only attachments are staged (empty caption).
-            // Send when there's text, or when only attachments are staged (empty caption).
+                if ((!string.IsNullOrEmpty(text) || _hasStagedAttachments)
-            if ((!string.IsNullOrEmpty(text) || _hasStagedAttachments)
+                    && !string.IsNullOrEmpty(_messageManager.CurrentChannel))
-                && !string.IsNullOrEmpty(_messageManager.CurrentChannel))
+                {
-            {
+                    OnMessageSubmitted?.Invoke(_messageManager.CurrentChannel, text);
-                OnMessageSubmitted?.Invoke(_messageManager.CurrentChannel, text);
+                    _inputField.Text = string.Empty;
-                _inputField.Text = string.Empty;
+                }
-            }
+                break;
-            e.Handled = true;
+
-        }
+            case AltQKey:
-        else if (e.KeyCode == AltQKey.KeyCode)
+                _app.RequestStop();
-        {
+                break;
-            _app.RequestStop();
+
-            e.Handled = true;
+            case CtrlKKey:
-        }
+                ShowSearchDialog();
-        else if (e.KeyCode == CtrlKKey.KeyCode)
+                break;
-        {
+
-            ShowSearchDialog();
+            case F6Key:
-            e.Handled = true;
+                // Move focus into the message list so you can select a message (arrows) and
-        }
+                // delete it (Delete). F6 again returns focus here. (Esc is the app quit key.)
-        else if (e.KeyCode == F6Key.KeyCode)
+                FocusMessageList();
-        {
+                break;
-            // Move focus into the message list so you can select a message (arrows) and
+
-            // delete it (Delete). F6 again returns focus here. (Esc is the app quit key.)
+            case CtrlVKey:
-            FocusMessageList();
+            case CtrlYKey:
-            e.Handled = true;
+                // Discord-style paste priority. Copied files in the OS file manager put a file
-        }
+                // list (not text) on the clipboard — attach them all. Copied image data (browser
-        else if (e.KeyCode == CtrlVKey.KeyCode || e.KeyCode == CtrlYKey.KeyCode)
+                // right-click copy, screenshot tools) is attached as a PNG. Otherwise paste text.
-        {
+                // Terminals never deliver either of the first two as text, so this is the only path.
-            // If a file was copied in the OS file manager, the clipboard holds a file list
+                if (ClipboardFiles.TryGetFiles(out var pastedFiles))
-            // (not text) — attach it. Otherwise paste text. This is the reliable path on
+                    StageFiles(pastedFiles);
-            // Windows Terminal, which never pastes copied files as text.
+                else if (!string.IsNullOrEmpty(_messageManager.CurrentChannel)
-            if (ClipboardFiles.TryGetFiles(out var pastedFiles))
+                         && ClipboardImage.TryGetPng(out var pastedPng))
-                StageFiles(pastedFiles);
+                    OnImagePasted?.Invoke(_messageManager.CurrentChannel, pastedPng);
-            else
+                else
-                GuardedClipboardAction(() => _inputField.Paste(), "paste");
+                    GuardedClipboardAction(() => _inputField.Paste(), "paste");
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlXKey.KeyCode)
+            case CtrlXKey:
-        {
+                GuardedClipboardAction(() => _inputField.Cut(), "cut");
-            GuardedClipboardAction(() => _inputField.Cut(), "cut");
+                break;
-            e.Handled = true;
+
-        }
+            case CtrlCKey:
-        else if (e.KeyCode == CtrlCKey.KeyCode)
+                GuardedClipboardAction(() => _inputField.Copy(), "copy");
-        {
+                break;
-            GuardedClipboardAction(() => _inputField.Copy(), "copy");
+
-            e.Handled = true;
+            default:
+                return; // not one of ours — leave e.Handled false so the key types normally
         }
+
+        e.Handled = true;
     }
 
     /// <summary>
@@ -872,17 +889,16 @@ public sealed partial class MainWindow : Runnable
     }
 
     /// <summary>
-    /// Routes files (from a drop or a file-clipboard paste) through the /send pipeline, which
+    /// Stages files (from a drop or a file-clipboard paste) as attachments in one batch; the
-    /// stages them; the next Enter sends them with any typed caption.
+    /// next Enter sends them with any typed caption.
     /// </summary>
-    private void StageFiles(IEnumerable<string> files)
+    private void StageFiles(IReadOnlyList<string> files)
     {
         var channel = _messageManager.CurrentChannel;
         if (string.IsNullOrEmpty(channel))
             return;
 
-        foreach (var file in files)
+        OnFilesStaged?.Invoke(channel, files);
-            OnMessageSubmitted?.Invoke(channel, $"/send \"{file}\"");
     }
 
     private void OnChatViewportChanged()
@@ -898,21 +914,25 @@ public sealed partial class MainWindow : Runnable
 
     private void OnWindowKeyDown(object? sender, Key e)
     {
-        if (e.KeyCode == AltQKey.KeyCode)
+        switch (e.KeyCode)
         {
-            _app.RequestStop();
+            case AltQKey:
-            e.Handled = true;
+                _app.RequestStop();
-        }
+                break;
-        else if (e.KeyCode == F2Key.KeyCode)
+
-        {
+            case F2Key:
-            ToggleUsersPanel();
+                ToggleUsersPanel();
-            e.Handled = true;
+                break;
-        }
+
-        else if (e.KeyCode == CtrlKKey.KeyCode)
+            case CtrlKKey:
-        {
+                ShowSearchDialog();
-            ShowSearchDialog();
+                break;
-            e.Handled = true;
+
+            default:
+                return;
         }
+
+        e.Handled = true;
     }
 
     private void ShowSearchDialog()
@@ -1317,8 +1337,11 @@ public sealed partial class MainWindow : Runnable
     /// </summary>
     private void RefreshChannelList()
     {
+        var privateChannels = _channelNames
+            .Where(n => _channelPublic.TryGetValue(n, out var isPublic) && !isPublic)
+            .ToHashSet();
         _channelListSource.Update(_channelNames, _messageManager.GetUnreadCounts(), _messageManager.CurrentChannel,
-            _channelProtected, _messageManager.MentionChannels);
+            _channelProtected, _messageManager.MentionChannels, privateChannels);
         _channelList.Source = _channelListSource;
 
         // Restore selection to current channel
@@ -1394,6 +1417,10 @@ public sealed partial class MainWindow : Runnable
             var text = roleTag.Length > 0
                 ? $"{statusIcon} {roleTag} {name}"
                 : $"{statusIcon} {name}";
+            // Users connected only via the IRC gateway get a tag — they lack client features
+            // (encryption, attachments, profiles), which is useful context in conversation.
+            if (u.IsIrc)
+                text += " [irc]";
             // Fall back to the deterministic per-nick palette so user-list colors
             // match the same user's messages in chat.
             var nameColor = HexColorHelper.ParseHexColor(u.NicknameColor)

src/EchoHub.Core/Constants/HubConstants.cs

@@ -4,6 +4,12 @@ public static class HubConstants
 {
     public const string ChatHubPath = "/hubs/chat";
     public const string DefaultChannel = "general";
+
+    /// <summary>
+    /// Connection-id prefix for IRC gateway connections. The presence tracker uses it to
+    /// tell IRC-only users apart from native (SignalR) clients.
+    /// </summary>
+    public const string IrcConnectionIdPrefix = "irc-";
     public const int DefaultHistoryCount = 100;
     public const int MaxMessageLength = 2000;
     public const int MaxImageSizeBytes = 10 * 1024 * 1024; // 10 MB

src/EchoHub.Core/DTOs/ChatDtos.cs

@@ -10,7 +10,8 @@ public record MessageDto(
     string ChannelName,
     DateTimeOffset SentAt,
     List<AttachmentDto>? Attachments = null,
-    List<EmbedDto>? Embeds = null);
+    List<EmbedDto>? Embeds = null,
+    string? SenderDisplayName = null);
 
 /// <summary>
 /// A file attached to a message. <see cref="AsciiPreview"/> holds the color-tag art for

src/EchoHub.Core/DTOs/ProfileDtos.cs

@@ -30,6 +30,7 @@ public record UserPresenceDto(
     string? NicknameColor,
     UserStatus Status,
     string? StatusMessage,
-    ServerRole Role);
+    ServerRole Role,
+    bool IsIrc = false);
 
 public record AvatarUploadResponse(string AvatarAscii);

src/EchoHub.Server.Irc/IrcClientConnection.cs

@@ -1,5 +1,6 @@
 using System.Net.Sockets;
 using System.Text;
+using EchoHub.Core.Constants;
 
 namespace EchoHub.Server.Irc;
 
@@ -14,7 +15,7 @@ public sealed class IrcClientConnection : IAsyncDisposable
     private readonly SemaphoreSlim _writeLock = new(1, 1);
 
     // Connection identity
-    public string ConnectionId { get; } = $"irc-{Guid.NewGuid()}";
+    public string ConnectionId { get; } = $"{HubConstants.IrcConnectionIdPrefix}{Guid.NewGuid()}";
 
     // Registration state
     public string? Nickname { get; set; }

src/EchoHub.Server/Controllers/ChannelsController.cs

@@ -308,7 +308,8 @@ public class ChannelsController : ControllerBase
             sender?.NicknameColor,
             channelName,
             message.SentAt,
-            attachmentDtos);
+            attachmentDtos,
+            SenderDisplayName: sender?.DisplayName);
 
         await _chatService.BroadcastMessageAsync(channelName, messageDto);
 
@@ -444,7 +445,8 @@ public class ChannelsController : ControllerBase
             sender?.NicknameColor,
             channelName,
             message.SentAt,
-            [new AttachmentDto(AttachmentKind.Image, attachmentUrl, fileName, imageBytes.Length, _encryption.Encrypt(preview))]);
+            [new AttachmentDto(AttachmentKind.Image, attachmentUrl, fileName, imageBytes.Length, _encryption.Encrypt(preview))],
+            SenderDisplayName: sender?.DisplayName);
 
         await _chatService.BroadcastMessageAsync(channelName, messageDto);
 

src/EchoHub.Server/Services/ChatService.cs

@@ -121,7 +121,8 @@ public class ChatService : IChatService
                 {
                     presence = new UserPresenceDto(
                         user.Username, user.DisplayName, user.NicknameColor,
-                        user.Status, user.StatusMessage, user.Role);
+                        user.Status, user.StatusMessage, user.Role,
+                        _presenceTracker.IsIrcOnly(user.Username));
                 }
             }
             catch (Exception ex)
@@ -236,7 +237,8 @@ public class ChatService : IChatService
             sender?.NicknameColor,
             channelName,
             message.SentAt,
-            Embeds: embeds);
+            Embeds: embeds,
+            SenderDisplayName: sender?.DisplayName);
 
         await BroadcastToAllAsync(b => b.SendMessageToChannelAsync(channelName, messageDto));
 
@@ -279,7 +281,8 @@ public class ChatService : IChatService
             user.NicknameColor,
             status,
             statusMessage,
-            user.Role);
+            user.Role,
+            _presenceTracker.IsIrcOnly(user.Username));
 
         var channels = _presenceTracker.GetChannelsForUser(username);
         await BroadcastToAllAsync(b => b.SendUserStatusChangedAsync(channels, presence));
@@ -295,16 +298,20 @@ public class ChatService : IChatService
         using var scope = _scopeFactory.CreateScope();
         var db = scope.ServiceProvider.GetRequiredService<EchoHubDbContext>();
 
-        return await db.Users
+        var users = await db.Users
             .Where(u => onlineUsernames.Contains(u.Username) && u.Status != UserStatus.Invisible)
-            .Select(u => new UserPresenceDto(
+            .ToListAsync();
+
+        // IsIrcOnly comes from the in-memory tracker, so map outside the EF query
+        return users.Select(u => new UserPresenceDto(
                 u.Username,
                 u.DisplayName,
                 u.NicknameColor,
                 u.Status,
                 u.StatusMessage,
-                u.Role))
+                u.Role,
-            .ToListAsync();
+                _presenceTracker.IsIrcOnly(u.Username)))
+            .ToList();
     }
 
     public Task BroadcastMessageAsync(string channelName, MessageDto message)
@@ -380,7 +387,7 @@ public class ChatService : IChatService
             .Join(db.Users,
                 m => m.SenderUserId,
                 u => u.Id,
-                (m, u) => new { m, u.NicknameColor })
+                (m, u) => new { m, u.NicknameColor, u.DisplayName })
             .ToListAsync();
 
         raw.Reverse();
@@ -448,7 +455,8 @@ public class ChatService : IChatService
                 channelName,
                 x.m.SentAt,
                 attachments,
-                embeds));
+                embeds,
+                x.DisplayName));
         }
 
         // Lazily delete the pruned messages (+ their attachment rows) as they're encountered.

src/EchoHub.Server/Services/PresenceTracker.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using EchoHub.Core.Constants;
 
 namespace EchoHub.Server.Services;
 
@@ -174,6 +175,20 @@ public class PresenceTracker
         return _userConnections.TryGetValue(username, out var connections) && connections.Count > 0;
     }
 
+    /// <summary>
+    /// True when the user is online exclusively through the IRC gateway. A user who also has a
+    /// native client connected has full features, so they don't count as IRC-only.
+    /// </summary>
+    public bool IsIrcOnly(string username)
+    {
+        lock (_lock)
+        {
+            return _userConnections.TryGetValue(username, out var connections)
+                && connections.Count > 0
+                && connections.All(c => c.StartsWith(HubConstants.IrcConnectionIdPrefix, StringComparison.Ordinal));
+        }
+    }
+
     public int GetOnlineUserCount()
     {
         return _userConnections.Count;

src/EchoHub.Tests/ClipboardImageTests.cs

@@ -0,0 +1,78 @@
+using EchoHub.Client.Services;
+using EchoHub.Core.Services;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Bmp;
+using SixLabors.ImageSharp.PixelFormats;
+using Xunit;
+
+namespace EchoHub.Tests;
+
+public class ClipboardImageTests
+{
+    /// <summary>
+    /// Encodes an image as BMP and strips the 14-byte BITMAPFILEHEADER, producing exactly what
+    /// the Windows clipboard hands out as CF_DIB.
+    /// </summary>
+    private static byte[] MakeDib(Image<Rgba32> image, BmpBitsPerPixel bpp)
+    {
+        using var ms = new MemoryStream();
+        image.Save(ms, new BmpEncoder { BitsPerPixel = bpp });
+        return ms.ToArray()[14..];
+    }
+
+    private static Image<Rgba32> MakeTestImage()
+    {
+        var image = new Image<Rgba32>(4, 3);
+        image[0, 0] = new Rgba32(255, 0, 0);
+        image[3, 2] = new Rgba32(0, 0, 255);
+        return image;
+    }
+
+    [Theory]
+    [InlineData(BmpBitsPerPixel.Pixel24)]
+    [InlineData(BmpBitsPerPixel.Pixel32)]
+    [InlineData(BmpBitsPerPixel.Pixel8)] // palette-based: exercises the palette offset math
+    public void DibToPng_ConvertsDibToValidPng(BmpBitsPerPixel bpp)
+    {
+        using var original = MakeTestImage();
+        var dib = MakeDib(original, bpp);
+
+        var png = ClipboardImage.DibToPng(dib);
+
+        Assert.NotNull(png);
+        using var pngStream = new MemoryStream(png);
+        Assert.True(FileValidationHelper.IsValidImage(pngStream));
+
+        using var decoded = Image.Load<Rgba32>(png);
+        Assert.Equal(original.Width, decoded.Width);
+        Assert.Equal(original.Height, decoded.Height);
+    }
+
+    [Fact]
+    public void DibToPng_PreservesPixels_For24Bpp()
+    {
+        using var original = MakeTestImage();
+        var dib = MakeDib(original, BmpBitsPerPixel.Pixel24);
+
+        var png = ClipboardImage.DibToPng(dib);
+
+        Assert.NotNull(png);
+        using var decoded = Image.Load<Rgba32>(png);
+        Assert.Equal(new Rgba32(255, 0, 0), decoded[0, 0]);
+        Assert.Equal(new Rgba32(0, 0, 255), decoded[3, 2]);
+    }
+
+    [Fact]
+    public void DibToPng_ReturnsNull_ForTruncatedData()
+    {
+        Assert.Null(ClipboardImage.DibToPng([0x28, 0x00, 0x00]));
+    }
+
+    [Fact]
+    public void DibToPng_ReturnsNull_ForGarbageData()
+    {
+        var garbage = new byte[256];
+        new Random(42).NextBytes(garbage);
+        Assert.Null(ClipboardImage.DibToPng(garbage));
+    }
+}

src/EchoHub.Tests/PresenceTrackerTests.cs

@@ -1,3 +1,4 @@
+using EchoHub.Core.Constants;
 using EchoHub.Server.Services;
 using Xunit;
 
@@ -65,4 +66,48 @@ public class PresenceTrackerTests
         Assert.Contains("general", channels);
         Assert.Contains("random", channels);
     }
+
+    [Fact]
+    public void IsIrcOnly_AllConnectionsIrc_ReturnsTrue()
+    {
+        var tracker = new PresenceTracker();
+        tracker.UserConnected($"{HubConstants.IrcConnectionIdPrefix}conn1", Guid.NewGuid(), "alice");
+        Assert.True(tracker.IsIrcOnly("alice"));
+    }
+
+    [Fact]
+    public void IsIrcOnly_NativeConnection_ReturnsFalse()
+    {
+        var tracker = new PresenceTracker();
+        tracker.UserConnected("conn1", Guid.NewGuid(), "alice");
+        Assert.False(tracker.IsIrcOnly("alice"));
+    }
+
+    [Fact]
+    public void IsIrcOnly_MixedConnections_ReturnsFalse()
+    {
+        var tracker = new PresenceTracker();
+        var userId = Guid.NewGuid();
+        tracker.UserConnected($"{HubConstants.IrcConnectionIdPrefix}conn1", userId, "alice");
+        tracker.UserConnected("conn2", userId, "alice");
+        Assert.False(tracker.IsIrcOnly("alice"));
+    }
+
+    [Fact]
+    public void IsIrcOnly_OfflineUser_ReturnsFalse()
+    {
+        var tracker = new PresenceTracker();
+        Assert.False(tracker.IsIrcOnly("nobody"));
+    }
+
+    [Fact]
+    public void IsIrcOnly_NativeConnectionDisconnects_BecomesTrue()
+    {
+        var tracker = new PresenceTracker();
+        var userId = Guid.NewGuid();
+        tracker.UserConnected($"{HubConstants.IrcConnectionIdPrefix}conn1", userId, "alice");
+        tracker.UserConnected("conn2", userId, "alice");
+        tracker.UserDisconnected("conn2");
+        Assert.True(tracker.IsIrcOnly("alice"));
+    }
 }

src/EchoHub.Tests/RoomKeyProtectionTests.cs

@@ -0,0 +1,168 @@
+using System.Security.Cryptography;
+using EchoHub.Client.Services;
+using EchoHub.Core.Security;
+using Xunit;
+
+namespace EchoHub.Tests;
+
+/// <summary>
+/// At-rest encryption of the cached room keys (RoomKeyProtector) and the store-level
+/// decisions built on it (RoomKeyStore): fresh envelopes overwrite stale cached keys,
+/// legacy plain-base64 entries are recognized for the one-way migration.
+/// </summary>
+public class RoomKeyProtectorTests : IDisposable
+{
+    private readonly string _dir = Directory.CreateTempSubdirectory("echohub-keyprotector-").FullName;
+
+    public void Dispose()
+    {
+        try { Directory.Delete(_dir, recursive: true); } catch { /* best-effort cleanup */ }
+    }
+
+    [Fact]
+    public void KeyFile_Protect_RoundTrips()
+    {
+        var protector = new RoomKeyProtector(_dir, useDpapi: false);
+        var key = RoomCrypto.GenerateRoomKey();
+
+        var stored = protector.Protect(key);
+
+        Assert.StartsWith(RoomKeyProtector.KeyFilePrefix, stored);
+        Assert.True(protector.TryUnprotect(stored, out var recovered, out var wasLegacy));
+        Assert.Equal(key, recovered);
+        Assert.False(wasLegacy);
+    }
+
+    [Fact]
+    public void Dpapi_Protect_RoundTrips()
+    {
+        if (!OperatingSystem.IsWindows()) return; // DPAPI is Windows-only
+
+        var protector = new RoomKeyProtector(_dir, useDpapi: true);
+        var key = RoomCrypto.GenerateRoomKey();
+
+        var stored = protector.Protect(key);
+
+        Assert.StartsWith(RoomKeyProtector.DpapiPrefix, stored);
+        Assert.True(protector.TryUnprotect(stored, out var recovered, out var wasLegacy));
+        Assert.Equal(key, recovered);
+        Assert.False(wasLegacy);
+    }
+
+    [Fact]
+    public void Protect_DoesNotStoreThePlainKey()
+    {
+        var protector = new RoomKeyProtector(_dir, useDpapi: false);
+        var key = RoomCrypto.GenerateRoomKey();
+
+        var stored = protector.Protect(key);
+
+        Assert.DoesNotContain(Convert.ToBase64String(key), stored);
+    }
+
+    [Fact]
+    public void Legacy_PlainBase64_IsAccepted_AndFlaggedForMigration()
+    {
+        var protector = new RoomKeyProtector(_dir, useDpapi: false);
+        var key = RoomCrypto.GenerateRoomKey();
+
+        Assert.True(protector.TryUnprotect(Convert.ToBase64String(key), out var recovered, out var wasLegacy));
+        Assert.Equal(key, recovered);
+        Assert.True(wasLegacy);
+
+        // The migration re-protects it; the upgraded value round-trips and is no longer legacy
+        var upgraded = protector.Protect(recovered);
+        Assert.True(protector.TryUnprotect(upgraded, out var recoveredAgain, out var stillLegacy));
+        Assert.Equal(key, recoveredAgain);
+        Assert.False(stillLegacy);
+    }
+
+    [Fact]
+    public void Malformed_Values_AreRejected()
+    {
+        var protector = new RoomKeyProtector(_dir, useDpapi: false);
+
+        Assert.False(protector.TryUnprotect("not base64 at all!!", out _, out _));
+        Assert.False(protector.TryUnprotect(RoomKeyProtector.KeyFilePrefix + "not base64!!", out _, out _));
+        // Valid base64 but not a 32-byte room key → not a usable legacy entry
+        Assert.False(protector.TryUnprotect(Convert.ToBase64String([1, 2, 3]), out _, out _));
+    }
+
+    [Fact]
+    public void KeyFile_Lost_MakesStoredValuesUnreadable_NotThrow()
+    {
+        var protector = new RoomKeyProtector(_dir, useDpapi: false);
+        var stored = protector.Protect(RoomCrypto.GenerateRoomKey());
+
+        File.Delete(Path.Combine(_dir, "roomkeys.key"));
+
+        // A fresh protector regenerates a different master key — the value must fail
+        // cleanly (entry dropped, passphrase prompt recovers it), not throw
+        var fresh = new RoomKeyProtector(_dir, useDpapi: false);
+        Assert.False(fresh.TryUnprotect(stored, out _, out _));
+    }
+}
+
+public class RoomKeyStoreEnvelopeTests
+{
+    // Note: without LoadForServer the store never touches the config file on disk —
+    // these tests exercise the in-memory decision logic only.
+
+    private static RoomKeyStore NewStore() =>
+        new(new RoomKeyProtector(Path.Combine(Path.GetTempPath(), "echohub-unused"), useDpapi: false));
+
+    [Fact]
+    public void TryStoreFromEnvelope_FreshEnvelope_OverwritesStaleCachedKey()
+    {
+        var store = NewStore();
+        var stale = RoomCrypto.GenerateRoomKey();
+        store.StoreKey("vault", stale);
+
+        // Channel deleted and recreated under the same name → new room key, new envelope
+        var fresh = RoomCrypto.GenerateRoomKey();
+        var kek = RandomNumberGenerator.GetBytes(32);
+        var wrapped = RoomCrypto.WrapRoomKey(fresh, kek);
+
+        Assert.True(store.TryStoreFromEnvelope("vault", wrapped, kek));
+        Assert.True(store.TryGetKey("vault", out var current));
+        Assert.Equal(fresh, current);
+    }
+
+    [Fact]
+    public void TryStoreFromEnvelope_WrongKek_KeepsCachedKey()
+    {
+        var store = NewStore();
+        var cached = RoomCrypto.GenerateRoomKey();
+        store.StoreKey("vault", cached);
+
+        var wrapped = RoomCrypto.WrapRoomKey(RoomCrypto.GenerateRoomKey(), RandomNumberGenerator.GetBytes(32));
+
+        Assert.False(store.TryStoreFromEnvelope("vault", wrapped, RandomNumberGenerator.GetBytes(32)));
+        Assert.True(store.TryGetKey("vault", out var current));
+        Assert.Equal(cached, current);
+    }
+
+    [Fact]
+    public void MarkChannelEncrypted_TracksAndUntracks()
+    {
+        var store = NewStore();
+
+        Assert.False(store.IsChannelEncrypted("vault"));
+
+        store.MarkChannelEncrypted("vault", true);
+        Assert.True(store.IsChannelEncrypted("vault"));
+        Assert.True(store.IsChannelEncrypted("VAULT")); // channel names are case-insensitive
+
+        store.MarkChannelEncrypted("vault", false);
+        Assert.False(store.IsChannelEncrypted("vault"));
+    }
+
+    [Fact]
+    public void StoreKey_MarksChannelEncrypted()
+    {
+        var store = NewStore();
+        store.StoreKey("vault", RoomCrypto.GenerateRoomKey());
+
+        Assert.True(store.IsChannelEncrypted("vault"));
+    }
+}