ciphermesh 2.0.0 → 2.2.0

package/src/client/ChatController.js

@@ -11,7 +11,9 @@ import {
   createRatchetedMessage,
   createSealedMessage,
   createKeyUpdate,
-  createChangeRoom,
+  createJoinRoom,
+  createLeaveRoom,
+  createRoomAuth,
   createListRooms,
   createKickPeer,
   createMutePeer,
@@ -19,6 +21,14 @@ import {
   ERR,
 } from '../protocol/messages.js';
 import { sealEnvelope, openEnvelope } from '../crypto/SealedSender.js';
+import {
+  deriveRoomSecrets,
+  signRoomChallenge,
+  encryptRoomPayload,
+  decryptRoomPayload,
+  isRoomWrapped,
+  freeRoomSecrets,
+} from '../crypto/RoomKey.js';
 import { KEY_ROTATION_INTERVAL_MS, EMOJI_MAP, COVER_CONSTANT_MS } from '../shared/constants.js';
 import { KeyManager } from '../crypto/KeyManager.js';
 import { Handshake } from '../crypto/Handshake.js';
@@ -43,10 +53,12 @@ import { setTheme, getThemeName, themeNames } from '../shared/themes.js';
 import { panicWipe } from '../shared/panic.js';
 import { farewellBanner } from '../shared/banner.js';
 import { parseDndWindow, shouldNotify, nowMinutes, mentionsMe } from '../shared/dnd.js';
+import { saveLastSession } from '../shared/lastSession.js';
 import { COMMANDS } from './UI.js';
 
 const TYPING_SEND_INTERVAL = 2000; // debounce: max 1 typing event per 2s
 const TYPING_EXPIRE_TIMEOUT = 3000; // hide indicator after 3s of silence
+const MENTIONS_MAX = 50; // session mention log cap (memory only, never persisted)
 
 export class ChatController {
   #nickname;
@@ -98,6 +110,17 @@ export class ChatController {
   #autoAwayMs = 0; // idle timeout in ms (0 = off)
   #autoAwayTimer = null;
   #autoAwaySet = false; // whether the current away was set automatically
+  #mentions = []; // session mention log: { nickname, text, room, at }
+  #awayUnread = 0; // messages received while away
+  #awayMentions = 0; // …of which mentioned me
+  #autoLockMs = 0; // idle screen-lock timeout (0 = off)
+  #autoLockTimer = null;
+  // Multi-room buffers (IRC style): lines live in the UI; membership, unread
+  // counters and private-room secrets live here, one entry per joined room.
+  #buffers = new Map(); // room → { unread, mentions, private, owner, secrets, pins }
+  #bufferOrder = []; // Alt+1..9 order
+  #allPeers = new Map(); // sessionId → { nickname, publicKey, rooms: Set } (all my rooms)
+  #pendingRoomSecrets = null; // derived while joining/creating, promoted on join
 
   constructor(
     nickname,
@@ -239,6 +262,23 @@ export class ChatController {
       this.destroy();
       process.exit(0);
     });
+
+    this.#ui.on('unlocked', () => {
+      this.#auditLog.log(AuditEvent.SCREEN_UNLOCKED, {});
+      this.#ui.addSystemMessage('Screen unlocked');
+      this.#noteActive();
+    });
+
+    this.#ui.on('lock-failed', () => {
+      this.#auditLog.log(AuditEvent.SCREEN_UNLOCK_FAILED, {});
+    });
+
+    this.#ui.on('buffer-switch', (idx) => {
+      const room = this.#bufferOrder[idx];
+      if (room) {
+        this.#switchToBuffer(room);
+      }
+    });
   }
 
   // ── Auto-away (idle) ────────────────────────────────────────
@@ -250,9 +290,52 @@ export class ChatController {
       this.#autoAwaySet = false;
       this.#ui.removeHeaderIndicator('away');
       this.#ui.addSystemMessage("You're back (auto)");
+      this.#reportAwayUnread();
       this.#broadcastPresence();
     }
     this.#armAutoAway();
+    this.#armAutoLock();
+  }
+
+  // ── Screen lock (privacy, not duress — that's /panic) ────────
+  #lockNow() {
+    if (!this.#passphrase) {
+      this.#ui.addErrorMessage(
+        'No session passphrase — /lock needs one (set it at startup to enable locking)',
+      );
+      return;
+    }
+    if (this.#ui.isLocked) {
+      return;
+    }
+    this.#auditLog.log(AuditEvent.SCREEN_LOCKED, {});
+    this.#ui.showLock((attempt) => attempt === this.#passphrase);
+  }
+
+  #armAutoLock() {
+    if (this.#autoLockTimer) {
+      clearTimeout(this.#autoLockTimer);
+      this.#autoLockTimer = null;
+    }
+    if (this.#autoLockMs > 0) {
+      this.#autoLockTimer = setTimeout(() => this.#lockNow(), this.#autoLockMs);
+      if (this.#autoLockTimer.unref) {
+        this.#autoLockTimer.unref();
+      }
+    }
+  }
+
+  // Summarize what arrived while away, then reset the counters.
+  #reportAwayUnread() {
+    if (this.#awayUnread > 0) {
+      const mentions =
+        this.#awayMentions > 0 ? ` — ${this.#awayMentions} mention(s), see /mentions` : '';
+      this.#ui.addSystemMessage(
+        `While you were away: ${this.#awayUnread} new message(s)${mentions}`,
+      );
+    }
+    this.#awayUnread = 0;
+    this.#awayMentions = 0;
   }
 
   #armAutoAway() {
@@ -275,6 +358,8 @@ export class ChatController {
     this.#away = true;
     this.#awayReason = 'away (idle)';
     this.#autoAwaySet = true;
+    this.#awayUnread = 0;
+    this.#awayMentions = 0;
     this.#ui.setHeaderIndicator('away', '{yellow-fg}[away]{/yellow-fg}');
     this.#ui.addSystemMessage('Auto-away: marked as away due to inactivity');
     this.#broadcastPresence();
@@ -350,6 +435,18 @@ export class ChatController {
         this.#onRoomChanged(msg);
         break;
 
+      case MSG.ROOM_JOINED:
+        this.#onRoomJoined(msg);
+        break;
+
+      case MSG.ROOM_LEFT:
+        this.#onRoomLeft(msg);
+        break;
+
+      case MSG.ROOM_CHALLENGE:
+        this.#onRoomChallenge(msg);
+        break;
+
       case MSG.ROOM_LIST:
         this.#onRoomList(msg);
         break;
@@ -367,6 +464,11 @@ export class ChatController {
           this.#ui.addErrorMessage(
             `${msg.message}. Use /nick <other> to pick a different nickname.`,
           );
+        } else if (msg.code === ERR.ROOM_AUTH_FAILED || msg.code === ERR.ROOM_EXISTS) {
+          // Join/create refused — drop the derived secrets for that attempt.
+          freeRoomSecrets(this.#pendingRoomSecrets);
+          this.#pendingRoomSecrets = null;
+          this.#ui.addErrorMessage(`Error: ${msg.message} (${msg.code})`);
         } else {
           this.#ui.addErrorMessage(`Error: ${msg.message} (${msg.code})`);
         }
@@ -406,21 +508,27 @@ export class ChatController {
   // ── JOIN_ACK: registered with server ──────────────────────────
   #onJoinAck(msg) {
     this.#sessionId = msg.sessionId;
-    this.#currentRoom = msg.room || 'general';
-    this.#ui.setRoom(this.#currentRoom);
-    this.#currentRoomOwner = msg.roomOwner || null;
+    const room = msg.room || 'general';
+    const hadPrivateBuffers = [...this.#buffers.values()].some((b) => b.secrets);
 
     // Build map of old sessionIds by nickname for ratchet migration
     const oldSessionByNick = new Map();
-    for (const [sid, peer] of this.#peers) {
+    for (const [sid, peer] of this.#allPeers) {
       oldSessionByNick.set(peer.nickname.toLowerCase(), sid);
     }
-    this.#peers.clear();
+
+    // (Re)connecting always starts over in a single public room.
+    this.#resetBuffersTo(room);
+    this.#currentRoomOwner = msg.roomOwner || null;
+    if (hadPrivateBuffers) {
+      this.#ui.addInfoMessage('Reconnected outside your private room(s) — /join them again.');
+    }
 
     for (const peer of msg.peers) {
-      this.#peers.set(peer.sessionId, {
+      this.#allPeers.set(peer.sessionId, {
         nickname: peer.nickname,
         publicKey: peer.publicKey,
+        rooms: new Set([room]),
       });
 
       const oldSid = oldSessionByNick.get(peer.nickname.toLowerCase());
@@ -437,9 +545,8 @@ export class ChatController {
     // Initialize ratchets now that we have our session ID
     this.#handshake.setMySessionId(msg.sessionId);
 
+    this.#rebuildActivePeers();
     const peerNames = [...this.#peers.values()].map((p) => p.nickname);
-    this.#ui.setOnlineCount(this.#peers.size + 1);
-    this.#ui.setPeerNames(peerNames);
     this.#ui.addSystemMessage('Connected to server with E2E encryption active');
 
     if (peerNames.length > 0) {
@@ -452,26 +559,201 @@ export class ChatController {
 
     // Invite included a room — join it once after the first connect
     if (this.#inviteRoom && this.#inviteRoom !== this.#currentRoom) {
-      this.#connection.send(createChangeRoom(this.#inviteRoom));
+      this.#connection.send(createJoinRoom(this.#inviteRoom));
       this.#inviteRoom = null;
     }
+
+    this.#saveLastSession();
+  }
+
+  // Remember where we are for the next launch. Privacy: in a private room only
+  // the server is written — the room name never touches disk.
+  #saveLastSession(isPrivate = false) {
+    saveLastSession({
+      server: (this.#connection.url || '').replace(/^wss?:\/\//, ''),
+      room: isPrivate || this.#activeSecrets ? undefined : this.#currentRoom,
+    });
+  }
+
+  // ── Multi-room buffer plumbing ───────────────────────────────
+
+  get #activeSecrets() {
+    return this.#buffers.get(this.#currentRoom)?.secrets || null;
+  }
+
+  #ensureBuffer(room, { isPrivate = false, owner = null, secrets = null } = {}) {
+    if (!this.#buffers.has(room)) {
+      this.#buffers.set(room, {
+        unread: 0,
+        mentions: 0,
+        private: isPrivate,
+        owner,
+        secrets,
+        pins: [],
+      });
+      this.#bufferOrder.push(room);
+    }
+    return this.#buffers.get(room);
+  }
+
+  #dropBufferState(room) {
+    const buf = this.#buffers.get(room);
+    if (buf) {
+      freeRoomSecrets(buf.secrets);
+      this.#buffers.delete(room);
+    }
+    this.#bufferOrder = this.#bufferOrder.filter((r) => r !== room);
+    this.#ui.dropBuffer(room);
+  }
+
+  // Forget every buffer and exist only in `room` (connect, reconnect, or a
+  // legacy full switch — including being kicked).
+  #resetBuffersTo(room, opts = {}) {
+    for (const buf of this.#buffers.values()) {
+      freeRoomSecrets(buf.secrets);
+    }
+    this.#buffers.clear();
+    this.#bufferOrder = [];
+    this.#allPeers.clear();
+    this.#peers.clear();
+    this.#currentRoom = room;
+    const buf = this.#ensureBuffer(room, opts);
+    this.#pinnedMessages = buf.pins;
+    this.#currentRoomOwner = buf.owner;
+    this.#ui.resetBuffers(room);
+    this.#updateBufferBar();
+    this.#updatePrivateIndicator();
+  }
+
+  #switchToBuffer(room) {
+    if (room === this.#currentRoom || !this.#buffers.has(room)) {
+      return;
+    }
+    // Sync the active-view aliases back before leaving the buffer.
+    const cur = this.#buffers.get(this.#currentRoom);
+    if (cur) {
+      cur.pins = this.#pinnedMessages;
+      cur.owner = this.#currentRoomOwner;
+    }
+    this.#currentRoom = room;
+    const buf = this.#buffers.get(room);
+    buf.unread = 0;
+    buf.mentions = 0;
+    this.#pinnedMessages = buf.pins;
+    this.#currentRoomOwner = buf.owner;
+    this.#ui.switchBuffer(room);
+    this.#rebuildActivePeers();
+    this.#updateBufferBar();
+    this.#updatePrivateIndicator();
+    this.#saveLastSession(buf.private);
+  }
+
+  // #peers is always "the active room's peers" so every send path stays
+  // room-scoped without changes. Rebuilt from the global map on switches.
+  #rebuildActivePeers() {
+    this.#peers.clear();
+    for (const [sid, p] of this.#allPeers) {
+      if (p.rooms.has(this.#currentRoom)) {
+        this.#peers.set(sid, { nickname: p.nickname, publicKey: p.publicKey });
+      }
+    }
+    this.#ui.setOnlineCount(this.#peers.size + 1);
+    this.#ui.setPeerNames([...this.#peers.values()].map((p) => p.nickname));
+  }
+
+  #updateBufferBar() {
+    this.#ui.setBufferBar(
+      this.#bufferOrder.map((room) => {
+        const b = this.#buffers.get(room);
+        return {
+          room,
+          active: room === this.#currentRoom,
+          unread: b?.unread || 0,
+          private: !!b?.private,
+        };
+      }),
+    );
+  }
+
+  #updatePrivateIndicator() {
+    if (this.#activeSecrets) {
+      this.#ui.setHeaderIndicator('private', '{green-fg}[🔒]{/green-fg}');
+    } else {
+      this.#ui.removeHeaderIndicator('private');
+    }
+  }
+
+  // Which buffer an incoming payload belongs to: its own E2EE `room` tag when
+  // it names a room we're in; otherwise a room shared with the sender.
+  #roomForIncoming(data, fromSid) {
+    if (typeof data.room === 'string' && this.#buffers.has(data.room)) {
+      return data.room;
+    }
+    const peer = this.#allPeers.get(fromSid);
+    if (peer?.rooms.has(this.#currentRoom)) {
+      return this.#currentRoom;
+    }
+    return peer?.rooms.values().next().value || this.#currentRoom;
+  }
+
+  // Count a message that landed in an inactive buffer.
+  #noteBufferUnread(room, mentioned) {
+    if (room === this.#currentRoom) {
+      return;
+    }
+    const buf = this.#buffers.get(room);
+    if (buf) {
+      buf.unread++;
+      if (mentioned) {
+        buf.mentions++;
+      }
+      this.#updateBufferBar();
+    }
+  }
+
+  // Tag an outgoing payload with the room it belongs to. Travels INSIDE the
+  // E2EE envelope — the relay never sees it.
+  #tagRoom(payloadStr) {
+    try {
+      const obj = JSON.parse(payloadStr);
+      if (obj && typeof obj === 'object' && !obj.room) {
+        obj.room = this.#currentRoom;
+        return JSON.stringify(obj);
+      }
+    } catch {
+      /* not JSON — send as is */
+    }
+    return payloadStr;
   }
 
   // ── New peer arrived ──────────────────────────────────────────
   #onPeerJoined(msg) {
     const { peer } = msg;
-    this.#peers.set(peer.sessionId, {
-      nickname: peer.nickname,
-      publicKey: peer.publicKey,
-    });
-    this.#handshake.registerPeer(peer.sessionId, peer.publicKey);
+    const room = msg.room && this.#buffers.has(msg.room) ? msg.room : this.#currentRoom;
+
+    const existing = this.#allPeers.get(peer.sessionId);
+    if (existing) {
+      existing.rooms.add(room);
+    } else {
+      this.#allPeers.set(peer.sessionId, {
+        nickname: peer.nickname,
+        publicKey: peer.publicKey,
+        rooms: new Set([room]),
+      });
+      this.#handshake.registerPeer(peer.sessionId, peer.publicKey);
+    }
     this.#checkTrust(peer.nickname, peer.publicKey);
+    this.#auditLog.log(AuditEvent.PEER_CONNECTED, { nickname: peer.nickname, room });
 
-    this.#ui.setOnlineCount(this.#peers.size + 1);
-    this.#ui.setPeerNames([...this.#peers.values()].map((p) => p.nickname));
-    this.#ui.handshakeConnect(peer.nickname);
-    this.#nudgeVerify(peer.nickname);
-    this.#auditLog.log(AuditEvent.PEER_CONNECTED, { nickname: peer.nickname });
+    if (room === this.#currentRoom) {
+      this.#rebuildActivePeers();
+      this.#ui.handshakeConnect(peer.nickname);
+      this.#nudgeVerify(peer.nickname);
+    } else {
+      this.#ui.toBuffer(room, () => {
+        this.#ui.addSystemMessage(`${peer.nickname} joined #${room}`);
+      });
+    }
 
     // A newcomer doesn't know my presence — send only to them
     if (this.#away || this.#statusText) {
@@ -491,19 +773,32 @@ export class ChatController {
     );
   }
 
-  // ── Peer left ─────────────────────────────────────────────────
+  // ── Peer left (one room, or entirely when untagged) ──────────
   #onPeerLeft(msg) {
-    const peer = this.#peers.get(msg.sessionId);
-    const nickname = peer?.nickname || msg.nickname || 'Unknown';
+    const entry = this.#allPeers.get(msg.sessionId);
+    const nickname = entry?.nickname || msg.nickname || 'Unknown';
+    const room = msg.room && this.#buffers.has(msg.room) ? msg.room : null;
 
-    this.#hidePeerTyping(msg.sessionId, nickname);
-    this.#handshake.removePeer(msg.sessionId);
-    this.#nonceManager.removePeer(msg.sessionId);
-    this.#peers.delete(msg.sessionId);
+    if (entry && room) {
+      entry.rooms.delete(room);
+    }
+    const goneEntirely = !entry || !room || entry.rooms.size === 0;
 
-    this.#ui.setOnlineCount(this.#peers.size + 1);
-    this.#ui.setPeerNames([...this.#peers.values()].map((p) => p.nickname));
-    this.#ui.handshakeDisconnect(nickname);
+    if (goneEntirely) {
+      this.#hidePeerTyping(msg.sessionId, nickname);
+      this.#handshake.removePeer(msg.sessionId);
+      this.#nonceManager.removePeer(msg.sessionId);
+      this.#allPeers.delete(msg.sessionId);
+    }
+
+    if (!room || room === this.#currentRoom) {
+      this.#rebuildActivePeers();
+      this.#ui.handshakeDisconnect(nickname);
+    } else {
+      this.#ui.toBuffer(room, () => {
+        this.#ui.addSystemMessage(`${nickname} left #${room}`);
+      });
+    }
     this.#auditLog.log(AuditEvent.PEER_DISCONNECTED, { nickname });
   }
 
@@ -522,7 +817,8 @@ export class ChatController {
       msg = { ...msg, from: opened.from, payload: opened.payload };
     }
 
-    const peer = this.#peers.get(msg.from);
+    // Multi-room: the sender may live in any of my rooms, not just the active one.
+    const peer = this.#allPeers.get(msg.from);
     if (!peer) {
       this.#ui.addErrorMessage('Message from unknown peer');
       return;
@@ -612,25 +908,54 @@ export class ChatController {
     }
 
     try {
-      const data = JSON.parse(plaintext.toString('utf-8'));
+      let data = JSON.parse(plaintext.toString('utf-8'));
+
+      // Private-room layer: try each private buffer's key (active room first).
+      // Content we can't read (no key, or stale key) is dropped silently.
+      if (isRoomWrapped(data)) {
+        let inner = this.#activeSecrets
+          ? decryptRoomPayload(data, this.#activeSecrets.roomKey)
+          : null;
+        if (!inner) {
+          for (const buf of this.#buffers.values()) {
+            if (buf.secrets) {
+              inner = decryptRoomPayload(data, buf.secrets.roomKey);
+              if (inner) {
+                break;
+              }
+            }
+          }
+        }
+        if (!inner) {
+          return;
+        }
+        data = JSON.parse(inner);
+      }
 
       // Cover traffic: a decoy — drop it silently (no UI, no history, no receipt).
       if (isCover(data)) {
         return;
       }
 
+      // Which buffer this belongs to (the tag rides inside the E2EE envelope).
+      const msgRoom = this.#roomForIncoming(data, msg.from);
+      const roomActive = msgRoom === this.#currentRoom;
+
       if (data.action === 'clear') {
-        this.#ui.clearChat();
+        this.#ui.clearBuffer(msgRoom);
         return;
       }
 
       if (data.action === 'typing') {
-        this.#showPeerTyping(msg.from, peer.nickname);
+        if (roomActive) {
+          this.#showPeerTyping(msg.from, peer.nickname);
+        }
         return;
       }
 
       if (data.action === 'key_rotation') {
         this.#handshake.updatePeerKey(msg.from, data.newPublicKey);
+        peer.publicKey = data.newPublicKey;
         const p = this.#peers.get(msg.from);
         if (p) {
           p.publicKey = data.newPublicKey;
@@ -757,13 +1082,21 @@ export class ChatController {
       }
 
       if (data.action === 'presence') {
-        const p = this.#peers.get(msg.from);
-        if (p) {
+        // Presence lives on the global peer entry so it survives buffer
+        // switches; the active view (#peers) mirrors it.
+        const p = peer;
+        {
           const wasAway = !!p.away;
           const oldStatus = p.status || null;
           p.away = !!data.away;
           p.awayReason = typeof data.reason === 'string' ? data.reason.slice(0, 60) : null;
           p.status = typeof data.status === 'string' ? data.status.slice(0, 60) : null;
+          const view = this.#peers.get(msg.from);
+          if (view) {
+            view.away = p.away;
+            view.awayReason = p.awayReason;
+            view.status = p.status;
+          }
 
           if (p.away && !wasAway) {
             const why = p.awayReason ? ` (${p.awayReason})` : '';
@@ -779,15 +1112,21 @@ export class ChatController {
       }
 
       if (data.action === 'reaction') {
-        this.#ui.addSystemMessage(`${data.emoji} ${peer.nickname} reacted to a message`);
-        this.#ui.playNotification();
+        this.#ui.toBuffer(msgRoom, () => {
+          this.#ui.addSystemMessage(`${data.emoji} ${peer.nickname} reacted to a message`);
+        });
+        if (roomActive) {
+          this.#ui.playNotification();
+        }
         return;
       }
 
       if (data.action === 'edit_message') {
         const author = this.#messageAuthors.get(data.messageId);
         if (author && author === peer.nickname) {
-          this.#ui.addSystemMessage(`${peer.nickname} edited: ${data.newText} (edited)`);
+          this.#ui.toBuffer(msgRoom, () => {
+            this.#ui.addSystemMessage(`${peer.nickname} edited: ${data.newText} (edited)`);
+          });
         }
         return;
       }
@@ -795,28 +1134,42 @@ export class ChatController {
       if (data.action === 'delete_message') {
         const author = this.#messageAuthors.get(data.messageId);
         if (author && author === peer.nickname) {
-          this.#ui.addSystemMessage(`${peer.nickname} deleted a message`);
+          this.#ui.toBuffer(msgRoom, () => {
+            this.#ui.addSystemMessage(`${peer.nickname} deleted a message`);
+          });
         }
         return;
       }
 
       if (data.action === 'pin_message') {
-        this.#pinnedMessages.push({
+        const pins = roomActive ? this.#pinnedMessages : this.#buffers.get(msgRoom)?.pins;
+        pins?.push({
           messageId: data.messageId,
           nickname: data.nickname,
           text: data.text,
           pinnedBy: peer.nickname,
           pinnedAt: Date.now(),
         });
-        this.#ui.addSystemMessage(
-          `\uD83D\uDCCC ${peer.nickname} pinned: "${data.text}" \u2014 ${data.nickname}`,
-        );
+        this.#ui.toBuffer(msgRoom, () => {
+          this.#ui.addSystemMessage(
+            `\uD83D\uDCCC ${peer.nickname} pinned: "${data.text}" \u2014 ${data.nickname}`,
+          );
+        });
         return;
       }
 
       if (data.action === 'unpin_message') {
-        this.#pinnedMessages = this.#pinnedMessages.filter((p) => p.messageId !== data.messageId);
-        this.#ui.addSystemMessage(`${peer.nickname} removed a pin`);
+        if (roomActive) {
+          this.#pinnedMessages = this.#pinnedMessages.filter((p) => p.messageId !== data.messageId);
+        } else {
+          const buf = this.#buffers.get(msgRoom);
+          if (buf) {
+            buf.pins = buf.pins.filter((p) => p.messageId !== data.messageId);
+          }
+        }
+        this.#ui.toBuffer(msgRoom, () => {
+          this.#ui.addSystemMessage(`${peer.nickname} removed a pin`);
+        });
         return;
       }
 
@@ -831,35 +1184,63 @@ export class ChatController {
       // Persist to encrypted history — never ephemeral or deniable messages
       if (this.#historyStore?.isOpen && !data.ephemeral && !isDeniable && !data.deniable) {
         this.#historyStore.append({
-          room: this.#currentRoom,
+          room: msgRoom,
           nickname: peer.nickname,
           text: data.text,
           isDM: !!data.isDM,
         });
       }
 
-      if (data.replyTo?.nickname && typeof data.replyTo.excerpt === 'string') {
-        this.#ui.addQuoteLine(String(data.replyTo.nickname), data.replyTo.excerpt.slice(0, 80));
-      }
-
       const mentioned = this.#mentionsMe(data.text) && !data.isDM;
+      if (mentioned) {
+        this.#mentions.push({
+          nickname: peer.nickname,
+          text: data.text,
+          room: msgRoom,
+          at: Date.now(),
+        });
+        if (this.#mentions.length > MENTIONS_MAX) {
+          this.#mentions.shift();
+        }
+      }
+      // Away: count what's arriving and keep the header badge live.
+      if (this.#away) {
+        this.#awayUnread++;
+        if (mentioned) {
+          this.#awayMentions++;
+        }
+        this.#ui.setHeaderIndicator(
+          'away',
+          `{yellow-fg}[away · ${this.#awayUnread} new]{/yellow-fg}`,
+        );
+      }
       const ephLabel = data.ephemeral ? this.#formatDuration(data.ephemeral) : null;
       const trust = trustBadge(this.#trustStore.getPeerRecord(peer.nickname), peer.publicKey);
-      const { lineIndex } = this.#ui.addMessage(
-        peer.nickname,
-        data.text,
-        !!data.isDM,
-        ephLabel,
-        isDeniable || !!data.deniable,
-        mentioned,
-        trust,
-      );
+      // File the message into its buffer (live log when active, stored otherwise).
+      let lineIndex = -1;
+      this.#ui.toBuffer(msgRoom, () => {
+        if (data.replyTo?.nickname && typeof data.replyTo.excerpt === 'string') {
+          this.#ui.addQuoteLine(String(data.replyTo.nickname), data.replyTo.excerpt.slice(0, 80));
+        }
+        ({ lineIndex } = this.#ui.addMessage(
+          peer.nickname,
+          data.text,
+          !!data.isDM,
+          ephLabel,
+          isDeniable || !!data.deniable,
+          mentioned,
+          trust,
+        ));
+      });
+      this.#noteBufferUnread(msgRoom, mentioned);
       const notify = shouldNotify(this.#dndMode, this.#dndWindow, nowMinutes(), mentioned);
       if (notify) {
         this.#ui.playNotification();
       }
 
-      if (data.ephemeral && data.ephemeral > 0) {
+      // Ephemeral burn animation only makes sense on the live log; in an
+      // inactive buffer the message simply expires in place.
+      if (data.ephemeral && data.ephemeral > 0 && roomActive) {
         this.#scheduleEphemeralRemoval(lineIndex, data.ephemeral, peer.nickname);
       }
 
@@ -927,11 +1308,19 @@ export class ChatController {
         this.#ui.addInfoMessage('  /users               - List online users');
         this.#ui.addInfoMessage('  /msg <nick> <text>   - Send a private message (DM)');
         this.#ui.addInfoMessage('  /reply <text>        - Reply to the last received message');
-        this.#ui.addInfoMessage('  /away [reason]       - Mark yourself as away');
+        this.#ui.addInfoMessage('  /mentions [n]        - Recent mentions of you (this session)');
+        this.#ui.addInfoMessage('  /contacts [add|remove|all] - Contact book (aliases for peers)');
+        this.#ui.addInfoMessage(
+          '  /away [reason]       - Mark yourself as away (unreads are counted)',
+        );
         this.#ui.addInfoMessage('  /back                - Clear the away status');
         this.#ui.addInfoMessage('  /autoaway <min|off>  - Auto-away on inactivity');
+        this.#ui.addInfoMessage('  /lock                - Lock the screen (session passphrase)');
+        this.#ui.addInfoMessage('  /autolock <min|off>  - Auto-lock on inactivity');
         this.#ui.addInfoMessage('  /status <text|off>   - Set a status (accepts :emoji:)');
-        this.#ui.addInfoMessage('  /join <room>         - Join a room');
+        this.#ui.addInfoMessage('  /join <room> [pass]  - Join a room as a new buffer (Alt+1..9)');
+        this.#ui.addInfoMessage('  /leave [room]        - Leave a room (its buffer closes)');
+        this.#ui.addInfoMessage('  /create <room> <pass> - Create a private room 🔒');
         this.#ui.addInfoMessage('  /invite [host:port]  - Generate an invite with QR code');
         this.#ui.addInfoMessage('  /rooms               - List available rooms');
         this.#ui.addInfoMessage('  /room                - Show the current room');
@@ -984,6 +1373,10 @@ export class ChatController {
       case '/users': {
         const names = [...this.#peers.values()].map((p) => {
           let label = p.nickname;
+          const alias = this.#trustStore.getAlias(p.nickname);
+          if (alias) {
+            label += ` (${alias})`;
+          }
           if (p.away) {
             label += ` [away${p.awayReason ? `: ${p.awayReason}` : ''}]`;
           }
@@ -1192,12 +1585,61 @@ export class ChatController {
       }
 
       case '/join': {
-        const roomName = parts[1];
+        const roomName = parts[1]?.toLowerCase();
+        if (!roomName) {
+          this.#ui.addErrorMessage('Usage: /join <room> [password]');
+          break;
+        }
+        // Already have that buffer? Just focus it.
+        if (this.#buffers.has(roomName)) {
+          this.#switchToBuffer(roomName);
+          break;
+        }
+        const joinPassword = parts.slice(2).join(' ');
+        if (joinPassword) {
+          // Derive now so we can answer the server's challenge immediately.
+          this.#prepareRoomSecrets(roomName, joinPassword, () => {
+            this.#connection.send(createJoinRoom(roomName));
+          });
+        } else {
+          this.#connection.send(createJoinRoom(roomName));
+        }
+        break;
+      }
+
+      case '/create': {
+        const roomName = parts[1]?.toLowerCase();
         if (!roomName) {
-          this.#ui.addErrorMessage('Usage: /join <room>');
+          this.#ui.addErrorMessage('Usage: /create <room> <password>');
           break;
         }
-        this.#connection.send(createChangeRoom(roomName));
+        if (this.#buffers.has(roomName)) {
+          this.#ui.addErrorMessage(`You are already in #${roomName}`);
+          break;
+        }
+        const createPassword = parts.slice(2).join(' ');
+        if (!createPassword) {
+          // No password — same as joining/creating a public room.
+          this.#connection.send(createJoinRoom(roomName));
+          break;
+        }
+        this.#prepareRoomSecrets(roomName, createPassword, (secrets) => {
+          this.#connection.send(createJoinRoom(roomName, secrets.authPublicKey.toString('base64')));
+        });
+        break;
+      }
+
+      case '/leave': {
+        const target = (parts[1] || this.#currentRoom).toLowerCase();
+        if (!this.#buffers.has(target)) {
+          this.#ui.addErrorMessage(`You are not in #${target}`);
+          break;
+        }
+        if (this.#bufferOrder.length === 1) {
+          this.#ui.addErrorMessage('Cannot leave your last room');
+          break;
+        }
+        this.#connection.send(createLeaveRoom(target));
         break;
       }
 
@@ -1233,9 +1675,23 @@ export class ChatController {
         break;
       }
 
-      case '/room':
-        this.#ui.addInfoMessage(`Current room: #${this.#currentRoom}`);
+      case '/room': {
+        this.#ui.addInfoMessage(
+          `Current room: #${this.#currentRoom}${this.#activeSecrets ? ' 🔒 (private)' : ''}`,
+        );
+        if (this.#bufferOrder.length > 1) {
+          const list = this.#bufferOrder
+            .map((r, i) => {
+              const b = this.#buffers.get(r);
+              const mark = r === this.#currentRoom ? '*' : ' ';
+              const unread = b?.unread ? ` (${b.unread} unread)` : '';
+              return `  ${mark}${i + 1}. #${r}${b?.private ? ' 🔒' : ''}${unread}`;
+            })
+            .join('\n');
+          this.#ui.addInfoMessage(`Buffers (Alt+1..9):\n${list}`);
+        }
         break;
+      }
 
       case '/tips': {
         this.#tipIndex = (this.#tipIndex + 1) % TIPS.length;
@@ -1265,6 +1721,8 @@ export class ChatController {
       case '/away': {
         this.#away = true;
         this.#autoAwaySet = false; // an explicit /away is not auto
+        this.#awayUnread = 0;
+        this.#awayMentions = 0;
         this.#awayReason = applyShortcodes(parts.slice(1).join(' ')).slice(0, 60) || null;
         this.#ui.setHeaderIndicator('away', '{yellow-fg}[away]{/yellow-fg}');
         this.#ui.addInfoMessage(
@@ -1284,10 +1742,124 @@ export class ChatController {
         this.#autoAwaySet = false;
         this.#ui.removeHeaderIndicator('away');
         this.#ui.addInfoMessage("You're back");
+        this.#reportAwayUnread();
         this.#broadcastPresence();
         break;
       }
 
+      case '/contacts': {
+        const sub = (parts[1] || 'list').toLowerCase();
+
+        if (sub === 'add') {
+          const nick = parts[2];
+          const alias = parts.slice(3).join(' ').trim();
+          if (!nick || !alias) {
+            this.#ui.addErrorMessage('Usage: /contacts add <nick> <alias>');
+            break;
+          }
+          if (this.#trustStore.setAlias(nick, alias)) {
+            this.#ui.addInfoMessage(`Contact saved: ${nick} → "${alias.slice(0, 30)}"`);
+          } else {
+            this.#ui.addErrorMessage(
+              `"${nick}" was never seen on this identity — no trust record to alias`,
+            );
+          }
+          break;
+        }
+
+        if (sub === 'remove') {
+          const nick = parts[2];
+          if (!nick) {
+            this.#ui.addErrorMessage('Usage: /contacts remove <nick>');
+            break;
+          }
+          if (this.#trustStore.clearAlias(nick)) {
+            this.#ui.addInfoMessage(`Alias removed from ${nick}`);
+          } else {
+            this.#ui.addErrorMessage(`${nick} has no alias`);
+          }
+          break;
+        }
+
+        if (sub !== 'list' && sub !== 'all') {
+          this.#ui.addErrorMessage('Usage: /contacts [add <nick> <alias> | remove <nick> | all]');
+          break;
+        }
+
+        const contacts = this.#trustStore.listContacts(sub === 'all');
+        if (contacts.length === 0) {
+          this.#ui.addInfoMessage(
+            sub === 'all'
+              ? 'No peers known yet.'
+              : 'No contacts yet. Use /contacts add <nick> <alias>',
+          );
+          break;
+        }
+        this.#ui.addInfoMessage(sub === 'all' ? 'Known peers:' : 'Contacts:');
+        for (const c of contacts) {
+          const badge = c.verified ? ' ✓' : '';
+          const alias = c.alias ? ` (${c.alias})` : '';
+          const seen = c.lastSeen
+            ? ` — last seen ${new Date(c.lastSeen).toLocaleString('en-US', {
+                day: '2-digit',
+                month: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+              })}`
+            : '';
+          this.#ui.addInfoMessage(`  ${c.nickname}${alias}${badge}${seen}`);
+        }
+        break;
+      }
+
+      case '/mentions': {
+        if (this.#mentions.length === 0) {
+          this.#ui.addInfoMessage('No mentions in this session yet.');
+          break;
+        }
+        const count = Math.min(parseInt(parts[1], 10) || 10, this.#mentions.length);
+        this.#ui.addInfoMessage(`Last ${count} mention(s) of you:`);
+        for (const m of this.#mentions.slice(-count)) {
+          const when = new Date(m.at).toLocaleString('en-US', {
+            hour: '2-digit',
+            minute: '2-digit',
+          });
+          this.#ui.addInfoMessage(`  [${when}] [#${m.room}] ${m.nickname}: ${m.text.slice(0, 80)}`);
+        }
+        break;
+      }
+
+      case '/lock':
+        this.#lockNow();
+        break;
+
+      case '/autolock': {
+        const alArg = parts[1]?.toLowerCase();
+        if (alArg === 'off' || alArg === '0') {
+          this.#autoLockMs = 0;
+          this.#armAutoLock();
+          this.#ui.addInfoMessage('Auto-lock disabled');
+          break;
+        }
+        const alMin = parseInt(alArg, 10);
+        if (!Number.isInteger(alMin) || alMin < 1 || alMin > 240) {
+          this.#ui.addInfoMessage(
+            `Auto-lock: ${this.#autoLockMs ? `${this.#autoLockMs / 60000}min` : 'off'}. Usage: /autolock <minutes|off>`,
+          );
+          break;
+        }
+        if (!this.#passphrase) {
+          this.#ui.addErrorMessage(
+            'No session passphrase — auto-lock needs one (set it at startup)',
+          );
+          break;
+        }
+        this.#autoLockMs = alMin * 60_000;
+        this.#armAutoLock();
+        this.#ui.addInfoMessage(`Auto-lock after ${alMin}min of inactivity`);
+        break;
+      }
+
       case '/autoaway': {
         const aaArg = parts[1]?.toLowerCase();
         if (aaArg === 'off' || aaArg === '0') {
@@ -1915,7 +2487,15 @@ export class ChatController {
         if (this.#pluginManager) {
           const result = this.#pluginManager.handleCommand(cmd, parts.slice(1));
           if (result) {
-            this.#ui.addInfoMessage(result);
+            // Plugin API: `{ send }` goes to the room as a normal E2EE
+            // message; `{ info }` or a plain string stays local.
+            if (typeof result === 'object' && typeof result.send === 'string' && result.send) {
+              this.#sendMessageToAll(result.send);
+            } else if (typeof result === 'object' && typeof result.info === 'string') {
+              this.#ui.addInfoMessage(result.info);
+            } else if (typeof result === 'string') {
+              this.#ui.addInfoMessage(result);
+            }
             break;
           }
         }
@@ -2004,45 +2584,166 @@ export class ChatController {
     this.#ui.addSystemMessage(`${peer.nickname} updated key (via server — unauthenticated)`);
   }
 
-  // ── Handle ROOM_CHANGED (after /join) ──────────────────────
+  // ── Private rooms: derive secrets off the input handler ─────
+  // Argon2id (MODERATE) blocks for ~1s — let the UI paint the notice first.
+  #prepareRoomSecrets(roomName, password, onReady) {
+    const room = roomName.toLowerCase();
+    this.#ui.addInfoMessage('Deriving room key (Argon2id)…');
+    setImmediate(() => {
+      freeRoomSecrets(this.#pendingRoomSecrets);
+      const secrets = deriveRoomSecrets(room, password);
+      this.#pendingRoomSecrets = { room, ...secrets };
+      onReady(secrets);
+    });
+  }
+
+  // ── Handle ROOM_CHALLENGE (target room is private) ──────────
+  #onRoomChallenge(msg) {
+    const pending = this.#pendingRoomSecrets;
+    if (!pending || pending.room !== msg.room) {
+      this.#ui.addErrorMessage(`Room #${msg.room} is private. Usage: /join ${msg.room} <password>`);
+      return;
+    }
+    const signature = signRoomChallenge(
+      pending.authSecretKey,
+      msg.room,
+      msg.nonce,
+      this.#sessionId,
+    );
+    this.#connection.send(createRoomAuth(msg.room, msg.nonce, signature.toString('base64')));
+  }
+
+  // Promote pending password-derived secrets once the server confirms the
+  // room really is private; warn when it isn't (old server or needless password).
+  #promotePendingSecrets(room, isPrivate) {
+    let secrets = null;
+    if (this.#pendingRoomSecrets?.room === room) {
+      if (isPrivate) {
+        secrets = this.#pendingRoomSecrets;
+      } else {
+        freeRoomSecrets(this.#pendingRoomSecrets);
+        this.#ui.addErrorMessage(
+          'WARNING: the server treated this room as PUBLIC — anyone can join.',
+        );
+      }
+      this.#pendingRoomSecrets = null;
+    } else if (this.#pendingRoomSecrets) {
+      freeRoomSecrets(this.#pendingRoomSecrets);
+      this.#pendingRoomSecrets = null;
+    }
+    return secrets;
+  }
+
+  #announceJoinedRoom(room, isPrivate, peerNames) {
+    if (isPrivate) {
+      this.#ui.addSystemMessage(`You joined private room #${room} 🔒`);
+      this.#ui.addInfoMessage('Messages here get an extra layer encrypted with the room key.');
+    } else {
+      this.#ui.addSystemMessage(`You joined room #${room}`);
+    }
+    if (peerNames.length > 0) {
+      this.#ui.addSystemMessage(`Online: ${peerNames.join(', ')}`);
+    }
+    if (this.#away || this.#statusText) {
+      this.#broadcastPresence();
+    }
+  }
+
+  // ── Handle ROOM_CHANGED (legacy full switch — also how a kick lands) ──
+  // change_room semantics: every buffer is dropped, we exist only in msg.room.
   #onRoomChanged(msg) {
-    this.#currentRoom = msg.room;
-    this.#ui.setRoom(this.#currentRoom);
-    this.#currentRoomOwner = msg.roomOwner || null;
+    const secrets = this.#promotePendingSecrets(msg.room, !!msg.private);
 
-    // Clear old peers and pins
-    this.#peers.clear();
-    this.#pinnedMessages = [];
+    this.#resetBuffersTo(msg.room, {
+      isPrivate: !!msg.private,
+      owner: msg.roomOwner || null,
+      secrets,
+    });
+    this.#currentRoomOwner = msg.roomOwner || null;
 
-    // Populate with new room peers
     for (const peer of msg.peers) {
-      this.#peers.set(peer.sessionId, {
+      this.#allPeers.set(peer.sessionId, {
         nickname: peer.nickname,
         publicKey: peer.publicKey,
+        rooms: new Set([msg.room]),
       });
-
-      // Register ratchet if new peer
       if (!this.#handshake.getRatchet(peer.sessionId)) {
         this.#handshake.registerPeer(peer.sessionId, peer.publicKey);
       }
-
       this.#checkTrust(peer.nickname, peer.publicKey);
     }
 
-    const peerNames = [...this.#peers.values()].map((p) => p.nickname);
-    this.#ui.setOnlineCount(this.#peers.size + 1);
-    this.#ui.setPeerNames(peerNames);
+    this.#rebuildActivePeers();
     this.#auditLog.log(AuditEvent.ROOM_CHANGED, { room: msg.room });
-    this.#ui.addSystemMessage(`You joined room #${msg.room}`);
+    this.#announceJoinedRoom(
+      msg.room,
+      !!secrets,
+      [...this.#peers.values()].map((p) => p.nickname),
+    );
+    this.#saveLastSession(!!msg.private);
+  }
 
-    if (peerNames.length > 0) {
-      this.#ui.addSystemMessage(`Online: ${peerNames.join(', ')}`);
+  // ── Handle ROOM_JOINED (additive join — new buffer, focused) ──
+  #onRoomJoined(msg) {
+    const secrets = this.#promotePendingSecrets(msg.room, !!msg.private);
+    this.#ensureBuffer(msg.room, {
+      isPrivate: !!msg.private,
+      owner: msg.roomOwner || null,
+      secrets,
+    });
+
+    for (const peer of msg.peers || []) {
+      const existing = this.#allPeers.get(peer.sessionId);
+      if (existing) {
+        existing.rooms.add(msg.room);
+      } else {
+        this.#allPeers.set(peer.sessionId, {
+          nickname: peer.nickname,
+          publicKey: peer.publicKey,
+          rooms: new Set([msg.room]),
+        });
+        if (!this.#handshake.getRatchet(peer.sessionId)) {
+          this.#handshake.registerPeer(peer.sessionId, peer.publicKey);
+        }
+      }
+      this.#checkTrust(peer.nickname, peer.publicKey);
     }
 
-    // The new room doesn't know my presence
-    if (this.#away || this.#statusText) {
-      this.#broadcastPresence();
+    this.#auditLog.log(AuditEvent.ROOM_CHANGED, { room: msg.room, additive: true });
+    this.#switchToBuffer(msg.room);
+    this.#announceJoinedRoom(
+      msg.room,
+      !!secrets,
+      [...this.#peers.values()].map((p) => p.nickname),
+    );
+    this.#updateBufferBar();
+  }
+
+  // ── Handle ROOM_LEFT (we left one room; buffer dies) ─────────
+  #onRoomLeft(msg) {
+    const room = msg.room;
+    const wasActive = room === this.#currentRoom;
+    this.#dropBufferState(room);
+
+    // Peers we only shared that room with are gone for us now.
+    for (const [sid, p] of [...this.#allPeers]) {
+      p.rooms.delete(room);
+      if (p.rooms.size === 0) {
+        this.#hidePeerTyping(sid, p.nickname);
+        this.#handshake.removePeer(sid);
+        this.#nonceManager.removePeer(sid);
+        this.#allPeers.delete(sid);
+      }
     }
+
+    if (wasActive && this.#bufferOrder.length > 0) {
+      this.#switchToBuffer(this.#bufferOrder[0]);
+    } else {
+      this.#rebuildActivePeers();
+      this.#updateBufferBar();
+    }
+    this.#ui.addSystemMessage(`You left #${room}`);
+    this.#auditLog.log(AuditEvent.ROOM_CHANGED, { room, left: true });
   }
 
   // ── Handle ROOM_LIST ───────────────────────────────────────
@@ -2050,7 +2751,8 @@ export class ChatController {
     this.#ui.addInfoMessage('Available rooms:');
     for (const room of msg.rooms) {
       const current = room.name === this.#currentRoom ? ' (current)' : '';
-      this.#ui.addInfoMessage(`  #${room.name} — ${room.memberCount} member(s)${current}`);
+      const lock = room.private ? ' 🔒' : '';
+      this.#ui.addInfoMessage(`  #${room.name}${lock} — ${room.memberCount} member(s)${current}`);
     }
   }
 
@@ -2106,6 +2808,11 @@ export class ChatController {
     if (!tracked) {
       return;
     }
+    // Line indexes are only valid on the live log — skip the ✓✓ update when
+    // the message's buffer isn't on screen (multi-room v1 limitation).
+    if (tracked.room && tracked.room !== this.#currentRoom) {
+      return;
+    }
 
     let readers = this.#messageReaders.get(messageId);
     if (!readers) {
@@ -2126,7 +2833,7 @@ export class ChatController {
     if (baseLine === null || baseLine === undefined) {
       return;
     }
-    this.#sentMessageLines.set(messageId, { lineIndex, baseLine });
+    this.#sentMessageLines.set(messageId, { lineIndex, baseLine, room: this.#currentRoom });
 
     // Bound memory: keep only the most recent 200 tracked messages
     if (this.#sentMessageLines.size > 200) {
@@ -2165,6 +2872,13 @@ export class ChatController {
       return;
     }
 
+    // Tag with the active room (inside the E2EE envelope), then the private
+    // room's extra symmetric layer when there is one.
+    payload = this.#tagRoom(payload);
+    if (this.#activeSecrets) {
+      payload = encryptRoomPayload(payload, this.#activeSecrets.roomKey);
+    }
+
     const ratchet = this.#handshake.getRatchet(peerId);
     if (ratchet && ratchet.isInitialized) {
       try {
@@ -2282,6 +2996,14 @@ export class ChatController {
 
   // ── Broadcast encrypted payload to all peers ───────────────────
   #broadcastPayload(payload, deniable = false) {
+    // Tag with the active room (inside the E2EE envelope), then the private
+    // room's extra symmetric layer, so even a relay-injected member can't
+    // read the room without the password.
+    payload = this.#tagRoom(payload);
+    if (this.#activeSecrets) {
+      payload = encryptRoomPayload(payload, this.#activeSecrets.roomKey);
+    }
+
     for (const [peerId] of this.#peers) {
       const peerPublicKey = this.#handshake.getPeerPublicKey(peerId);
       if (!peerPublicKey) {